C/C++ - Creare un ciclo for oscillante

Carlo, perché vuoi togliermi il sottile piacere di insultare qualcuno, chiunque sia?
Scherzi a parte, la tua soluzione non mi sarebbe mai e poi mai venuta in mente, eppure è così sensata!

Ho anche raccolto lo spunto di... quell'altro là che non esiste... e ho fatto una versione ricorsiva, tiè!

#include <stdio.h>

int ciclamino( int lim, int val, int qZeri ) {
    if( qZeri>=0 ) {
        int dir = val<lim?1:-1;

        printf( "%d\n", val );
        qZeri += !val;
        val += dir;

        return qZeri<3 ? ciclamino(lim*(val==lim?-1:1),val,qZeri) : -1;
    }

    return qZeri;
}

int main() {
    ciclamino( 5, 0, 0 );
}

La questione è che sin() non dà luogo a una progressione lineare, ma a una curva che alterna tratti più "ripidi" a tratti meno "ripidi". Per questo la serie di valori in uscita (arrotondati all'intero) presenta dei salti e delle fasi di stasi.

#include <stdio.h>
#include <math.h>

int main() {
    double a, inc=(M_PI+M_PI)/40.0;

    for( a=0; a<=M_PI+M_PI; a+=inc )
       printf( "%d\n", (int)round(sin(a)*10.0) );
}

Rimane comunque un'idea alla quale non avrei pensato, il che mi fa sentire un po' tonno.

Nella domanda non si menziona che la serie deve essere progressiva o che deve essere composta da soli interi, secondo me la progressione generata dal mio e dal tuo programma con la funzione seno, risponde correttamente ai requisiti della domanda, comunque eliminare i doppioni con un if è facile...

Domada a chi lo sa, mi piacerebbe far girare i codici C di AldoBaldo, nel mio VisualStudio con C++

per esempio l'ultimo codice postato:

    #include <stdio.h>
#include <math.h>
     
int main() {
double a, inc=(M_PI+M_PI)/40.0;
     
    for( a=0; a<=M_PI+M_PI; a+=inc )
       printf( "%d\n", (int)round(sin(a)*10.0) );
    }

ricevo errore su M_PI e su round "identificatore non definito"
ho provato ad includere la libreria <cmath.h>, che dovrebbe contenere round, ma non funziona lo stesso.

Uso gcc e mingw, quindi può essere che ci siano alcune parti che sono specifiche di quell'ambiente. Purtroppo non ho l'esperienza e le conoscenze sufficienti per scendere in dettagli che vadano oltre il livello "passatempo". Ho comunque trovato in math.h le definizioni delle costanti tra le quali si trova anche M_PI. Puoi sostituire la macro con il valore che rappresenta, sicuramente funzionerebbe.

/* Traditional/XOPEN math constants (double precison) */
#ifndef __STRICT_ANSI__
#define M_E		2.7182818284590452354
#define M_LOG2E		1.4426950408889634074
#define M_LOG10E	0.43429448190325182765
#define M_LN2		0.69314718055994530942
#define M_LN10		2.30258509299404568402
#define M_PI		3.14159265358979323846
#define M_PI_2		1.57079632679489661923
#define M_PI_4		0.78539816339744830962
#define M_1_PI		0.31830988618379067154
#define M_2_PI		0.63661977236758134308
#define M_2_SQRTPI	1.12837916709551257390
#define M_SQRT2		1.41421356237309504880
#define M_SQRT1_2	0.70710678118654752440
#endif

Nello stesso file di #include, round() appare così:

/* 7.12.9.6 */
/* round away from zero, regardless of fpu control word settings */
extern double __cdecl round (double);
extern float __cdecl roundf (float);
extern long double __cdecl roundl (long double);

Però in effetti round() non è nella mia documentazione riguardante la libreria standard. Boh!
Prova a sostituirla con questa, che se non mi sono rimbambito del tutto dovrebbe fare la stessa cosa:

double mio_round( double v ) {
    return v>=0.0 ? v+0.5 : v-0.5;
}

si con il valore P_greco impostato a mano e con il codice che sostituisce round funziona ma non appaiono gli uno sul risultato.
Con VS2017 round viene riconosciuto, M_PI no.
Il ciclo lo avevo fatto arrivare a 6.3 invece che a 2P_greco, perchè cosi la funzione seno ritorna a 0

il tuo codice C++ in VS2017:

#include "stdafx.h"
#include <stdio.h>
#include <math.h>
     
int main()
{
double a, inc=(.1);
     
for(a = 0; a <= 6.3F; a+=inc)
     printf("%d\n", (int)round(sin(a)*10.0));
}

Infatti ...

Fondamentalmente non è un discorso sbagliato, se non fosse solo per l'inefficienza del calcolo delle funzioni trigonometriche e del trattamento dei valori reali rispetto all'uso di semplici interi.

Ma per passare il tempo ...

Sì, ma che noia questo forum! Nessuno che commenta, nessuno che scrive...

ATTENZIONE ancora per passatempo



Ho controllato il tuo codice con interi gira circa 200 volte più velocemente del mio con i double.
li ho looppati 100000 volte, con il writeline remmato, l'istruzione più lenta in assoluto di tutto il codice.
C#

using System;
using System.Diagnostics;

namespace ForOscillante1
// creare un ciclo for in cui l'indice vada prima da 0 a 10, poi da 10 a - 10 e poi dinuovo da - 10 a 0
{
    class Program
    {
        static void Main(string[] args)
        {
            int i;
            Stopwatch Inizio = new Stopwatch();

            // approcio con funzione seno e double
            double a, b, c = -1;
            Inizio.Reset();
            Inizio.Start();
            for (i = 0; i <= 100000; i++)
            {
                for (a = 0; a <= 6.3F; a += 0.1F)
                {
                    b = Math.Round(Math.Sin(a) * 10);
                    if (b != c) // per uniformare il risultato stampo solo i dati validi
                    {
                        // Console.WriteLine(b.ToString());
                        c = b;
                    }
                }
            }
            Console.WriteLine("con sin() e double " + Inizio.ElapsedMilliseconds + " ms.");
            Console.WriteLine("---------------- ");
            // -----------------------------------------------------------------------------

            // approcio con interi
            int A, B, S = 1;
            Inizio.Reset();
            Inizio.Start();
            for (i = 0; i <= 100000; i++)
            {
                for (A = B = 0; A <= 40; A++, B += S)
                {
                   // Console.WriteLine(B.ToString());
                    if (B == 10 || B == -10) S = -S;
                }
            }
            Console.WriteLine("nessuno e interi " + Inizio.ElapsedMilliseconds + " ms.");
            Console.WriteLine("---------------- ");
            // -----------------------------------------------------------------------------

           
        }
    }
}