Newsgroup: it.comp.lang.pascal
Titolo: Successioni

Salve Raga,
Non sono proprio in grado di risolvere questo esercizio per le mie scarse
conoscenze matematiche.
Ekko perciň che ve lo getto in pasto a voi:
Si consideri la successione a1=0, a2=1, a3=2 e per n>3 an = an-1+2an-2+an-3
Scrivere un algoritmo che, dati 3 interi N1<N2<N3, con N1 > a3, ritorna TRUE
se il numero di elementi della successione tali che N1 <=an <=N2 č pari al
numero di elementi della successione tali che N2 <= an <=N3.
Non utilizzare un array per memorizzare gli elementi della successione.
Se qualcuno conoscesse l'algoritmo generale della successione mi farebbe un
grandissimo piacere se lo postasse! (Ed entrerebbe a far parte della mia
schiera di eroi preferiti :)
Grazie a tutti quelli che risponderanno o semplicemente visioneranno questo
post.
Ciao Gianni

 mi farebbe un grandissimo piacere se lo postasse!
il problema per te' e generare la successione o calcolare quanti
elementi sono compresi negli intervalli ? :-)
La successione non devi memorizzarla, perche' in fondo dei valori
non ti importa nulla, ti serve solo sapere quando raggiungi i limiti
dell'intervallo (N2  e N3) e ovviam per partire...
la successione la generi con poche variabili:
a := 0; b := 1; c := 2; n := 3;
e cicli una cosa di questo tipo, finche' non arrivi a t > N2 [o N3]
t := a + 2*b + c;
a := b;
b := c;
c := t;
n := n +1; { il contatore serve sempre }
per sapere da quale a[n] partire non so'... a meno di qualche proprieta'
meravigliosa della succ. mi sa che devi scorrerla tutta a partire da a[3]
e vedere quando arrivi a N1... quindi, inventata una funz
function scorriSuccFinoA( limite: longint ): longint;
  che
   usando a, b e c va avanti [come sopra] sulla successione
   finche'  (a[n] <= limite)
   e ritorna <n>
puoi fare una cosa del genere:
<inizilizzi a, b, c>
indice_di_N1 := 1+ scorriSuccFinoA ( N1 );
indice_di_N2 := scorriSuccFinoA ( N2 );
{ quindi il num di elem in [N1..N2] e' indice_di_N2 - indice_di_N1 }
<una iterazione sulla succ. per superare N2>
indice_di_N3 := scorriSuccFinoA ( N3 );
e devi verificare se
 ( indice_di_N2 - indice_di_N1 ) =  ( indice_di_N3 - indice_di_N2 )
`spero' funzioni :-)
--
Dreadnaut
(Life would be easier if I had the source code)

 indice_di_N3 := scorriSuccFinoA ( N3 );
forse basta cosi'....
<inizilizzi a, b, c>
 indice_di_N1 := scorriSuccFinoA ( N1 ) + 1;
 indice_di_N2 := scorriSuccFinoA ( N2 );
 indice_di_N3 := scorriSuccFinoA ( N3 ) - 1;
indice_di_N3 non e' il vero indice di N3, ma e' una bossa per fare
a meno dell'iterazione per superare N2... togli `1' ad entrambi gli
estremi, quindi la lunghezza non cambia... piu' o meno si
schematizza cosi':
[metti Visualizza\Carattere\Fisso ]
(*)  elem della successione (messi a caso !!)
  tre risultati delle chiamate a funzione
   |
   `---------+-----------------+---------------,
             |                 |               |
              N1                  N2               N3
----*---*----*|------*---------*--|---*--------*---|----*-------*----
                     |         |      |
  ,------------------'         |      |
  |                            |      |
 indice_di_N1                  |     indice_di_N3
                               |
  ,----------------------------'
  |
 indice_di_N2
in realta' il test sarebbe
 ( num_elem_[N1..N2] ) = ( num_elem_[N2..N3] )
cioe'
 ( indice_di_N2 - indice_di_N1 +1 ) = ( indice_di_N3 - indice_di_N2 +1)
elimini entrambi i `+1' e viene quello del post prima
 ( indice_di_N2 - indice_di_N1 ) = ( indice_di_N3 - indice_di_N2 )
boh forse ho incasinato ancora di piu' la cosa ma adesso sono
quasi sicuro che funzioni :-)
