DOMANDA cifrario di cesare e scacchiera di polibio

[Francesco C.]

Ciao a tutti

Stavo facendo un programma che presa in input una parola deve fare la cifratura di cesare.
Es. CIAO deve uscire FLDR

Solo che prende in input la parola ma non stampa.
Potete aiutarmi ?

Ecco il codice

#include <stdio.h>

int main()
{
    char A[26]={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W','X','Y','Z'};
    char B[26]={'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W','X','Y','Z','A', 'B', 'C'};
    char P[26];
    char RI[26];
    int i;
        printf("Inserire parola:  ");
        scanf("%s", P);
    
    for(i=0;i<26;i++)
    {
        if(P[i] == A[i])
            {
              RI[i]=B[i]; 
            }
    }
    
    printf("Frase: %s", RI);
    return 0;
}

 

[Hero467]

Ciao, quello che credo sia il tuo problema è che fai un solo ciclo for. In questo modo confronta un carattere della parola immessa con un solo carattere presente nell'array, e non confronta tutte le lettere come invece dovrebbe fare.
Esempio:
i è 0, quindi il carattere alla prima iterazione sarà C nella tua parola e A nel primo array.
C è diverso da A, quindi passa avanti e va alla seconda iterazione, e i diventa 1.
Quindi ora confronta I con B. I è diverso da B, quindi passa avanti e va alla seconda iterazione, e così via...

Come vedi confronta solo una lettera di uno con la corrispondente dell'altro, e non la lettera indicata della parola con tutte quelle presenti nell'array.

Si potrebbe rimediare con un ciclo innestato, così:

include <string.h>  //ricordati di usare anche questa libreria, per la funzione strlen()
   
int len = strlen(P);

for(int i = 0; i < len; i++) {
    for(int j = 0; i < 26; j++) {
        if (P[i] == A[j]) {
            RI[i] = B[j];
        }
    }
}

Dovrebbe funzionare così. Potrei aver commesso qualche errore nell'istruzione che si verifica se l'if esegue perché adesso non posso testare il codice, ma a occhio dovrebbe andare

 

[Francesco C.]

Facendolo con un amico mi ha detto che la seguente versione è ok però continua a non restituire nulla in output... che errore può essere?

#include <stdio.h>

int main()
{
    char A[26]={'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W','X','Y','Z'};
    char B[26]={'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W','X','Y','Z','A', 'B', 'C'};
    char P[26];
    char RI[26];
    int i,j;
        printf("Inserire parola:  ");
        scanf("%s", P);
    
    for(i=0;i<26;i++)
    {
        for(j=0;j<26;j++)
        {
        if(P[i] == A[j])
            {
              RI[j]=B[j]; 
            }
        }
    }


    printf("Frase: %s", RI);

    return 0;
}

 

[Hero467]

strlen() serve a ottenere la lunghezza di una stringa, cioè di un array di caratteri. L'ho messo per evitare un segmentation fault (come ho ottenuto appunto eseguendo il tuo codice). Mi stupisco che ti esegua senza errori.

Quello che non funziona (almeno a me) è che vai a cercare di accedere ad aree di memoria "vuote" (passami il termine, non sono il più adatto a spiegare queste cose), cioè che non contengono nulla. Quindi l'array sa di potersi aspettare 26 elementi, ma nel momento in cui tu metti CIAO le aree di memoria occupate saranno solo 4. Il ciclo però questo non lo sa (visto che lo hai impostato per fare 26 iterazioni) e quindi va avanti a cercare di accedere anche alle altre. E visto che non può perché non gli competono finché non vengono occupate, il compilatore ti restituisce un segmentation fault.

Quindi, in sostanza, quello che dovresti fare è dichiarare un array di lunghezza a te comoda, occupare le aree dell'array che ti servono con la parola che desideri (e fin qui l'hai gia fatto, tutto bene), poi impostare il primo ciclo per iterare SOLO e SOLTANTO per la lunghezza della parola da te immessa, così da operare su aree di memoria a lui accessibili. Lo puoi fare impostando nel ciclo la lunghezza della parola che puoi ricavare con strlen(), come ho fatto io (ricorda di importare string.h però), oppure puoi farlo direttamente con int len = sizeof(P) / sizeof(P[0]). La variabile conterrà il numero di caratteri della tua parola, e la puoi usare tranquillamente nel tuo ciclo per evitare questo tipo di errori.



Per ultimo, cito @Andretti60, @DispatchCode e @BrutPitt che sono decisamente piu esperti e qualificati per spiegarti queste cose, e che correggeranno la mia abominevole spiegazione

 

[Francesco C.]

strlen() serve a ottenere la lunghezza di una stringa, cioè di un array di caratteri. L'ho messo per evitare un segmentation fault (come ho ottenuto appunto eseguendo il tuo codice). Mi stupisco che ti esegua senza errori.

Quello che non funziona (almeno a me) è che vai a cercare di accedere ad aree di memoria "vuote" (passami il termine, non sono il più adatto a spiegare queste cose), cioè che non contengono nulla. Quindi l'array sa di potersi aspettare 26 elementi, ma nel momento in cui tu metti CIAO le aree di memoria occupate saranno solo 4. Il ciclo però questo non lo sa (visto che lo hai impostato per fare 26 iterazioni) e quindi va avanti a cercare di accedere anche alle altre. E visto che non può perché non gli competono finché non vengono occupate, il compilatore ti restituisce un segmentation fault.

Quindi, in sostanza, quello che dovresti fare è dichiarare un array di lunghezza a te comoda, occupare le aree dell'array che ti servono con la parola che desideri (e fin qui l'hai gia fatto, tutto bene), poi impostare il primo ciclo per iterare SOLO e SOLTANTO per la lunghezza della parola da te immessa, così da operare su aree di memoria a lui accessibili. Lo puoi fare impostando nel ciclo la lunghezza della parola che puoi ricavare con strlen(), come ho fatto io (ricorda di importare string.h però), oppure puoi farlo direttamente con int len = sizeof(P) / sizeof(P[0]). La variabile conterrà il numero di caratteri della tua parola, e la puoi usare tranquillamente nel tuo ciclo per evitare questo tipo di errori.



Per ultimo, cito @Andretti60, @DispatchCode e @BrutPitt che sono decisamente piu esperti e qualificati per spiegarti queste cose, e che correggeranno la mia abominevole spiegazione

Grazie mille.
Quella funzione non l'abbiamo mai utilizzata a scuola per questo non l'ho capita.
Comunque spiegazione chiarissima!! In poche parole non stampa perchè invece di essere occupati 26 slot sono occupati solo 4 e va in segmentation fault.

 

[Hero467]

Comunque spiegazione chiarissima!! In poche parole non stampa perchè invece di essere occupati 26 slot sono occupati solo 4 e va in segmentation fault.

Diciamo che in una visione semplicistica può essere vista così. Felice di averti aiutato comunque :)

 

[Francesco C.]

Diciamo che in una visione semplicistica può essere vista così. Felice di averti aiutato comunque :)

scusami sempre il disturbo...
posso chiederti una mano anche per questo ?
E' la scacchiera di polibio
devo stampare le coordinate delle lettere di una parola presa in input

Il problema è che non mi fa terminare il riempimento matrice con le lettere.

ecco il codice:

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

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char *argv[])
{
    int i, j;
    char S[5][5];
    char A[4];
        
        printf("Inserire parola: ");
        scanf("%s", A);
                    
                    for(i=0;i<5;i++)
                    {
                        for(j=0;j<5;j++)
                            {
                                printf("Scrivi alfabeto -inserisci KQ insieme- \n");
                                scanf("%c", &S[i][j]);
                            }
                    }
                    
            for(i=0;i<5;i++)
                {
                    for(j=0;j<5;j++)
                        {
                            if(A[i] == S[i][j])
                                {
                                    printf(" %c = %d, %d \n", A[i], i,j);
                                }
                        }
                }
    return 0;
}

 

[Hero467]

Purtroppo ora non sono più al PC e non ho il tempo di esaminare il codice. Se ti va bene gli do un'occhiata domani mattina

 

[Francesco C.]

Purtroppo ora non sono più al PC e non ho il tempo di esaminare il codice. Se ti va bene gli do un'occhiata domani mattina

d'accordo grazie mille

 

[BrutPitt]

Stavo facendo un programma che presa in input una parola deve fare la cifratura di cesare.
Es. CIAO deve uscire FLDR

Lascerei perdere l'array A: e' inutile sono gia' codici ASCII consecutivi.
Due possibilita':
1) Calcolare direttamente la lettera del cifrario, sapendo che differisce di 3 caratteri, quindi senza dichiarare un array B
2) Usare il cifrario (array B) da indicizzare.

//usare solo 2 array
    char P[100]; //input
    char RI[100]; //output

// acquisisci la stringa in P

// 1) Calcolo diretto:
    for(int i=0; P[i]; i++)
        RI[i] =  'A' + ((P[i] - 'A' + 3)  % 26);

// 2) Array B come cifrario da indicizzare
    char B[]={'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W','X','Y','Z','A', 'B', 'C'};
    for(int i=0; P[i]; i++)
       RI[i] =  B[P[i] - 'A'];

// stampa il risultato di RI

Troppo criptico?

Prova a ragionare:
(*) for(int i=0; P[i]; i++)
Perche' mi basta fare cio' per controllare il ciclo?

Cerca di spiegare questo passaggio:
(*) RI[i] = 'A' + ((P[i] - 'A' + 3) % 26);
o questo:
(*) RI[i] = B[P[i] - 'A'];
Ricorda che ho parlato di codice ASCII 😉

P.S.
Potresti aggiungere la gestione di UPPERCASE / lowercase (MAIUSCOLO/minuscolo)

 

[DispatchCode]

Quando ci sono cose interessanti arrivo sempre in ritardo... 😩

Quello che non funziona (almeno a me) è che vai a cercare di accedere ad aree di memoria "vuote" (passami il termine, non sono il più adatto a spiegare queste cose), cioè che non contengono nulla. Quindi l'array sa di potersi aspettare 26 elementi, ma nel momento in cui tu metti CIAO le aree di memoria occupate saranno solo 4. Il ciclo però questo non lo sa (visto che lo hai impostato per fare 26 iterazioni) e quindi va avanti a cercare di accedere anche alle altre. E visto che non può perché non gli competono finché non vengono occupate, il compilatore ti restituisce un segmentation fault.

Grazie mille.
Quella funzione non l'abbiamo mai utilizzata a scuola per questo non l'ho capita.
Comunque spiegazione chiarissima!! In poche parole non stampa perchè invece di essere occupati 26 slot sono occupati solo 4 e va in segmentation fault.

@Francesco C. spero di risultare chiaro con la spiegazione, in caso contrario dimmi pure. 😁

No in realtà no @Hero467. Essendo un'allocazione statica di memoria (cioè, conosciuta quando il programma viene compilato) vengono allocati effettivamente quei bytes sullo stack (26 * 4 + la variabile int (4 bytes)); a questi vanno in realtà aggiunti altri bytes per arrotondare, ma non è importante questo aspetto.

Per esempio:

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

int main()
{
    char str[26];

    scanf("%s", str);
    printf("Str inserita: %s\n\n", str);
    
    for(int i=0; i<26; i++) {
        printf("%X\n", str[i]);
    }

    return 0;
}

Eseguendo:

Spoiler

CIAO
Str inserita: CIAO

43
49
41
4F
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

Il vero problema in questo codice è che se viene inserita una frase più lunga di 26 caratteri, si verifica una sovrascrittura dei dati sullo stack (nelle posizioni di memoria successive all'array) e il programma crasha.

---

A parte tutto ciò... utilizzerei la prima soluzione di BrutPitt, che andrebbe poi adattata per i caratteri minuscoli.

 

[Hero467]

No in realtà no @Hero467. Essendo un'allocazione statica di memoria (cioè, conosciuta quando il programma viene compilato) vengono allocati effettivamente quei bytes sullo stack (26 * 4 + la variabile int (4 bytes)); a questi vanno in realtà aggiunti altri bytes per arrotondare, ma non è importante questo aspetto.

Per esempio:

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

int main()
{
    char str[26];

    scanf("%s", str);
    printf("Str inserita: %s\n\n", str);
   
    for(int i=0; i<26; i++) {
        printf("%X\n", str[i]);
    }

    return 0;
}

Eseguendo:

Spoiler

CIAO
Str inserita: CIAO

43
49
41
4F
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

Il vero problema in questo codice è che se viene inserita una frase più lunga di 26 caratteri, si verifica una sovrascrittura dei dati sullo stack (nelle posizioni di memoria successive all'array) e il programma crasha.

---

A parte tutto ciò... utilizzerei la prima soluzione di BrutPitt, che andrebbe poi adattata per i caratteri minuscoli.

Ma se la memoria allora è allocata, perché da un segmentation fault invece saltare semplicemente l’if, visto che 0x00 è diverso da qualunque altro byte presente nell’array B?

 

[DispatchCode]

Ma se la memoria allora è allocata, perché da un segmentation fault invece saltare semplicemente l’if, visto che 0x00 è diverso da qualunque altro byte presente nell’array B?

Ti riferisci al suo primo codice? Io non ho alcun segmentation fault.
Da strace è tutto ok:

Spoiler

strace ./test 
execve("./test", ["./test"], 0x7ffc774bbcf0 /* 47 vars */) = 0
brk(NULL)                               = 0x55d266edc000
arch_prctl(0x3001 /* ARCH_??? */, 0x7fffd61ef0b0) = -1 EINVAL (Argomento non valido)
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fd9dab4a000
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (File o directory non esistente)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
newfstatat(3, "", {st_mode=S_IFREG|0644, st_size=77063, ...}, AT_EMPTY_PATH) = 0
mmap(NULL, 77063, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fd9dab37000
close(3)                                = 0
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0P\237\2\0\0\0\0\0"..., 832) = 832
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784
pread64(3, "\4\0\0\0 \0\0\0\5\0\0\0GNU\0\2\0\0\300\4\0\0\0\3\0\0\0\0\0\0\0"..., 48, 848) = 48
pread64(3, "\4\0\0\0\24\0\0\0\3\0\0\0GNU\0i8\235HZ\227\223\333\350s\360\352,\223\340."..., 68, 896) = 68
newfstatat(3, "", {st_mode=S_IFREG|0644, st_size=2216304, ...}, AT_EMPTY_PATH) = 0
pread64(3, "\6\0\0\0\4\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0@\0\0\0\0\0\0\0"..., 784, 64) = 784
mmap(NULL, 2260560, PROT_READ, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fd9da800000
mmap(0x7fd9da828000, 1658880, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x28000) = 0x7fd9da828000
mmap(0x7fd9da9bd000, 360448, PROT_READ, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1bd000) = 0x7fd9da9bd000
mmap(0x7fd9daa15000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x214000) = 0x7fd9daa15000
mmap(0x7fd9daa1b000, 52816, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fd9daa1b000
close(3)                                = 0
mmap(NULL, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fd9dab34000
arch_prctl(ARCH_SET_FS, 0x7fd9dab34740) = 0
set_tid_address(0x7fd9dab34a10)         = 53376
set_robust_list(0x7fd9dab34a20, 24)     = 0
rseq(0x7fd9dab350e0, 0x20, 0, 0x53053053) = 0
mprotect(0x7fd9daa15000, 16384, PROT_READ) = 0
mprotect(0x55d2652ea000, 4096, PROT_READ) = 0
mprotect(0x7fd9dab84000, 8192, PROT_READ) = 0
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0
munmap(0x7fd9dab37000, 77063)           = 0
newfstatat(1, "", {st_mode=S_IFCHR|0620, st_rdev=makedev(0x88, 0), ...}, AT_EMPTY_PATH) = 0
getrandom("\x21\xed\xa0\x39\xc7\x23\xcf\x26", 8, GRND_NONBLOCK) = 8
brk(NULL)                               = 0x55d266edc000
brk(0x55d266efd000)                     = 0x55d266efd000
newfstatat(0, "", {st_mode=S_IFCHR|0620, st_rdev=makedev(0x88, 0), ...}, AT_EMPTY_PATH) = 0
write(1, "Inserire parola:  ", 18Inserire parola:  )      = 18
read(0, CIAO
"CIAO\n", 1024)                 = 5
write(1, "Frase: ", 7Frase: )                  = 7
lseek(0, -1, SEEK_CUR)                  = -1 ESPIPE (Operazione di seek non consentita)
exit_group(0)                           = ?
+++ exited with 0 +++

Ho anche eseguito, e termina senza mostrare nulla a parte "Frase".

Che versione di GCC utilizzi?

La memoria è allocata perchè è un'allocazione statica: la memoria viene riservata per tutti gli array che sono stati dichiarati, sia quelli inizializzati che quelli non inizializzati.
Lo vedi ad esempio anche da qui, senza debuggare in locale: https://godbolt.org/z/1qa5YM91a
Quella add rsp, -128 è lo spazio che viene riservato sullo stack, ed è appunto codice prodotto dal compilatore, poichè la dimensione della memoria che ti serve è conosciuta in compilazione (al contrario dell'allocazione dinamica).

 

[Hero467]

Ti riferisci al suo primo codice? Io non ho alcun segmentation fault.

Si. Ho provato anche a fare debug, e dopo avere confrontato i 4 caratteri della parola CIAO quando cerca di accedere all’indice [4] mi risulta segmentation fault.

La versione di gcc te la so dire quando torno a casa

 

[DispatchCode]

Si. Ho provato anche a fare debug, e dopo avere confrontato i 4 caratteri della parola CIAO quando cerca di accedere all’indice [4] mi risulta segmentation fault.

La versione di gcc te la so dire quando torno a casa

Va bene, prova a verificare.

Mi sembra molto strano il segmentation fault, poichè la memoria a cui accede è valida; inoltre è tutto sullo stack e non è una dimensione così grande da giustificare quel tipo di errore (viene restituito ad esempio se cerchi di allocare un numero di elementi superiore alla dimensione dello stack).
Tipo se compili modificando l'array RI in questo modo: char RI[10000000000000]; ottieni un segmentation fault.