Discussione Ufficiale Programmiamo con Inforge | Esercitazione 05 in C | Livello difficile

Una Discussione Ufficiale punta a raccogliere tutte le informazioni su un argomento o un fatto di attualità, con costanti aggiornamenti da parte del creatore e dei partecipanti.

Not an engineer

Moderatore
31 Ottobre 2011
2,716
100
1,202
1,091
Ultima modifica:
main.png


Programmiamo con Inforge | Presentazione

Ad oggi, sul web, si trovano moltissime guide sui vari linguaggi di programmazione e sulle loro molteplici applicazioni. Tuttavia, chi si approccia a queste risorse, non sempre riesce a mettere in pratica ciò che ha appreso. Al fine di limitare queste mancanze, nasce Programmiamo con Inforge.

In questa rubrica potrai scrivere codice per la risoluzione di alcuni problemi legati alla programmazione, mettendo in pratica quanto stai apprendendo dalla teoria oppure mostrando le tue abilità e competenze nel campo dell’informatica.


Partiamo dalle basi del C

In questa guida puoi trovare i testi per studiare e approfondire il C: I migliori libri per imparare e approfondire il C
In questa discussione puoi trovare le risposte alle domande più frequenti su come scrivere codice in C: Frequently asked questions: da dove si parte?


Esercitazione 05 in C | Livello difficile | [Spirale]


Soluzioni


Per rendere l'esercitazione più interessante, non verrà pubblicata alcuna soluzione! Spetterà a te scrivere la tua versione del codice e pubblicarla in questo thread così che possa essere valutata dai moderatori e dalla community; il modo migliore per imparare!

Conclusioni


Pubblica la soluzione ottimale per risolvere gli esercizi e ricorda che puoi confrontarti con il resto della community in questo thread, chiedere aiuto o aiutare gli altri ;)
 
Soluzione meme, probabilmente si comporta peggio delle altre soluzioni ma è stato divertente scriverla.
Non ho pulito o riletto il codice.
Non ho messo input il codice è settato per una matrice 30x30 e per cambiare le dimensioni bisogna cambiare il valore di n nel main.
Ho testato con successo fino a una matrice 20k x 20k dopo di che inizia ad avere qualche problema di allocazione :v

C:
#include <stdio.h>
#include <stdlib.h>
int** start(int n);
void right(int** mat,int i,int x, int n);
void down(int** mat, int i,int x, int n);
void left(int** mat, int i,int x, int n);
void up(int** mat, int i,int x, int n);
int** start(int n){
    int** result = (int**)calloc(1,n*sizeof(int*)+n*n*sizeof(int));
    if (result == NULL){
        fprintf(stderr, "Sbiriguda");
        exit(1);
    }
    int**pstart=result;
    int*dstart=(int*)(result+n);
    for (int i=0;i<n;++i){
        *pstart++=dstart;
        dstart=dstart+n;
    }
    right(result,0,1,n);
    return result;
}
void right(int** mat, int i, int x, int n){
    for(int j=i; j<n-i;j++){
        mat[i][j]=x++;
    }
    if(x<=n*n){
        down(mat,i,x,n);
    }
}
void down(int** mat, int i, int x, int n){
    for(int j=i+1; j<n-i;j++){
        mat[j][n-1-i]=x++;
    }
    if(x<=n*n){
        left(mat,i,x,n);
    }
}
void left(int** mat, int i, int x, int n){
    for(int j=n-i-2; j>=i;j--){
        mat[n-1-i][j]=x++;
    }
    if(x<=n*n){
        up(mat,i,x,n);
    }
}
void up(int** mat, int i, int x, int n){
    for(int j=n-i-2; j>=i+1;j--){
        mat[j][i]=x++;
    }
    if(x<=n*n){
        right(mat,++i,x,n);
    }
}
int main(){
    int n=30;
    int **mat=start(n);
    for (int i=0; i<n;i++){
        for (int j=0; j<n; j++){
            printf("%3d ",mat[i][j]);
        }
        printf("\n");
    }
    return 0;
}
 
bello !

anche se tardi ho giocato anche io

Codice:
/*
 * Siprale, per inforge
 *
 * in linux (o mingw):
 *    gcc -o spirale main.c
 */

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

void err(char *msg)
{
    printf("error: %s\n", msg);
    exit(1);
}

enum senso {
    dx,
    giu,
    sx,
    su,
};

/*
 * Spirale ha
 */
void crea_spirale(int n)
{
    int i, q, val, cur, tot, line_cnt, line_len;
    enum senso senso = dx;
    unsigned char *p, *out;

    tot = n * n;

    p = (unsigned char *)malloc(tot);

    if (!p)
        err("errore allocazione memoria");

    line_len = n;
    line_cnt = 0;
    tot = n * n;

    for (cur = -1, val = 1, i = 0; i < tot; ++i, ++val) {

        switch (senso) {
        case dx:
            cur++;
            break;
        case giu:
            cur += n;
            break;
        case sx:
            cur--;
            break;
        case su:
            cur -= n;
            break;
        }

        p[cur] = val;

        if (++line_cnt == line_len) {
            line_cnt = 0;
            switch (senso) {
            case dx:
                line_len--;
                senso++;
                break;
            case giu:
                senso++;
                break;
            case sx:
                line_len--;
                senso++;
                break;
            case su:
                senso = dx;
                break;
            }
        }
    }

    printf("\n");
    for (out = p, i = 0; i < n; ++i) {
        for (q = 0; q < n; ++q)
            printf("%-3d ", *out++);
        printf("\n");
    }
}

int main(void)
{
    int n, val = 0;

    printf("spirale v.090 (alpha), built %s %s\n\n", __DATE__, __TIME__);
    printf("inserisci n (1 a 100) ");

    while ((n = getchar()) != '\n') {

        if (n < 48 || n > 57)
            err("invalid value");

        val *= 10;
        val += n - 48;
    }

    if (val > 100)
        err("100 possono bastare, dai.");

    crea_spirale(val);

    return 0;
}

angelo@dfj ~/tests/spirale (master*) $ gcc -o spirale main.c
angelo@dfj ~/tests/spirale (master*) $ ./spirale
spirale v.090 (alpha), built Jun 17 2021 14:37:50

inserisci n (1 a 100) 10

1   2   3   4   5   6   7   8   9   10  
36  37  38  39  40  41  42  43  44  11  
35  64  65  66  67  68  69  70  45  12  
34  63  84  85  86  87  88  71  46  13  
33  62  83  96  97  98  89  72  47  14  
32  61  82  95  100 99  90  73  48  15  
31  60  81  94  93  92  91  74  49  16  
30  59  80  79  78  77  76  75  50  17  
29  58  57  56  55  54  53  52  51  18  
28  27  26  25  24  23  22  21  20  19  

angelo@dfj ~/tests/spirale (master*) $ ./spirale            
spirale v.090 (alpha), built Jun 17 2021 14:39:17

inserisci n (1 a 100) 15

1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  
56  57  58  59  60  61  62  63  64  65  66  67  68  69  16  
55  104 105 106 107 108 109 110 111 112 113 114 115 70  17  
54  103 144 145 146 147 148 149 150 151 152 153 116 71  18  
53  102 143 176 177 178 179 180 181 182 183 154 117 72  19  
52  101 142 175 200 201 202 203 204 205 184 155 118 73  20  
51  100 141 174 199 216 217 218 219 206 185 156 119 74  21  
50  99  140 173 198 215 224 225 220 207 186 157 120 75  22  
49  98  139 172 197 214 223 222 221 208 187 158 121 76  23  
48  97  138 171 196 213 212 211 210 209 188 159 122 77  24  
47  96  137 170 195 194 193 192 191 190 189 160 123 78  25  
46  95  136 169 168 167 166 165 164 163 162 161 124 79  26  
45  94  135 134 133 132 131 130 129 128 127 126 125 80  27  
44  93  92  91  90  89  88  87  86  85  84  83  82  81  28  
43  42  41  40  39  38  37  36  35  34  33  32  31  30  29  
angelo@dfj ~/tests/spirale (master*) $
 
Ecco la mia soluzione, anche se un po' in ritardo:
C:
#include <stdio.h>
#include <stdlib.h>

#define RIGHT  0
#define DOWN   1
#define LEFT   2
#define UP     3

int digits(int num)
{
    if(!num)
      return 0;
    
    return 1+digits(num/10);
}

void spiralMatrix(int** matrix, int dim)
{
    int move = RIGHT, pos_to_move = dim, trig_ch = 0;
    int i = 0, j = 0, num = 1;
  
    while(num <= dim*dim)
    {
        for(int k = 0; k < pos_to_move; k++)
        {
            matrix[i][j] = num;
            num++;
          
            if(k == pos_to_move-1)
            {
                if(move == UP)
                    move = RIGHT;
                 
                 else
                   move++;
            }
          
            switch(move)
            {
                case RIGHT: j++; break;
                case DOWN:  i++; break;
                case LEFT:  j--; break;
                case UP:    i--; break;
            }
        }
      
        if(pos_to_move == dim)
            pos_to_move--;
      
        else if(!trig_ch)
            trig_ch++;
          
        else
        {
            trig_ch = 0;
            pos_to_move--;
        }
    }
  
}

int main() {
    int n, **matrix;
  
    scanf("%d", &n);
  
    matrix = (int**)malloc(n*sizeof(int*));
  
    for(int i = 0; i < n; i++)
        matrix[i] = (int*)malloc(n*sizeof(int));
      
    spiralMatrix(matrix, n);
  
    for(int i = 0; i < n; i++)
    {
        for(int j = 0; j < n; j++)
        {
            printf("%d ", matrix[i][j]);
          
            for(int k = digits(matrix[i][j]); k < digits(n*n); k++)
                printf(" ");
        }
          
        printf("\n");
    }
  
    for(int i = 0; i < n; i++)
        free(matrix[i]);
      
    free(matrix);
  
    return 0;
}
Questo è l'output:
Codice:
5
1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

7
1  2  3  4  5  6  7
24 25 26 27 28 29 8
23 40 41 42 43 30 9
22 39 48 49 44 31 10
21 38 47 46 45 32 11
20 37 36 35 34 33 12
19 18 17 16 15 14 13

15
1   2   3   4   5   6   7   8   9   10  11  12  13  14  15
56  57  58  59  60  61  62  63  64  65  66  67  68  69  16
55  104 105 106 107 108 109 110 111 112 113 114 115 70  17
54  103 144 145 146 147 148 149 150 151 152 153 116 71  18
53  102 143 176 177 178 179 180 181 182 183 154 117 72  19
52  101 142 175 200 201 202 203 204 205 184 155 118 73  20
51  100 141 174 199 216 217 218 219 206 185 156 119 74  21
50  99  140 173 198 215 224 225 220 207 186 157 120 75  22
49  98  139 172 197 214 223 222 221 208 187 158 121 76  23
48  97  138 171 196 213 212 211 210 209 188 159 122 77  24
47  96  137 170 195 194 193 192 191 190 189 160 123 78  25
46  95  136 169 168 167 166 165 164 163 162 161 124 79  26
45  94  135 134 133 132 131 130 129 128 127 126 125 80  27
44  93  92  91  90  89  88  87  86  85  84  83  82  81  28
43  42  41  40  39  38  37  36  35  34  33  32  31  30  29
 
  • Grazie
Reazioni: Not an engineer