Funzioni in C

[andbin]

Originariamente inviato da Vasec87

altrimenti non capisco, tanto sti esercizi non li uso molto per imparare a programmare, per imparare uso quelli del libro con le soluzioni

Ah beh .... allora ....

Se vuoi imparare a programmare ... devi imparare a ragionare!

Intanto mi è venuto in mente che, in effetti, ci sono 2 modi di gestire l'aggiornamento della variabile 'lung_max'. E uno è un po' più semplice dell'altro.

Modo 1:

ricerca di 't':

           a  r  t  t  t  t  o  p  t  t  w  e
lung        0  0  1  2  3  4  0  0  1  2  0  0
lung_max    0  0  0  0  0  0  4  4  4  4  4  4

Modo 2 (più semplice):

ricerca di 't':

           a  r  t  t  t  t  o  p  t  t  w  e
lung        0  0  1  2  3  4  0  0  1  2  0  0
lung_max    0  0  1  2  3  4  4  4  4  4  4  4

Forse è meglio se usi quest'ultimo che è più semplice.

Cosa puoi notare da quest'ultimo schemino?? Diverse cose:

a) Ogni volta che trovi il carattere richiesto, devi incrementare 'lung'.

b) Ogni volta che non trovi il carattere richiesto, devi azzerare 'lung'.

c) La variabile 'lung_max' la devi aggiornare quando 'lung' è maggiore di 'lung_max'.

[Vasec87]

c'ho provato ma sarà sbagliatissimo

int _strch2_(const char *s, int c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s1);

for(i=0;i<n1;i++){
if(s1[i]==s1[i++]){
++lung;}
else{
lung=0;}
if(lung_max<lung){
lung=lung_max;}

[andbin]

Originariamente inviato da Vasec87

c'ho provato ma sarà sbagliatissimo

int _strch2_(const char *s, int c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s1);

for(i=0;i<n1;i++){
if(s1[i]==s1[i++]){
++lung;}
else{
lung=0;}
if(lung_max<lung){
lung=lung_max;}

Infatti non va per niente bene. Non devi verificare se 2 caratteri qualunque sono adiacenti, ma devi verificare se un certo carattere ben preciso si trova ripetuto in modo consecutivo e determinare quale è la sequenza più lunga.

Ripeto (anche se l'ho spiegato prima):

Se il carattere è uguale a quello richiesto, incrementi 'lung'. Inoltre se 'lung' è maggiore di 'lung_max' allora aggiorni 'lung_max'.

Se il carattere non è uguale a quello richiesto, azzeri 'lung'.

[Vasec87]

Infatti non va per niente bene. Non devi verificare se 2 caratteri qualunque sono adiacenti, ma devi verificare se un certo carattere ben preciso si trova ripetuto in modo consecutivo e determinare quale è la sequenza più lunga.



UN AIUTINO??

il mio punto di partenza è sempre questo

int _strch2_(const char *s, int c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s1);

for(i=0;i<n1;i++){

[andbin]

Originariamente inviato da Vasec87

UN AIUTINO??

Sono poi 2 if da fare!

Se s[i] è uguale a c, allora incrementi 'lung' e se è maggiore di 'lung_max', aggiorni 'lung_max'. Altrimenti azzeri 'lung'.

[Vasec87]

int _strch2_(const char *s, int c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s1);

for(i=0;i<n1;i++){
if(s[i]==c)
{
++lung;
if(lung>lung_max){
lung_max=lung;}}
else{
lung=0;}}




ci siamo ora?

perdonami andbin, ma come mai ancora non mi hai mandato a quel paese?

[andbin]

Originariamente inviato da Vasec87

ci siamo ora?

Ok, ci siamo!!!
Solo alcune bazzeccole:
- Il parametro è 's', in strlen hai usato s1
- Ti è stato richiesto espressamente di passare int c?? Sarebbe meglio char c
- fai ritornare lung_max e chiudi la func.

Originariamente inviato da Vasec87

perdonami andbin, ma come mai ancora non mi hai mandato a quel paese?

Non mi permetterei mai.

[Vasec87]

int _strch2_(const char *s, char c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s);

for(i=0;i<n1;i++){
if(s[i]==c)
{
++lung;
if(lung>lung_max){
lung_max=lung;}}
else{
lung=0;}

return lung_max;
}




è buona ora?

ti ringrazio di tutto, ciao

[andbin]

Originariamente inviato da Vasec87

è buona ora?

Manca la graffa di chiusura del for. Cerca di scrivere il sorgente in modo chiaro con una corretta spaziatura e indentazione. Scopriresti subito dove mancano le graffe!

[Vasec87]

ora va bene?
int _strch2_(const char *s, char c)
{
int lung=0;
int lung_max=0;
int n1 = strlen (s);

for(i=0;i<n1;i++){
if(s[i]==c)
{
++lung;
if(lung>lung_max){
lung_max=lung;}}
else{
lung=0;}

return lung_max;}
}


comq solo quando incollo sul forum non ci sono gli spazi, sennò quando uso il compilatore li metto ovunque. invece quando lo posto qui mi mette tutto appiccicato

[andbin]

Originariamente inviato da Vasec87

ora va bene?

No la graffa va prima del return!

Originariamente inviato da Vasec87

invece quando lo posto qui mi mette tutto appiccicato

Devi metterlo tra i tag CODE (è il # tra gli strumenti).

Così si scrive:

int _strch2_(const char *s, char c)
{
    int lung=0;
    int lung_max=0;
    int n1 = strlen (s);
    
    for(i=0;i<n1;i++) {
        if(s[i]==c) {
            ++lung;
            if(lung>lung_max) {
                lung_max=lung;
            }
        }
        else {
            lung=0;
        }
    }                                              

    return lung_max;
}

A me personalmente non piacciono le graffe di apertura messe al fondo dopo l'istruzione .... ma le accetto lo stesso.

[Vasec87]

E' L'ULTIMO

void _gen_labirinto_(char a[][]. int m, int n);

la funzione prende da input una matrice non inizializzata, e le sue dimensioni (m e n). Modifica i suoi elementi come segue: tramite un generatore pseudocasuale pone casualmente nelle varie posizioni della matrice o il carattere #(che indica che la posizione corrisponde a un pezzo di muro del labirinto) o il carattere .(che indica una posizione in cui si puo passare per uscire dal labirinto). La funzione stampa in output per righe la matrice cosi ottenuta. Il labirinto prodotto in outpute deve sempre essere risolubile: deve sempre esserci un percorso da una cella vuota nell'ultima riga in alto ad una cella vuota della riga in basso. la persona che esplora il labirinto si suppone che possa muoversi solo sulle celle vuote in orizzontale e verticale.
ad esempio se si ha in input una matrice composta da 10*10 elementi il programma dovrebbe riempire la matrice nel modo a sinistra. la soluzione del percorso è riportata a destra.
ASSUMIAMO CHE a[i][j] sia la cella della riga i e della colonna j.

Labirinto:


##.#..####
#...##..##
.#.##....#
#..###.###
##.#.#.#.#
#...#..###
#.#..#...#
##.#.#.#.#
#....#.#.#
###.#..###

Soluzione

##°#..####
#.°.##..##
.#°##....#
#.°###.###
##°#.#.#.#
#.°°#..###
#.#°°#...#
##.#°#.#.#
#...°#.#.#
###°#..###


sicuramente non sono allineati bene, ma basta che rendano l'idea

[andbin]

Originariamente inviato da Vasec87

void _gen_labirinto_(char a[][]. int m, int n);

Ok, come avevo già detto in questo thread, se vuoi passare una matrice bidimensionale di dimensione "arbitraria" non puoi dichiarare il parametro come char a[][].

A parte questo, il problema è da suddividere in 2 fasi:

1) Creazione del labirinto
2) Soluzione del labirinto

Per la creazione c'è il problema che generandolo in modo casuale, non è detto che si ottenga un labirinto percorribile secondo le richieste. Si possono comunque fare più tentativi fino a quando non si trova un labirinto risolvibile.

Per la soluzione del labirinto, bisogna valutare come ci si può muovere all'interno del labirinto. La prima cosa che mi viene in mente: l'ipotetica persona che esplora il labirinto deve viaggiare sempre e solo nella direzione dell'uscita o può anche eventualmente passare per una strada che "torna indietro"???

[Vasec87]

non lo so, io so quello che sai tu,perchè il testo l'ho copiato e incollato, non me l'hanno spiegato


sembra abbastanza difficile però

[andbin]

Originariamente inviato da Vasec87

sembra abbastanza difficile però

Difficilissimo no, semmai si può dire che non è come gli altri esercizi precedenti in cui te la cavavi con una unica semplice funzioncina.

Per questo esercizio è bene mettere giù diverse funzioni più il main.

[Vasec87]

vabbè lo salto questo, non fa niente

[AngeL)]

Originariamente inviato da andbin

Per la creazione c'è il problema che generandolo in modo casuale, non è detto che si ottenga un labirinto percorribile secondo le richieste. Si possono comunque fare più tentativi fino a quando non si trova un labirinto risolvibile.

anziche' crearlo in modo casuale, è meglio imho fare cosi':
mettiamo il caso che la matrice sia di 30 righe x 10 colonne
si genera un numero random da 0 a 9 (n) e si rende percorribile mat[0][n]
matrice[0][n]='.'

si genera un numero random da 1 a 3:
se il numero è 1 e non ci si trova sul bordo sinistro
si va a sinistra (mat[0][n-1]='.')
altrimenti
si genera un altro numero random e si ripete

se è 2
se ci si trova alla fine
si esce dal ciclo
altrimenti
si va giu (mat[1][n]='.')

se è 3 e non ci si trova sul bordo destro
si va a destra (mat[0][n+1])
altrimenti
si genera un altro numero random e si ripete.

ora vado a provare

[Vasec87]

io non ci riuscirei mai, se magari ti diverti a farlo poi puoi postarlo..

[AngeL)]

Originariamente inviato da Vasec87

io non ci riuscirei mai

in cosa trovi difficolta' di preciso? nel tradurre il ragionamento in codice?

[Vasec87]

no, proprio nel fare il ragionamento, per pensare alla soluzione