C/C++ - Creare un ciclo for oscillante

Per distrarmi dalle porcherie che i "vertici" stanno facendo ANCHE nel mondo della scuola, ho voluto strafare. Ecco un programmino che crea pure un grafico della "oscillazione" del valore.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void oscilla_ocariddi( int lim, unsigned int qOsc );

int main() {
    oscilla_ocariddi( 3, 6 );
    return 0;
}

void *crea_array_2d( size_t dim_elem, size_t w, size_t h ) {
    size_t dimRiga = w*dim_elem;
    size_t dimPtr  = sizeof(void*);

    void *a2d = calloc( h, dimPtr+dimRiga );

    if( a2d ) {
        void *y = a2d;
        void *x = a2d + h*dimPtr;

        while( h ) {
            memcpy( y, &x, dimPtr );
            y += dimPtr;
            x += dimRiga;
            --h;
        }
    }

    return a2d;
}

// attenzione: m non viene verificato!
void mostra_matrice( char **m, size_t qx, size_t qy ) {
    size_t x, y;

    for( y=0; y<qy; ++y ) {
        for( x=0; x<qx; ++x ) {
            char c = m[y][x];
            printf( "%c", c?c:' ' );
        }

        printf( "\n" );
    }
}

void oscilla_ocariddi( int lim, unsigned int qOsc ) {
    if( lim )  { // come oscilla intorno allo zero, se e' zero?
        size_t qx = 4*lim*qOsc+1; // ci sono qx "campioni" nel grafico
        size_t qy = 2*lim+1; // ci sono qy possibili valori per y
        size_t o = lim>0 ? lim : -lim; // o: offset, centra y nel grafico
        unsigned int qZeri = 1; // conta la quantita' di incroci con lo zero
        unsigned int maxZeri = qOsc*2+1; // quantita' massima d'incroci con zero
        size_t x = 0; // x e' per forza positivo
        int y = 0; // y oscilla tra positivo e simmetrico negativo

        char **m = crea_array_2d( sizeof(char), qx, qy );
        if( !m ) { puts( "Allocazione fallita" ); return; }

        while( qZeri<=maxZeri ) {
            m[o-y][x] = '*';
            qZeri += 0==y;
            lim = (y+=lim>0?1:-1)!=lim?lim:-lim;
            ++x;
        }

        mostra_matrice( m, qx, qy );
        free( m ); m = NULL;
    }
}

Ora vado a dormire. Spero di riuscire a reggere il sonno, perché appena smetto di impegnare i neuroni con if, then, else, for, while ecc. mi torna in mente il modo in cui mi (ci) stanno fregando e mi monta la iena in corpo. Magari mi ingollo qualche goccina, va'.
Ciao, programmatori. Dita incrociate.

Si potrebbe usare anche una Funzione ricorsiva

La Funzione richiama se stessa modificando i parametri iniziali a ogni step

Be ragazzi credo di aver trovato una soluzione abbastanza semplice e voglio condividerla, datemi un vostro giudizio:

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

 int main()
 {
 
 int i ;
 int a = 0; // inizializzo il punto di partenza
 int b = 10; // inizializzo il punto di arrivo
 int c = 1 ; // inizializzo il verso di conteggio
 int conta0 = 0;
 
for (i=a; i<=b; i+=c) 
{
	if (i == 10 || i == -10) c *= -1 ; // quando il conteggio arriva a 10 o -10 inverto il verso di conteggio
		
	printf("%d \n", i); // stampo i
                        
	if (i == 0) conta0++; // conto i passaggi per lo 0
	if (conta0 == 3) break; // se ci passo 3 volte termino il ciclo
}
}

Il mio Nick "Goblin" ha una visione fantasy forse più vicina a quella di Tolkien nell'Hobbit, ma la definizione che preferisco è quella di uno spiritello che si intromette in tutto e per tutto prendendo il mondo in maniera burlesca e leggera fregandosene altamente di tutto ciò che lo circonda e che pensa solo al divertimento momentaneo.



Questa è interessante !!!



Giusto per restare in tema ... di "rompiballe"
Io, nella mia profonda ignoranza, ho sempre visto il ciclo "for" come un ciclo chiuso ossia l'indice va A a B.
Se nel caso serve lavorare su un indice che può essere modificato, nel suo valore, da eventi esterni sono sempre stato più propenso ad usare cicli "anonimi" come while/repeat, ma come ho detto questa è una mia opinione.

G.

So di non fare un bella figura, perché sembra che io voglia fare quel che non sono in grado di fare, cioè il "maestrino puntiglioso", però ho bisogno di tenere la testa impegnata con qualcosa, che questa notte mi son svegliato dopo neanche tre ore di sonno con un attacco di panico da togliere il fiato, e non ho più chiuso occhio. (desidero ringraziare pubblicamente tutte quelle "belle personcine" che per i loro luridi interessi ci stanno rovinando la vita -- ma lo fanno per il nostro bene, eh!)

#include <stdio.h>
/* #include <string.h> e' superflua per questo programma */
/* #include <math.h>   e' superflua per questo programma */

int main() {
    int i ;
    // int a = 0;  // inizializzo il punto di partenza
    
    /* questa variabile la usi solo per inizializzare i, non e'               **
    ** inutile? puoi mettere direttamente i=0 nel ciclo for, no?              */
    
    int b = 10; // inizializzo il punto di arrivo
    
    /* questa variabile b invece ha un senso in caso si volesse modificare    **
    ** il punto di arrivo senza dover "toccare" altri punti del codice        */
    
    int c = 1 ; // inizializzo il verso di conteggio
    int conta0 = 0;

    for (i=0; /*i<=b*/; i+=c) { /* i e' sempre <= b, quindi perche' verificarlo? */
        if (i == b || i == -b) c *= -1 ; // quando il conteggio arriva a 10 o -10 inverto il verso di conteggio

        printf("%d \n", i); // stampo i

        if (i == 0) conta0++; // conto i passaggi per lo 0
        
        /* ti bisbiglio un trucchetto che ho trovato non so piu' dove, per    **
        ** ridurre il rischio di errori: nei confronti con == mettere prima   **
        ** la costante e dopo la variabile, in modo che se per errore scrivi  **
        ** = anziche' == il compilatore non compila e ti segnala l'errore     **
        ** tipo: 0 == i anziche' i == 0; se uno non sbaglia a scrivere e'     **
        ** esattamente la stessa cosa, ma se si distrae, questo e' una specie **
        ** di cicalino d'allarme                                              */
        
        if (conta0 == 3) break; // se ci passo 3 volte termino il ciclo
        
        /* volendo, questo potresti spostarlo nel secondo elemento del for,   **
        ** nella forma conta0<3: for (i=0; conta0<3; i+=c), il risultato non  **
        ** cambia.                                                            */
    }
}

Grazie mille a tutti

Scusa ... mi sembra che ci siano degli elementi del codice che ti avevo suggerito, solo che io ti avevo scritto 4 righe da utilizzare immediatamente ... tu l'hai inutilmente complicato ...

Comunque ... fai come vuoi ...

Ciao, Goblin, AldoBaldo, nessuno, Ultimo, nello79.
Ho visto i vostri codici in Pascal/C/C++
non è che poi il for oscilli più di tanto, sono artifizi che alla fine restituiscono un valore in una variabile che oscilla, allora la funzione che oscilla più di tutte è la funzione seno, scusate se posto in C#:

           double a;
double b;

for (a = 0; a <= 6.3F; a += 0.1F)
{
   b = Math.Round(Math.Sin(a) * 10);
   Console.WriteLine(b.ToString());
}

non mi insultate, bisogna passare il tempo...