Newsgroup: it.comp.lang.c
Titolo: Programma per invertire stringa inserita

Salve a tutti,
a scopo didattico ho implementato un algoritmo che data in input una stringa 
stampa la stessa invertita.
ecco il codice:
int main ()
{
char lstringa;
char larray[30], rarray[30];
int=i, max;
while (((lstringa=getchar())) != '\n')
 {
 larray[i]=lstringa;
 max=i;
 i++;
 }
 for (i=max; i<=0; i--)
 {
  for(j=0; j<=max; j++)
  {
  larray[i]=rarray[j];
  }
 }
for(i=0;i<=max; i++)
putchar(rarray[i]);
getchar();
return 0;
}
----------------
qualcuno potrebbe aiutarmi a capire il motivo per il quale tale codice non 
fa quanto mi aspetto ?
Grazie 

  }
qui sopra stai facendo una cosa senza senso. Per rendertene conto
esegui "a mano" il tuo programma prendendo nota passo passo
di quali valori assumono le variabili..
Non e' una questione di C, ma di semplice logica.
Tra l'altro il primo ciclo non viene mai eseguito
perche' poni la condizione i<=0.
Per invertire una stringa basta un solo ciclo:
il primo elemento va nell'ultimo, il secondo
nel penultimo etc.etc.
In realta' non ti serve neanche il secondo vettore
di appoggio. Basta scrivere opportunamente il
ciclo che emette i caratteri.
ciao,
v.

Prova con questo codice
int main ()
{
char lstringa;
char larray[30], rarray[30];
int i=0, j, max;
while (((lstringa=getchar())) != '\n')
 larray[i++]=lstringa;
 
 max=i-1;
 for (i=max; i>=0; i--)
 {
   rarray[max-i]=larray[i];
  }
for(i=0;i<=max; i++)
putchar(rarray[i]);
getchar();
return 0;
}
Oppure, se devi solo visualizzare la stringa invertita, potresti provare
con questo codice
int main ()
{
char lstringa;
char larray[30], rarray[30];
int i=0, j, max;
while (((lstringa=getchar())) != '\n')
 larray[i++]=lstringa;
 
 max=i-1;
 
for(i=0;i<=max; i++)
putchar(larray[max-i]);
getchar();
return 0;
}
Franc_

 perche' poni la condizione i<=0.
ho posto la condizione i<=0 perchè la condizione di partenza è i=max e ad 
ogni ciclo si decrementa il contatore.
grazie per le osservazioni ! 

 ogni ciclo si decrementa il contatore.
Deve essere i>=0, altrimenti il ciclo non viene mai eseguito.
Franc 

 wrote:
[CUT]
for(i=strlen(stringa);i>=0;i--) { putchar(stringa[i]); }
-- 
[Filippo...........................]
[Linux User #342745................]
        ==[...penguin powered...]==

  for (i=max; i<=0; i--)
Il ciclo non si attiverà mai, così.
Impara comunque ad usare la funzione fgets() per leggere le stringhe.
#include <stdio.h>
#include <string.h>
int main()
{
    char s[30];
    int i, j, len;
 
    printf("inserire una stringa: "); 
    fgets(s, sizeof s, stdin);
 
    len = strlen(s);
 
    if (s[len-1] == '\n')
      s[--len] = '\0';          
 
    for(i=0, j=len-1; i<j; i++, j--)
    {
       char t = s[i];      
       s[i] = s[j];
       s[j] = t;   
    }    
    printf("stringa invertita: %s\n", s);
    return 0;
}
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Puoi provare anche questa alternativa
#include <stdio.h>
int main(){
	char* s = "";
	int i;
	printf("inserire una stringa: ");
	fgets(s, 1000, stdin); // Buffer massimo per la stringa: 1000
caratteri
	for(i=0;i<strlen(s)/2;i++){ // Ciclo su metࠤegli elementi della
stringa
		int j = strlen(s) - i - 2; // "puntatore" all'elemento speculare
rispetto ad i
		if (i==j) // Se la stringa ha un numero di caratteri dispari, non
considero il carattere centrale ed esco dal ciclo
			break;
		s[i] ^= s[j]; // Scambio i due elementi speculari attraverso l'ExOR
		s[j] ^= s[i];
		s[i] ^= s[j];
	}
	printf("stringa invertita: %s\n", s);
	return 0;
}
Ci sono i seguenti vantaggi nell'utilizzare questa tecnica:
1) La tecnica dell'ExOR ti permette di evitare l'utilizzo di una
variabile temporanea. In tempi in cui la RAM te la vendono un tot al
chilo non ha molto senso, ma 蠳empre bene imparare tecniche di
risparmio risorse. Infatti questa tecnica funziona anche con oggetti
molto grossi (se programmerai ad oggetti e dovrai implementare un
metodo che scambia due entit࠭olto grandi, questa tecnica ti puডr
risparmiare un po' di memoria).
2) Cicli solo per metࠤegli elementi della stringa, quindi per
stringhe molto lunghe potrebbe essere un risparmio di processore (vale
lo stesso discorso della memoria).
3) L'utilizzo del char* ti permette di non dover definire la dimensione
della stringa all'interno del codice, e poter quindi parametrizzare,
volendo, la fgets con lunghezze diverse, utilizzando sempre la stessa
stringa, a seconda dell'utilizzo.
Lone

 caratteri
Peccato che questo programma sia gravemente errato:
infatti usi la stringa s senza averla allocata, o meglio
il puntatore s punta ad una stringa vuota (ovvero ad un array di char
lungo 1 carattere e contenente il solo terminatore 0).
Quindi quando vai a leggerci dentro fino a 1000 caratteri non
fai altro che sporcare la memoria con esiti imprevedibili.
(Per input corti il programma puo' apparentemente funzionare).
 > L'utilizzo del char* ti permette di non dover definire la dimensione
 > della stringa all'interno del codice, e poter quindi parametrizzare,
 > volendo, la fgets con lunghezze diverse, utilizzando sempre la stessa
 > stringa, a seconda dell'utilizzo.
Questo che scrivi e' palesemente falso. Leggiti la definizione di fgets.
Non c'e' scritto da nessuna parte che la fgets allochi per te
il buffer.
Te lo devi allocare da solo (dinamicamente o staticamente)
e passare a fgets la lunghezza L del buffer.
La fgets leggera' al massimo L-1 caratteri e li memorizzera'
nel buffer. In C le stringhe non vengono allocate e/e allungate
automaticamente: te le devi gestire tu.
ciao,
g.

 stringa, a seconda dell'utilizzo.
Questo è falso.  La fgets() dà per scontato che la memoria che essa
utilizzerà sia già allocata.  Quello che si preoccupa di fare è di non
sforarla, visto che le passi un max di elementi da leggere.
