1. Quanti soldi hai in tasca?
Vuoi scoprire quanti soldi ha in tasca un tuo amico?
Chiedigli di:

  1. partire dalla somma (s) dei soldi che ha in tasca (ad es. € 35)
  2. Moltiplicarla per 2: 35x2=70 (2s)
  3. Aggiungere tre al prodotto: 70+3=73 (2s+3)
  4. Moltiplicare la somma per 5: 5x73=365 5(2s+3)=10s+15
  5. Sottrarre 6: 365-6=359 10s+15-6=10s+9
  6. Darti il risultato finale: 359
    Togli l’unità e saprai che ha in tasca 35 euro!

Il gioco si basa sulle proprietà algebriche dei numeri: si sa che in algebra x può assumere qualsiasi valore numerico. Se io scrivo l’espressione algebrica 10x+9 e poi assegno a x successivamente il valore 1, 4, 20
per x=01 il risultato sarà 019
per x=04 il risultato sarà 049
per x=20 il risultato sarà 209.
Cosa si nota?
Il numero scelto compare nelle decine tolto il numero finale e pertanto è sufficiente togliere le unità per indovinare il gioco.

Proviamo a trasformare questo gioco in un programma per il computer:
# quanti soldi hai in tasca
print "Vediamo se indovino subito quanti soldi hai in tasca"
print "Moltiplica il numero dei soldi che hai in tasca per 2"
print "Ora aggiungi 3 al prodotto"
print "Ora moltiplica per 5"
print "Sottrai 6"
soldiintasca = input ("Inserisci ora il risultato ottenuto")
soldiintasca = str(soldiintasca)
print "Secondo me hai in tasca", soldiintasca[1:3], "euro"

2. Indovina la data del compleanno
Chiedi a una tua amica di moltiplicare mentalmente per 5 il numero del mese in cui è nata (5m). Supponiamo che sia nata il 13 giugno (5x6=30).
Poi chiedile di:

  1. aggiungere 7: 30+7=37 (5m+7)
  2. moltiplicare per 4: 37x4=148 (4(5m+7)=20m+28)
  3. aggiungere 13: 148+13=161 (20m+28+13=20m+41)
  4. moltiplicare per 5: 161x5=805 (5(20m+41)=100m+205)
  5. aggiungere il giorno del mese in cui è nata: 805+13=818 (100m+205+g)
  6. sottrarre 205 dal numero ottenuto: 818-205=613 (100m+g+205-205).

Chiedi alla tua amica di dirti il numero ottenuto (613): dalle centinaia otterrai il mese e dalle unità il giorno.
Non ti resta che di ricordarti di augurarle, a tempo debito, Buon compleanno!

# indovina la data del compleanno
print "Vediamo se indovino subito la data del compleanno\n"
print "Moltiplica il numero del mese in cui sei nata per 5\n"
print "Ora aggiungi 7\n"
print "Ora moltiplica per 4\n"
print "Aggiungi 13\n"
print "Moltiplica per 5\n"
print "Aggiungi il giorno del mese in cui sei nato\n"
print "Sottrai 205 dal numero ottenuto\n"
compleanno = input ("Inserisci ora il risultato ottenuto\n")
compleanno = int(compleanno)
x= 999
if compleanno > x:
comp = str(compleanno) # trasforma il numero in stringa
else:
comp = '0' + str(compleanno)
if comp[0:2] == "01":
mese = "gennaio"
elif comp[0:2] == "02":
mese = "febbraio"
elif comp[0:2] == "03":
mese = "marzo"
elif comp[0:2] == "04":
mese = "aprile"
elif comp[0:2] == "05":
mese = "maggio"
elif comp[0:2] == "06":
mese = "giugno"
elif comp[0:2] == "07":
mese = "luglio"
elif comp[0:2] == "08":
mese = "agosto"
elif comp[0:2] == "09":
mese = "settembre"
elif comp[0:2] == "10":
mese = "ottobre"
elif comp[0:2] == "11":
mese = "novembre"
elif comp[0:2] == "12":
mese = "dicembre"
print "Sei nata il ", comp[2:4], "del mese di", mese

3. Indovina la data della Rivoluzione Francese
Chiedi a un tuo amico di:

  1. moltiplicare il numero del mese per 5: 5x7=35 (5m)
  2. sottrarre 3 al risultato: 35-3=32 (5m-3)
  3. raddoppiare il numero ottenuto: 32x2=64 (2(5m-3)=10m+6)
  4. moltiplicarlo per 10: 64x10=640 (100m-60)
  5. aggiungere il giorno: 640+14= 654 (100m-60+g)
  6. dirti il numero ottenuto:654
    Aggiungi 60 e otterrai 714
    (100m+g+60-60)

La data dell’inizio della Rivoluzione Francese è 14 luglio.

4. gioco del TRIS
Regole: i giocatori, che sono sempre solo due, scelgono ciascuno una lettera o un simbolo. Sul computer è meglio scegliere una lettera perché è più facile da rappresentare, quindi il primo giocatore sceglierà la N e il secondo la R.
Per giocare avranno a disposizione una scacchiera composta da 9 riquadri disposti su 3 file con il seguente schema:

   1 2 3
a  x x x
b  x x x
c  x x x

Inseriranno a turno un simbolo nello spazio scelto ancora libero. Vincerà chi per primo riuscirà ad inserire 3 simboli consecutivi in orizzontale oppure in verticale o in diagonale.
Ad esempio:

    1 2 3       1 2 3       1 2 3
a  N N N  a  N x R   a  N x x
b  R x x   b  R N x   b  N R x
c  x x R   c   x x N   c  N x R

Ora con molta attenzione impostiamo le varie parti del programma.

La scacchiera
Per rappresentare la scacchiera utilizzeremo nove variabili che chiameremo a1, a2, a3, b1, b2, b3, c1, c2, c3.
Ciascuna di queste variabili può assumere soltanto tre valori: “R” oppure “N” oppure “X”.
Inizialmente tutte le variabili assumono il valore X; successivamente, se, ad esempio, il giocatore che ha scelto “N” come suo simbolo mette quel simbolo nella riga a in corrispondenza della colonna 2, la variabile a2 assumerà il valore “N”.

La visualizzazione della scacchiera
Per visualizzare la scacchiera è sufficiente scrivere questo breve programma:

print '\t 1 \t 2 \t 3 \n'
print 'a \t', a1, '\t', a2, '\t', a3, '\n'
print 'b \t', b1, '\t', b2, '\t', b3, '\n'
print 'c \t', c1, '\t', c2, '\t', c3, '\n'

Avremo bisogno di visualizzare la scacchiera molte volte nell'arco della partita, quindi converrà scrivere una funzione per la visualizzazione.

def scacchiera():
     print '\t 1 \t 2 \t 3 \n'
     print 'a \t', a1, '\t', a2, '\t', a3, '\n'
     print 'b \t', b1, '\t', b2, '\t', b3, '\n'
     print 'c \t', c1, '\t', c2, '\t', c3, '\n'

Il controllo della vittoria
Questa operazione dovrà essere ripetuta dopo ogni mossa nel corso della partita e quindi converrà scrivere una funzione che chiameremo “vittoria”.
La funzione "vittoria" avrà un'unica variabile su cui operare, il nome “N” oppure “R” del giocatore che ha fatto la sua giocata. A questa variabile diamo il nome "n".
def vittoria(n):
     if ((a1 == n and a2 == n and a3 == n) or (b1 == n and b2 == n and b3 == n) or
        (c1 == n and c2 == n and c3 == n) or
       (a1 == n and b1 == n and c1 == n) or (a2 == n and b2 == n and c2 == n) or
       (a3 == n and b3 == n and c3 == n) or
       (a1 == n and b2 == n and c3 == n) or (a3 == n and b2 == n and c1 == n)):
          EsisteVincitore = 'si'
     else:
          EsisteVincitore = 'no'
     return EsisteVincitore

variabili globali, variabili locali
La funzione "vittoria" contiene una novità importante su cui dobbiamo riflettere insieme.
In una funzione di Python si possono introdurre variabili che appartengono al programma principale, come a1,..., c3..., che sono chiamate "variabili globali", perché hanno un valore globale indipendentemente da dove sono
scritte. Inoltre, vi sono variabili come "EsisteVincitore" che sono valide soltanto entro il corpo della funzione e che sono chiamate "variabili locali".
Le variabili locali non sono utilizzabili fuori dal corpo della funzione; inoltre, entro una funzione non si può modificare il valore di una variabile globale.
Se vogliamo utilizzare il valore di una variabile locale entro il programma principale dobbiamo scrivere, come abbiamo fatto in "vittoria", una istruzione come

return EsisteVincitore

L'istruzione "return" trasferisce il valore della variabile locale "EsisteVincitore" nella scatola che ha il nome della funzione (nel nostro caso, "vittoria"). Quando poi, nel programma principale, scriveremo, ad esempio,

partitafinita = vittoria('R')

il contenuto di "vittoria" sarà trasferito nella variabile globale "partitafinita". In sostanza, il contenuto della variabile locale "EsisteVincitore" (che può essere "si" oppure "no") viene dapprima trasferito nella scatola di nome "vittoria" e poi nella scatola di nome "partitafinita".

Il programma principale
Per scrivere il programma principale serviranno molte testoline pensanti perché è un programma un po' lungo e non sempre facilissimo.

# Il programma inizia ponendo tutte le nove variabili uguali a 'x'.
a1 = 'x'
a2 = 'x'
a3 = 'x'
b1 = 'x'
b2 = 'x'
b3 = 'x'
c1 = 'x'
c2 = 'x'
c3 = 'x'
# Poi visualizza la scacchiera

scacchiera()

# Quindi inizializza una variabile di nome "nmosse" che conta il numero delle mosse fatte dai giocatori e la variabile "partitafinita" che indica quando la partita è finita.

nmosse = 0
partitafinita = 'no'

# Poi informa che muoverà prima “N”.

print 'Il primo giocatore sarà N \n'

# A questo punto il programma entra in un ciclo che sarà percorso più volte. Poiché il numero totale delle mosse non può superare 9 (il numero delle posizioni sulla scacchiera) il ciclo sarà controllato dalla variabile "nmosse", che abbiamo posto = 0. Dopo la prima mossa, nmosse sarà posta = 1 e dopo la seconda mossa nmosse sarà posta = 2. A questo punto si torna all'inizio del ciclo che quindi sarà descritto al massimo 5 volte.
Prima di tutto si invita il giocatore a fare la propria mossa. Il programma verificherà che la mossa sia corretta con le istruzioni:

print 'Muova N \n'
mossafatta = 'no'
x = raw_input('Dove vuoi scrivere N: a1, a2, a3, b1, b2, b3, c1, c2, c3? \n')
if x == 'a1' and a1 == 'x':
   a1 = 'N'
   mossafatta = 'si'

# In sostanza il programma verifica che la posizione dove il giocatore intende collocare il proprio simbolo contenga una "x" e sostituisce quella "x" con il simbolo ("N" o "R") del giocatore stesso. La variabile "mossafatta" viene inizializzata al valore "no" e viene posta = "si" se il giocatore ha indicato una mossa corretta, ossia uno dei simboli a1,a2,.....c3, come propria risposta e non ha chiesto di sostituire il simbolo dell'avversario con il proprio. Se il giocatore richiede una mossa non legittima o dà una risposta non corretta, verrà squalificato.
Nota bene che quando si scopre che c'è un vincitore (EsisteVincitore = 'si') si pone nmosse = 10 per uscire subito dal ciclo. Se il numero delle mosse fatte è = 0 e non c'è vincitore, il programma decide il pareggio e pone nmosse = 10 per uscire dal ciclo.

while nmosse < 9 :
    print 'Muova N \n'
    mossafatta = 'no'
    x = raw_input('Dove vuoi scrivere N: a1, a2, a3, b1, b2, b3, c1, c2, c3\n')
    if x == 'a1' and a1 == 'x':
       a1 = 'N'
       mossafatta = 'si'
    elif x == 'a2' and a2 == 'x':
       a2 = 'N'
       mossafatta ='si'
    elif x == 'a3' and a3 == 'x':
       a3 = 'N'
       mossafatta ='si'
    elif x == 'b1' and b1 =='x':
       b1 = 'N'
       mossafatta ='si'
    elif x == 'b2' and b2 == 'x':
       b2 = 'N'
       mossafatta ='si'
    elif x == 'b3' and b3 == 'x':
       b3 = 'N'
       mossafatta ='si'
    elif x == 'c1' and c1 == 'x':
       c1 = 'N'
       mossafatta ='si'
    elif x == 'c2' and c2 == 'x':
      c2 = 'N'
      mossafatta ='si'
    elif x == 'c3' and c3 == 'x':
      c3 = 'N'
      mossafatta ='si'
    if mossafatta == 'no':
       print 'SQUALIFICATO!'
       partitafinita = 'si'
       nmosse = 10
    scacchiera()
    nmosse = nmosse + 1
    partitafinita = vittoria('N')
    if partitafinita == 'si':
       print 'Ha vinto N \n'
       nmosse = 10
    elif nmosse == 9:
       print 'PAREGGIO'
       nmosse = 10

# Se non si sono fatte tutte le mosse, il programma invita il giocatore "R" a fare la sua mossa e procede al controllo di questa mossa con la stessa logica che è stata adottata per "N".

if partitafinita == 'no' and nmosse < 9:
   nmosse = nmosse +1
   mossafatta = 'no'
   print 'La mossa tocca a R \n'
   x = raw_input('Dove vuoi scrivere R: a1, a2, a3, b1, b2, b3, c1, c2, c3? \n')
   if x == 'a1' and a1 == 'x':
     a1 = 'R'
     mossafatta = 'si'
  elif x == 'a2'and a2 == 'x':
    a2 = 'R'
    mossafatta = 'si'
  elif x == 'a3'and a3 == 'x':
    a3 = 'R'
    mossafatta = 'si'
 elif x == 'b1'and b1 == 'x':
   b1 = 'R'
   mossafatta = 'si'
 elif x == 'b2'and b2 == 'x':
  b2 = 'R'
  mossafatta = 'si'
 elif x == 'b3'and b3 == 'x':
  b3 = 'R'
  mossafatta = 'si'
 elif x == 'c1'and c1 == 'x':
 c1 = 'R'
 mossafatta = 'si'
elif x == 'c2'and c2 == 'x':
c2 = 'R'
mossafatta = 'si'
elif x == 'c3'and c3 == 'x':
c3 = 'R'
mossafatta = 'si'
if mossafatta == 'no':
   print 'SQUALIFICATO!'
   partitafinita = 'si'
   nmosse = 10
scacchiera ()
partitafinita = vittoria('R')
if partitafinita == 'si':
   print 'Ha vinto R \n'
   nmosse = 10