C/C++ - Creare un ciclo for oscillante

Salve ragazzi, sono un nuovo iscritto e vi anticipo che sono alle prime armi con la programmazione in c. Chiedo ai più esperti se è possibile 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. Grazie in anticipo a chi può aiutarmi.

Invece di un ciclo "for", così senza avere una soluzione scritta, hai pensato ad un while ?
G.

Ma questo ciclo si deve ripetere o deve essere fatto solo una volta?

No una sola volta. In che modo il ciclo while?

In C, "al volo" non saprei scriverlo, ci vorrebbe AldoBaldo ... lo butto giù in pascal...

procedure ciclo;
Var a: Integer;
      b: Boolean;
begin
  a := 0;
  b := True;
  while a<11 do // giro sino a quando a<11
  begin
    Write(a);
    if b then
      inc(a)  // incremento a
    else
      dec(a);  // decremento a
    if (a=10) or (a=-10) then //cambio giro quando sono ai estremi
      b := not b;
    if (a=0) and b then  //quando torna a 0 stoppo tutto
    begin
      write(a);
      break;
    end;
  end;

end;

Scritto "al volo" non testato ... ma la logica credo si capisce

G.

Potrebbe essere un ' idea.

Direi che potresti scrivere

int a, b, s=1;
for (a = b = 0; a <= 40; a++, b += s)
{
	printf("%d ", b);
	
	
	if (b == 10 || b==-10) s = -s;
}

Io ho seguito un ragionamento un po' diverso da quelli proposto dal goblin e da... solo lui, perché non c'è nessun altro.

Prima di tutto ho fatto questo, che porta la variabile i a "ciclare" all'infinito tra un limite dato e il suo simmetrico di segno opposto. Per orientare il movimento, viene impostata una variabile dir (per "direzione" che sarà 1 se il limite è positivo, -1 se il limite è negativo. Da notare: questa funzione "gela" il programma, poiché lo "impalla" in una continua ripetizione degli stessi calcoli.

void oscilla_ocariddi( int lim ) {
    if( lim )  { // come oscilla intorno allo zero, se e' zero?
        int dir = lim>0 ? 1 : -1; // la direzione punti verso il limite
        int i = 0;

        while(1) { // all'infinito
            printf( "%d\n", i );
            i += dir;

            if( i==lim ) {
                dir = -dir; // inverte la direzione dell'incremento
                lim = -lim; // limite simmetrico rispetto allo zero
            }
        }
    }
}

Come si può notare, la funzione "rifiuta" di impiegare lo zero come parametro, anche perché se i valori devono "oscillare" attorno allo zero, dare limite zero significa impedire l'oscillazione.

In un secondo tempo ho posizionato un valore che agisce da "condizione di fermo" (qZeri, ovvero quantità di zeri), valore che viene incrementato ad ogni "incrocio" di i con lo zero fino a raggiungere una quantità massima determinata dalla quantità delle oscillazioni richieste. Se viene richiesta una sola oscillazione, maxZeri sarà 3, poiché i partirà da zero per raggiungere il limite massimo, quindi invertirà la direzione puntando al simmetrico di segno opposto del limite, attraversando nuovamente lo zero, quindi invertirà ancora una volta la direzione puntando al limite originale ma fermandosi al terzo raggiungimento dello zero. Ogni oscillazione aggiuntiva comporterà due ulteriori incroci con lo zero.

void oscilla_ocariddi( int lim, unsigned int qOsc ) {
    if( lim )  { // come oscilla intorno allo zero, se e' zero?
        unsigned int qZeri = 1; // conta la quantita' di incroci con lo zero
        unsigned int maxZeri = qOsc*2+1; // quantita' massima d'incroci con zero
        int dir = lim>0 ? 1 : -1; // la direzione punti verso il limite
        int i = 0;

        while( qZeri<=maxZeri ) {
            printf( "%d\n", i );
            qZeri += 0==i;
            i += dir;

            if( i==lim ) {
                dir = -dir; // inverte la direzione dell'incremento
                lim = -lim; // limite simmetrico rispetto allo zero
            }
        }
    }
}

Volendo si potrebbe anche eliminare la variabile dir, però in quel caso la direzione andrebbe ricalcolata ad ogni ripetizione del ciclo.

void oscilla_ocariddi( int lim, unsigned int qOsc ) {
    if( lim )  { // come oscilla intorno allo zero, se e' zero?
        unsigned int qZeri = 1; // conta la quantita' di incroci con lo zero
        unsigned int maxZeri = qOsc*2+1; // quantita' massima d'incroci con zero
        int i = 0;

        while( qZeri<=maxZeri ) {
            printf( "%d\n", i );
            qZeri += 0==i;
            lim = (i+=lim>0?1:-1)!=lim?lim:-lim;
        }
    }
}

Ammetto che quest'ultima formulazione l'ho scritta apposta in modo fumoso.

P.S. Ho trovato questa definizione di "goblin", ben poco lusinghiera: "...esseri crudeli, barbarici e poco civilizzati, creature spesso fetide e poco apprezzate dalle altre razze. Sebbene in alcuni ambiti siano considerati molto inclini alla creatività e all'ingegno, cedono volentieri all'impeto e alle passioni, prediligendole quindi ad un raziocinio maggiormente ponderato e alle decisioni sofferte." Non credo tu ti ci riconosca, dai!