Numeri felici: eccone uno, il 13!

Numeri felici, per cominciare bene l’anno.
Cosa rende felice un numero ce lo spiega il solito Wikipedia. Dato un intero positivo di partenza, si costruisca la sequenza in cui il successivo è uguale alla somma dei quadrati delle cifre del numero precedente. Si trova che la sequenza termina con 1 (e allora il numero di partenza viene detto numero felice) oppure termina nella sequenza ripetitiva: 4, 16, 37, 58, 89, 145, 42, 20, 4, …
Un paio di esempi:

  • 32 -> 9 + 4 = 13 -> 1 + 9 = 10 -> : 32 è un numero felice;
  • 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4 : siamo tornati al punto di partenza, loop!

Con poche righe di Python e l’utilizzo del Google Colaboratory, esploriamo il territorio degli interi, alla ricerca di numeri felici.

Per chi volesse imparare il Python, segnalo la possibilità di iscriversi gratuitamente a un corso online che fa parte del programma di MOOC (massive open online course) dell’Università Federico II di Napoli.

numeri felici: i corsi di Federica.eu

I dettagli del corso di Programmazione in Python (iscrizione gratuita aperta a tutti) sono consultabili qui. Può sembrare banale, ma non è mai troppo tardi.


Google Colaboratory

Iniziato come progetto interno Google, il Google Colab è un Jupyter Notebook disponibile gratuitamente a chi possegga un account Google. È quindi un comodo strumento, accessibile via browser web, per creare codice in linguaggio Python e, allo stesso tempo, documentarlo in modo ottimale. Più che codice con commenti, è possibile creare un documento con all’interno del codice, distribuito dove è opportuno.
La possibilità di descrivere il proprio codice (e i relativi risultati) in maniera estesa aiuta a rimettere insieme i propri ragionamenti anche a mesi di distanza, cosa questa assolutamente fondamentale per chi, come me, non ha una memoria robustissima, che con gli anni ha poche speranze di migliorare. Anzi.

Riassumo qui gli elementi essenziali di un Jupyter Notebook:

  • è possibile creare una sequenza di celle, ciascuna delle quali può contenere codice oppure testo;
  • il linguaggio di programmazione sempre presente è Python3 (la versione più recente), a volte se ne affiancano altri (ma il Google Colab ha solo Python3);
  • le celle di testo possono contenere testo scritto in Markdown, che consente la marcatura del testo (grassetto, corsivo, link, liste, tabelle, …) e stringhe scritte in LaTeX, per l’inserimento di espressioni matematiche.

Il documento completo (testo + codice + output) può essere più o meno facilmente scaricato in formato html, per poi essere trasformato, ad esempio, in pdf.

Il tutto è più semplice di quanto appaia da questa mia descrizione, provare per credere.

Numeri felici: proviamo che 4 appartiene a un loop

Dominato dalla mia pigrizia, in modo molto poco canonico prendo per provato quello che mi racconta Wikipedia: un numero intero può essere felice oppure la sua sequenza può finire nel loop 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4.
Però un giro di prova lo faccio volentieri:

n0 = 4
n = n0
jmp = 1
sep = ' -> '
while n != 4 or jmp == 1:
  if jmp == 1:
    jmp = 0
    print (n, end = sep)
  sn = list(str(n))
  n = 0
  for c in sn:
    n += int(c)*int(c)
  if n == 4:
    sep = ': '
  print (n, end = sep)
print (n0, "finisce nel loop")

L’output del programma è, come atteso:

4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 4 finisce nel loop

Come funziona il programma

Non avendo grosse competenze in Python, l’algoritmo è molto semplice. Vale la pena di sottolineare l’utilizzo di alcuni costrutti molto semplici e comodi del linguaggio:

  • sn = list(str(n)), trasforma l’intero n in una stringa e successivamente nella lista delle sue cifre;
  • for c in sn:, delimita un ciclo di operazioni sugli elementi della lista, cioè sulle cifre di n;
  • n += int(c)*int(c), trasforma il carattere della singola cifra in un intero, ne fa il quadrato e ne accumula la somma nel nuovo valore di n;
  • print (n, end = sep), diversamente dal normale comportamento di un’istruzione print (), stampa senza andare a capo, utilizzando come fine riga di stampa la stringa ” -> ” oppure, alla fine del loop, “: “.

Il programma completo

Basta aggiungere poche righe al codice appena descritto, per adattarlo all’analisi degli interi positivi tra, ad esempio, 1 e 100.

nfelici, nloop = 0, 0
maxn = 100
for n0 in range(1,maxn + 1):
  n = n0
  jmp = 1
  sep = ' -> '
  while (n != 1 and n != 4) or jmp == 1:
    if jmp == 1:
      jmp = 0
      print (n, end = sep)
    sn = list(str(n))
    n = 0
    for c in sn:
      n += int(c)*int(c)
    if n ==1 or n == 4:
      sep = ': '
    print (n, end = sep)
  if n == 1:
    print (n0,"è un numero felice")
    nfelici += 1
  elif n == 4:
    print (n0, "finisce nel loop")
    nloop += 1
print ("Tra i primi",maxn,"interi, trovati",nfelici,"numeri felici e",
        nloop,"numeri che terminano nel loop")

Le modifiche riguardano, essenzialmente, l’inserimento di un ciclo esterno per analizzare un range di numeri invece di un solo valore e nell’aggiunta del contatore degli casi di numeri felici e quello dei numeri la cui sequenza finisce in loop.

L’output del programma:

1 -> 1: 1 è un numero felice
2 -> 4: 2 finisce nel loop
3 -> 9 -> 81 -> 65 -> 61 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 
           3 finisce nel loop
4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 4 finisce nel loop
5 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 5 finisce nel loop
6 -> 36 -> 45 -> 41 -> 17 -> 50 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 
           6 finisce nel loop
7 -> 49 -> 97 -> 130 -> 10 -> 1: 7 è un numero felice
8 -> 64 -> 52 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 8 finisce nel loop
9 -> 81 -> 65 -> 61 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 9 finisce nel loop
10 -> 1: 10 è un numero felice
11 -> 2 -> 4: 11 finisce nel loop
12 -> 5 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 12 finisce nel loop
13 -> 10 -> 1: 13 è un numero felice
14 -> 17 -> 50 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 14 finisce nel loop
15 -> 26 -> 40 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 15 finisce nel loop
16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4: 16 finisce nel loop
17 -> 50 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 17 finisce nel loop
[...]
99 -> 162 -> 41 -> 17 -> 50 -> 25 -> 29 -> 85 -> 89 -> 145 -> 42 -> 20 -> 4: 
            99 finisce nel loop
100 -> 1: 100 è un numero felice
Tra i primi 100 interi, trovati 20 numeri felici e 80 numeri che terminano nel loop

Ho eliminato il corpo centrale dell’output, per limitare la lunghezza del testo. L’output completo può essere scaricato, in pdf, da qui.

Comunque, i 20 numeri felici da 1 a 100 sono: 1, 7, 10, 13, 19, 23, 28, 31, 32, 44, 49, 68, 70, 79, 82, 86, 91, 94, 97, 100.


Se è vero che, per rallentare l’invecchiamento, occorre tenere la mente occupata in qualcosa di creativo, a mio parere il Google Colab offre uno strumento semplice per mettersi in gioco.
Certo, c’è da imparare un linguaggio di programmazione. Per questo basta fare un salto, ancorché virtuale, a Napoli!

Immagine di apertura di Greg Montani da Pixabay.

Ti è piaciuto? Condividilo!

Scritto da:

Pasquale

Mi chiamo Pasquale Petrosino, radici campane, da alcuni anni sulle rive del lago di Lecco, dopo aver lungamente vissuto a Ivrea.
Ho attraversato 40 anni di tecnologia informatica, da quando progettavo hardware maneggiando i primi microprocessori, la memoria si misurava in kByte, e Ethernet era una novità fresca fresca, fino alla comparsa ed esplosione di Internet.
Tre passioni: la Tecnologia, la Matematica per diletto e le mie tre donne: la piccola Luna, Orsella e Valentina.
Potete contattarmi scrivendo a: p.petrosino@inchiostrovirtuale.it