Newsgroup: it.comp.lang.c++
Titolo: palindromo

  Ciao ho scritto un piccolo programma per verificare se un numero e'
palindromo o no,nel seguente caso un numero di 5 cifre vorrei sapere se ci
sono altri modi per definire se un numero lo e' o no magari non sapendo
inizialmente la dimensione del numero che verra immesso:
#include <iostream.h>
int main()
{
  int number,n1,n2,n3,n4,n5;
  cout << "immetti numero a 5 cifre:";
  cin >> number;
  n1=number/10000;
  n2=number%10000/1000;
  n3=number%1000/100;
  n4=number%100/10;
  n5=number%10;
  cout << "risultato:" << n1 << " " << n2 << " "
  << n3 << " " << n4 << " " << n5 << endl;
if(n1-n5==0) {
  if(n2-n4==0)
  if(n3-n3==0)
  cout << "il numero e' un palindromo";
}
  else
  cout << "non e' un palindromo";
  cout << endl << endl;
  return 0;
}
 
Grazie per la cortese attenzione.
 
--------------------------------
Inviato via 
http://arianna.libero.it/usenet/

 Grazie per la cortese attenzione.
Figurati, mi diverto!
#include <iostream>
#include <string>
#include <iterator>
template <class BidirectionalIterator>
bool palindromo(BidirectionalIterator start,BidirectionalIterator end)
{
        const int length=end-start;
        if (length<3) return false;
        BidirectionalIterator m1=start+length/2-1;
        BidirectionalIterator m2=start+length/2+1;
        bool ok=true;
        while (m2!=end && ok)
        {
                if (*m1!=*m2) ok=false;
                ++m2;
                --m1;
        }
        return ok;
}
int main()
{
        std::string qualsiasi_cosa;
        std::cout << "Inserisci una stringa o un numero ? ";
        std::cin >> qualsiasi_cosa;
        std::cout << "e' palindromo ? Esito : ";
        bool
verifica=palindromo(qualsiasi_cosa.begin(),qualsiasi_cosa.end());
        std::cout << verifica << std::endl;
        char c;
        std::cin.ignore();
        std::cin.get(c);
        return 0;
}


    Ti ringrazio moltissimo^_^



 Io farei così:
converto il numero nella stringa s1 con itoa, ltoa ecc...)
poi faccio il confronto:
if (strcmp(s1,strrev(s1)) == 0)
   allora sono palindrome
ciao ferradini

    allora sono palindrome
itoa, ltoa e strrev non esistono. 
strcmp non confronta stringhe ma array di caratteri.
Anche scrivendo le funzioni mancanti, l'algoritmo rimane inefficiente:
crea inutilmente una nuova stringa (o un array) e confronta due volte
gli stessi caratteri.
        Mauro


       Grazie a tutti^_^


 gli stessi caratteri.
e ti preoccupi per qualche byte sprecato..........
io non me ne preoccuperei....   punti di vista eventualmente
se poi confronti questa soluzione con quelle date... ....
ciao gianni

 }
In alternativa si puo` procedere dall'esterno verso l'interno:
  template <class BiIt>
  bool palindromo(BiIt start, BiIt end)
  {
    while (start != end) {
      --end;
      if (start == end)
        break;
      if (*start != *end)
        return false;
      ++start;
    }
    return true;
  }
        Mauro

 stringa
Se lo converti in stringa *non* puoi usare strcmp.
        Mauro

         Mauro
ciao e grazie.


Non hai nulla di cui scusarti (io ne faccio continuamente di questi errori)
^_^


 ^_^
Ciao Manuel, grazie, comunque capita di sbagliare e dispiace dare
indicazioni sbagliate a chi, cercando d'imparare, chiede spiegazioni con
fiducia. Chi chiede spiegazioni e ha voglia d'imparare, merita risposte
corrette!
Però, come tutti, ho poco tempo e a volte si cerca di rispondere con i tempi
che si hanno. Proprio per questo motivo comunque è altrettanto corretto
intervenire come ha fatto Mauro.
Infine, un'altro algoritmo, anche questo dovrebbe funzionare: è il più corto
che mi è venuto in mente.
Usa gli iteratori RandomAccess, per via dell'operatore < , e per questo
motivo risulta più corto di quello postato da Mauro Casini, che invece ha
dovuto fare due controlli su start ed end, tuttavia questo non può essere
utilizzato con alcune strutture dati, come ad esempio le liste, che non
usano iteratori ad accesso casuale.
Sicuramente il sistema più generico e raccomandabile è quello di Mauro, ti
ho postato comunque questo perché secondo me è forse più immediato da
comprendere.
template <class RandomAccessIterator>
bool palindromo(RandomAccessIterator start,RandomAccessIterator end)
{
        while (start<end)
        {
                if (*start++!=*--end) return false;
        }
        return true;
}
In pratica finche start è minore di end confronta tutti i caratteri a destra
di start e tutti quelli a sinistra di end, fino a quando non s'incontrano.
Esempio stringa di caratteri "abba", con iteratori start=stringa.begin() e
end=stringa.end() dove *start punta quindi a un carattere, ed end è
posizionato alla fine della stringa, con questi due iteratori chiamiamo la
funzione.
All'ingresso della funzione, abbiamo.
start = 0 e end = 4 (facciamo finta che sia così, in realtà saranno dei mega
indirizzi in memoria, dove comunque end sarà più grande di 4, per questo
esempio)
0<4, *start è il carattere 'a', dopo la sua lettura start viene incrementato
e passa a 1, il carattere letto rimane in un registro o in un indirizzo di
memoria individuato dal tuo compilatore. Ora il compilatore decrementa end,
e solo dopo legge il carattere da questo puntato, che nell'esempio è ancora
una 'a', il confronto è falso perché 'a' non è diverso da 'a' e quindi non
ritorna false ma il controllo ripassa al while (con start=1 e end=3).
1<3 quindi controlla 'b' (che è *start) con 'b' (che è *--end, ovvero *2,
dato che prima end era 3), poi b diventa 2.
2<2 falso, quindi esce dal ciclo e ritorna true.
Se invece avessimo incontrato una non corrispondenza, all'interno del ciclo
while, avremmo avuto l'immediato ritorno di false.
ciao, saluti e continu a chiedere a me, a Mauro e agli altri, ogni volta che
sei in difficoltà.
Paolo Ferraresi.


   Ancora mille grazie^_^
