Categorie: Matematica Quiz
Tags: dieci quattro operazioni quiz
Scritto da: Vincenzo Zappalà
Commenti:42
Quiz: Prendiamo un bel 10 *
Accidenti! Siete in vacanza (molti almeno) e un bel quiz semplice semplice non può che far piacere. Però, questa volta, VOGLIO che rispondano solo i lettori normalmente silenziosi. Niente maghi o super esperti... Avanti, un po' di coraggio!!! Basta conoscere le quattro operazioni...
Avete a vostra disposizione quattro numeri interi: 1, 1, 5, 8. Utilizzando SOLO le quattro operazioni (moltiplicazione, divisione, somma, differenza), per il numero di volte che volete (una, nessuna, due, tre...) fate in modo che il risultato dell'espressione dia come risultato 10. OGNUNO DEI QUATTRO NUMERI DEVE APPARIRE, MA SOLO UNA VOLTA. Sono ammesse le parentesi...
Forza!!!!
QUI la soluzione (ma chi vuole provare a risolverlo senza leggerla, è il benvenuto!)
42 commenti
Ovviamente intendi può e deve apparire una volta sola vero? Altrimenti lo risolvo con 8+1+1=10 e lascio fuori il 5...
ci sono 1536 modi possibili...
Hai ragione Mik, non era abbastanza chiaro... ho scritto in modo più categorico.
Non capisco Leandro...
Il testo si capiva bene. Volevo dire che ci sono 768 combinazioni possibili, di cui solo alcune possono dare come risultato 10.
caro Leandro,
secondo me ce n'è una sola... ma ben vengano soluzioni alternative... (sempre che mi sia fatto capire bene...).
Forse ho capito il "baco". Ogni numero dei quattro deve rimanere staccato dagli altri. In altre parole, ogni singolo numero deve essere separato dagli altri da una operazione...
Usando la notazione polacca ci saranno 4! disposizioni di 4 numeri distinti preceduti da 3 operazioni anche ripetute cioè 4! * 4^3 = 1536 ma essendoci due numeri uguali le disposizioni saranno 768.
Ma a noi interessa solo quella con i numeri che ho dato io... quante ce ne sono?
Sono un alieno, e ho 15 dita (5 per ognuna delle mie 3 mani): quindi uso un sistema di numerazione a base 15, ovvero uso le cifre 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E. Quando scrivo 10, intendo quello che voi terresti indicate con 15. Di conseguenza, per me 1+1+5+8=10.
Ho barato?
sicuramente sì, caro Marco!
La numerazione è la nostra e non serve di certo la notazione polacca e nemmeno il calcolo delle disposizioni. Ricordate che ha solo un asterisco di difficoltà... 
8/(1-1/5)
Confesso che sono stato un po' birbante...
#!/bin/python3
def risultato(a,b,operazione):
if a!=None and b!=None:
if operazione=='+':
return a+b
elif operazione=='-':
return a-b
elif operazione=='*':
return a*b
elif operazione=='/' and b!=0:
return a/b
if a!=None and b!=None and (operazione=='/' and b!=0):
print("Errore")
return None
def espressionePiuRisultato(espressioneParziale,a,b,operazione,commuta):
if commuta:
return "("+str(b)+operazione+espressioneParziale+")",risultato(b,a,operazione)
else:
return "("+espressioneParziale+operazione+str(b)+")",risultato(a,b,operazione)
n=[1,1,5,8]
for i in range(4):
espressione1=str(n[i])
risultato1=n[i]
for operazione1 in "+-*/":
for j in range(4):
if i!=j:
for commuta1 in [False,True]:
espressione2,risultato2=espressionePiuRisultato(espressione1,risultato1,n[j],operazione1,commuta1)
for operazione2 in "+-*/":
for k in range(4):
if k!=i and k!=j:
for commuta2 in [False,True]:
espressione3,risultato3=espressionePiuRisultato(espressione2,risultato2,n[k],operazione2,commuta2)
for operazione3 in "+-*/":
for l in range(4):
if l!=i and l!=j and l!=k:
for commuta3 in [False,True]:
espressione4,risultato4=espressionePiuRisultato(espressione3,risultato3,n[l],operazione3,commuta3)
if risultato4==10:
print(espressione4+"=10")
È saltata l'indentazione, che è fondamentale per il python. Chi lo conosce, e volesse provare, sostituisca tutti i pallini (●) con il carattere di tabulazione:
#!/bin/python3
def risultato(a,b,operazione):
●if a!=None and b!=None:
●●if operazione=='+':
●●●return a+b
●●elif operazione=='-':
●●●return a-b
●●elif operazione=='*':
●●●return a*b
●●elif operazione=='/' and b!=0:
●●●return a/b
●if a!=None and b!=None and (operazione=='/' and b!=0):
●●print("Errore")
●return None
●
def espressionePiuRisultato(espressioneParziale,a,b,operazione,commuta):
●if commuta:
●●return "("+str(b)+operazione+espressioneParziale+")",risultato(b,a,operazione)
●else:
●●return "("+espressioneParziale+operazione+str(b)+")",risultato(a,b,operazione)
n=[1,1,5,8]
for i in range(4):
●espressione1=str(n[i])
●risultato1=n[i]
●for operazione1 in "+-*/":
●●for j in range(4):
●●●if i!=j:
●●●●for commuta1 in [False,True]:
●●●●●espressione2,risultato2=espressionePiuRisultato(espressione1,risultato1,n[j],operazione1,commuta1)
●●●●●for operazione2 in "+-*/":
●●●●●●for k in range(4):
●●●●●●●if k!=i and k!=j:
●●●●●●●●for commuta2 in [False,True]:
●●●●●●●●●espressione3,risultato3=espressionePiuRisultato(espressione2,risultato2,n[k],operazione2,commuta2)
●●●●●●●●●for operazione3 in "+-*/":
●●●●●●●●●●for l in range(4):
●●●●●●●●●●●if l!=i and l!=j and l!=k:
●●●●●●●●●●●●for commuta3 in [False,True]:
●●●●●●●●●●●●●espressione4,risultato4=espressionePiuRisultato(espressione3,risultato3,n[l],operazione3,commuta3)
●●●●●●●●●●●●if risultato4==10:
●●●●●●●●●●●●●print(espressione4+"=10")
Birbante, ma ingegnoso!
E bravo Marco, batti un cinq... ops... un quindici!
Oh mamma mia! Perfino i programmi.... Non spaventatemi i lettori meno preparati...
In realtà per ottenere 10 è necessario che 8 sia moltiplicato per 5/4 (o diviso per 4/5). Il 5 e i due 1 servono solo a costruire la frazione richiesta. Se avessi lasciato da parte il 5, sarei al massimo riuscito ad ottenere 20 (8/2 =4, e poi 5x4 = 20). Ah... questa tecnologia!!!!
Comunque, complimenti Marco!!
Bravo Marco, anche i numeri primi li trovano aiutandosi con i computer.
Escludendo atti di violenza nei confronti di chi ha proposto il quiz, per estorcergli la soluzione, ogni mezzo per arrivare al risultato è lecito. In particolare se viene spiegato e condiviso, come hai fatto tu.
Ti dirò, caro Mau, questa idea delle violenze fisiche non è mica da buttare... mumble
mumble... scommettiamo che il prossimo quiz riesco a risolverlo anch'io?!? 
ce l'avete mica con me? Comunque, ci starebbe bene una spiegazione terra-terra delle operazioni fatte per arrivare alla soluzione. Il programma non fa che eseguire operazioni ideate dall'uomo. Sarebbe bello seguire questa logica... se no cadiamo nei programmi "pappa pronta". Io sono il primo a non avere dimestichezza con certi linguaggi, dato che sono fermo al fortran... Vorrei imparare e capire...
Fornisco una versione commentata del programma usato. Ricordo che ogni pallino va sostituito con un carattere di tabilazione (o, è lo stesso, con 4 spazi). La prima riga, con la shabang (#!/bin/python3), serve, in un sistema Unix-Linux, per indicare al sistema operativo con quale programma va eseguito, ed è perfettamente inutile in un sistema Windows.
#!/bin/python3
# Questa riga è un commento, poiché inizia con il simbolo '#' (cancelletto)
# I commenti non vengono eseguiti, e servono solo a spiegare il programma
def risultato(a,b,operazione):
# risultato è una funzione che restituisce (return) il risultato dell'operazione
# nel caso in cui sia presente una divisione per 0 restituisce None (niente, ovvero non definito)
# nel caso in cui a o b siano None, vuol dire che, in precedenza, era stata incontrata
# una divisione per 0, e quindi si restituisce ancora None
●if a!=None and b!=None:
# se a è diverso da none e B è diverso da None
# si noti che if, come elif, richiede che una o più istruzioni vengano eseguite
# solo in certi casi. Per far capire a python quante righe debbano essere eseguite a condizione che,
# è obbligatorio indentarle, ovvero spostare a destra l'inizio delle righe.
# Si noti che anche ciò che segue def è indentato a destra, per far capire a python dove finisce
# la definizione la definizione della funzione.
# Tutte le righe a cui segue un blocco devono terminare con i due punti (:)
●●if operazione=='+':
# Se operazione è uguale al simbolo '+'. Si noti che
# operazione='+' assegna alla variabile operazione il valore '+',
# mentre operazione=='+' (con il simbolo = ripeturo due volte)
# si limita a testare se il primo e il secondo membro dell'espressione sono uguali,
# senza assegnare nessun valore
●●●return a+b
●●elif operazione=='-':
# elif è la contrazione di else if, ovvero altrimenti se
●●●return a-b
●●elif operazione=='*':
●●●return a*b
●●elif operazione=='/' and b!=0:
●●●return a/b
●if a!=None and b!=None and (operazione=='/' and b!=0):
# questo non deve capitare, solo le 4 operazioni consentite
●●print("Errore")
●return None
●
def espressionePiuRisultato(espressioneParziale,a,b,operazione,commuta):
# Questa funzione restituisce due risultati:
# il primo è una stringa (ovvero, una successione di caratteri)
# e rappresenta, l'espressione come la scriveremmo su carta;
# il secondo è un numero, e rappresenta il risultato dell'operazione.
# Si noti che il simbolo + permette di sommare due numeri (per esempio, 1+1 diventa 2),
# ma, se viene usato con due stringhe, si limita a concatenarle, ovvero a scriverle
# una dopo l'altra: per esempio, '1'+'1' diventa '11'
# Quindi il primo valore che questa funzione restituisce è così costituito:
# aperta parentesi, prima espressione, simbolo dell'operazione, seconda espressione, chiusa parentesi
●if commuta:
●●return "("+str(b)+operazione+espressioneParziale+")",risultato(b,a,operazione)
●else:
●●return "("+espressioneParziale+operazione+str(b)+")",risultato(a,b,operazione)
n=[1,1,5,8]
# n è una lista, ovvero un elenco di valori
# in questo caso n è l'elenco dei numero consentiti
# si noti che n[0] rappresenta il primo elemento della lista, ovvero 1.
# Analogamente, n[1] è il secondo (1), n[2] il terzo (5) e n[3] il quarto (8).
for i in range(4):
# Questo è un ciclo, che viene eseguito 4 volte, dando ad i prima il valore 0, poi 1, poi 2 e infine 3.
# range(4) fornisce una lista di valori che partono da 0, si incrementano ogni volta di 1 e finiscono
# quando si ottiene 4 (nel senso che 4 è il primo valore ad essere escluso).
# Come per if e elif, la riga che inizia con for deve terminare con i due punti (:)
# ed essere seguita da un blocco indentato a destra
●espressione1=str(n[i])
# Viene assegnato alla variabile espressione1 il valore n[i], ovvero prima 1, poi 1, poi 5 e infine 8
# la funzione str trasforma in stringa il valore intero originario
●risultato1=n[i]
# Viene assegnato alla variabile risultato1 il valore n[i], che è un valore intero
●for operazione1 in "+-*/":
# Per ogni carattere presente nella stringa "+-*/":
# la prima volta operazione1 è il simbolo dell'addizione, poi della sottrazione,
# poi della moltiplicazione, e infine della divisione
●●for j in range(4):
# secondo numero, sempre tra quelli della lista
●●●if i!=j:
# ma non deve essere già stato usato, quindi i deve essere diverso da j
●●●●for commuta1 in [False,True]:
# commuta1 può essere falso (la prima volta) o vero (la seconda)
●●●●●espressione2,risultato2=espressionePiuRisultato(espressione1,risultato1,n[j],operazione1,commuta1)
# Usiamo la seconda funzione definita più in alto (espressionePiuRisultato).
# Ricordiamo che il primo valore (espressione2) è una stringa che rappresenta l'espressione usata,
# mentre il secondo (risultato2) è un numero che rappresenta il risultato
●●●●●for operazione2 in "+-*/":
# seconda operazione
●●●●●●for k in range(4):
# terzo numero, che non deve anche qui essere già stato usato
●●●●●●●if k!=i and k!=j:
●●●●●●●●for commuta2 in [False,True]:
# come sopra, possiamo o no invertire l'ordine dei due numeri
●●●●●●●●●espressione3,risultato3=espressionePiuRisultato(espressione2,risultato2,n[k],operazione2,commuta2)
# espressione e risultato applicando la seconda operazione
●●●●●●●●●for operazione3 in "+-*/":
# terza operazione
●●●●●●●●●●for l in range(4):
# quarto numero, che, ancora una volta, non deve essere già stato usato
●●●●●●●●●●●if l!=i and l!=j and l!=k:
●●●●●●●●●●●●for commuta3 in [False,True]:
# come sopra, possiamo o no invertire l'ordine dei due numeri
●●●●●●●●●●●● espressione4,risultato4=espressionePiuRisultato(espressione3,risultato3,n[l],operazione3,commuta3)
# espressione e risultato applicando la terza operazione
# abbiamo finito il calcolo: qui controlliamo se il risultato è 10
●●●●●●●●●●●●if risultato4==10:
# in caso affermativo stampiamo sul terminale l'espressione, e precisiamo che il risultato è 10 ("=10")
●●●●●●●●●●●●●print(espressione4+"=10")
Direi che " provarle tutte" è una modalità che funziona sempre.
Cartesio la chiamava "enumerazione dei casi", altri la chiamano "forza bruta".
La lotta fra crittografi e scassinatori non finisce mai, tra poco avremo pure i computer quantistici con cui riusciranno a decrittare anche i protocolli più sofisticati e tutto ricomincerà da capo.
Una soluzione basata su una logica non esaustiva, ossia su un algoritomo più efficiente, è certo attraente ma, dal punto di vista pratico, se il problema ha un livello di complessità modesto rispetto agli strumenti usati, si fa prima a studiare tutti i casi possibili.
il provarle tutte è proprio ciò che fa il computer (solitamente o, almeno, ai miei tempi). Esiste però la possibilità di ragionare sopra i numeri e cercare di capire quali sono le operazioni utili oppure no, per ottenere un certo risultato. Non dico proprio un'espressione analitica, ma almeno una decisa eliminazione di operazioni inutili. Il dir "tanto le fa il computer" mi sta bene in campo professionistico, ma non in campo divulgativo... Almeno questa è la mia antiquata idea. Arrivare all'idea di moltiplicare i due numeri più grandi per una certa frazione e vedere se questa frazione è ottenibile mi sembra estremamente più "educativo" per chi non ha dimestichezza con bit e bitibit... Ma sicuramente sono io che sono fuori tempo e certe cose sono ormai conosciute da tutti (tranne me). Pazienza... il mondo gira e non si può rimanere indietro...
e io sto tanto bene indietro... e mi beo di Euclide, Pappo e Pitagora... e al diavolo le pappe pronte...
Beh... usare un programma pappa pronta e saperne compilare uno ad'OK (
) sono cose ben diverse.
Per dare l'esame di informatica alla facoltà di economia (era il '95 e già nelle aziende si apprezzava la comodità di Windows con i suoi Word ed Excel), dovetti imparare il Cobol... in teoria lo sapevo (infatti sul libretto mi verbalizzarono un bel 28), ma i miei due tentativi pratici di realizzare qualcosa che funzionasse furono fallimentari: un programma andava in errore e l'altro (se non ricordo male volevo riuscire a calcolare la somma di tutti gli interi compresi tra altri due) girava, ma restituiva un risultato sbagliato. Rinunciai e lasciai perdere il Cobol, tanto nella vita non mi sarebbe mai più servito... vero, ma sforzare le meningi per provare a creare un programma non fu senz'altro inutile, peccato non avere insistito fino a raggiungere l'obiettivo, sarebbe stata una bella soddisfazione e, ai tempi, di sicuro alla mia portata. Errori di gioventù...
Sono pienamente d'accordo... non per niente parlavo di professionalità. Chi costruisce i programmi per Celestia è sicuramente bravo, ma chi usa Celestia senza capire il problema è un "utilizzatore finale". Se il programmatore di Celestia mi spiegasse quali sono i punti astronomici essenziali da risolvere... Molto bene. ma se mi spiegasse il tutto con una serie di comandi di un programma mi servirebbe ben poco, non essendo un informatico.
Faccio un classico esempio (che mi riguarda da vicino). Il programma per trovare le famiglie asteroidali l'ho fatto io e ne ero molto compiaciuto, essendo particolarmente veloce. Era in banale fortran, ma usava logiche puramente matematiche per minimizzare il tempo. Se io avessi spiegato il programma attraverso i comandi fortran (decisamente più comprensibili di molti altri codici) non avrei assolutamente spiegato la logica astronomica e statistica che ci stava dietro. Non avrei certo fatto divulgazione astronomica. Molto meglio spiegare le cose con i diagrammi a stalattite e con la metrica utilizzata per le "distanze".
Secondo me, anche i quiz devono avere un valore didattico e non solo un valore limitato a dare la risposta esatta. Se io chiedessi la magnitudine assoluta di una stella, data la magnitudine apparente e la distanza, avrei piacere in una risposta astronomica e non di una del tipo: "Celestia dice X", anche se chi risponde è il programmatore di Celestia.
Ma stiamo discutendo del sesso degli angeli... ognuno la vede in modo diverso e ognuno è libero di agire come preferisce. Io accetto tutto, anche la libertà di esprimere le impressioni e le valutazioni personali (anche mie)...
Sesso degli angeli? Non sono d’accordo, per me questi scambi di opinione sono l’essenza del blog, ciò che lo distingue (in meglio o in peggio, a seconda delle preferenze personali) dai tanti forum che si trovano nel web, dove va bene qualunque cosa tu scriva, ma ti tirano le orecchie se divaghi di una virgola dall’oggetto del post.
Una cosa è la padronanza del linguaggio, Dany, della sua sintassi formale e delle potenzialità che offre, un'altra cosa è saper mettere a punto la logica da fargli eseguire. Equivale, nel linguaggio naturale a conoscere bene il lessico e la costruzione linguistica, da un lato, e avere la fantasia creativa per narrare una vicenda, dall'altro.
Quello che intendo con "enumerazione dei casi" (usiamo il linguaggio di Cartesio) è più o meno questo:
Dato 1 Operatore Dato 2 = Risultato 1
Dato 3 Operatore Risultato 1 = Risultato 2
Dato 4 Operatore Risultato 2 = Risultato 3 …. vale 10?
I numeri assegnati ( 1,1,5,8 ) corrispondono ai quattro Dati
Il termine Operatore rappresenta una delle operazioni aritmetiche ( + - x : )
Il numero di valori ottenibili per il Risultato 1 dipende dalle scelte, per Dato 1, di uno dei 4 valori possibili, per Dato 2, di uno dei restanti 3 e per operatore, di uno dei quattro simboli. Totale 4*3*4 = 48 valori.
Per ciascuno dei 48 valori procediamo con la seconda operazione ( una delle 4 ) che verrà eseguita tra Risultato 1 e due possibili valori rimanenti dei dati. Avremo 2*4*48 = 384 combinazioni.
Per ciascuna delle 384 combinazioni resterà da eseguire una operazione (tra le 4 ) che agirà sull'ultimo dato rimanente e su Risultato 2. In tutto 1*4*384 = 1536 risultati.
Dato che il numero 1 compare 2 volte tra i dati del problema i valori distinti dei risultati saranno la metà, ossia 768 ( come aveva anticipato immediatamente Leandro nel suo commento)
Non resta che disporre ordinatamente le combinazione e mettere in evidenza quella (o quelle) che genera il risultato finale = 10 come richiesto.
Qui lo sforzo intellettuale di cui parla Enzo, per immaginare geniali scorciatoie logiche, è nullo. Occorre però la padronanza del linguaggio per "fargli eseguire" correttamente le operazioni necessarie. Su questo versante non possiamo dire che tale competenza sia "pappa pronta".
Ci sono poi problemi più complessi, in cui l'enumerazione dei casi non è una soluzione efficiente e occorre invece un linea strategica per ridurre e semplificare il problema, per evitare di imboccare "rami secchi" e per convergere velocemente alla soluzione. La logica dell'algoritmo può avere una valenza addirittura estetica, una bellezza classica che sarebbe stata apprezzata da molti filosofi Greci.
Il fatto che l'esecuzione dell'algoritmo richieda poi strumenti di calcolo più poderosi di carta e matita, come la competenza necessaria a padroneggiare un linguaggio di programmazione, non fa altro che introdurre una componente intellettuale addizionale, frutto di studio e applicazione mentale. ( anche questa componente sarebbe di certo piaciuta a Euclide & Co)
Tu inviti la lepre a correre, caro Mau!
È una vita che Scherzy vuole intervistare Alan Turing per farsi raccontare delle sue macchine intelligenti e di quanto l’interazione uomo pensante - macchina sia stata determinante nel decidere le sorti della seconda guerra mondiale... prima o poi ce la farà!
Una splendida idea!
Ancora una volta, si parte con un piccolo quiz e poi....
Mau dice: "Occorre però la padronanza del linguaggio per "fargli eseguire" correttamente le operazioni necessarie. Su questo versante non possiamo dire che tale competenza sia "pappa pronta". Esattamente quello che ho detto prima io... Chi prepara un programma è estremamente abile, ma una cosa è essere abile e un'altra rendere questa abilità alla portata di tutti. Se invece l'abilità viene digerita solo attraverso il suo risultato, diventa "pappa pronta" per chi la usufruisce. L'ideale sarebbe spiegare a parole e con schemi di semplicità estrema cosa è stato comandato al computer attraverso comandi troppo professionali per molti.
Un singolo comando impregnato di if, else, goto del vecchio fortran restava arido se non veniva spiegato in modo semplice a tutti.
Faccio un esempio: moltiplica 1 per 1. OK moltiplica il risultato per 5. Moltiplica il risultato per 8. E' venuto 10? No, allora tona al primo passaggio e usa il segno più. 1 per 1. Poi il risultato più 5 e poi ancora + 8. E' venuto 10? No. Torna indietro... ecc. ecc. E' questo l'algoritmo di base? Beh... sarebbe veramente esorbitante. Forse si potrebbero ridurre i passaggi inserendo qualche ulteriore "blocco" preventivo, con vari if, goto, else, ecc.
La parte più interessante sarebbe una spiegazione semplificata dei passaggi intermedi atti a ridurre il numero dei passaggi. Trattando con poche centinaia di numeri poco importa... ma provate con integrazioni numeriche su milioni di anni o col calcolo delle distanze reciproche di tutte le possibili combinazioni di decine di migliaia di oggetti...
Resto della mia idea... nel quiz in questione, vista la sua semplicità e avendo la conoscenza del risultato, pochi passaggi logici adattati ai numeri a disposizione avrebbero limitato le possibilità a pochi tentativi e reso del tutto inutile una calcolo ripetitivo limitato solo a lettori preparati a un certo gergo. proprio da situazioni del genere nascono, alla fine, programmi "pappa pronta", che poco insegnano, anche se chi li ha creati è stato molto abile.
Ha fatto bene Marco ad aprire il cassetto segreto che conteneva il mistero di un "pappa pronta" adatto allo scopo. Mi sarebbe, però, anche piaciuto un approccio più legato a ragionamenti particolari che a ripetizioni continue che sicuramente avrebbero portato al risultato. In fondo, avendo tempo, anche una scimmia scriverebbe la divina commedia...
Ribadisco i complimenti a Marco e al suo programmino, ma si poteva anche agire in modo più "umano".
Tutto lì...
Una richiesta per Marco. Ho iniziato a leggere la tua spiegazione del vodice utilizzato per risolvere il wuiz, ma mi vi sono velocemente smarrito
Un po' di programmazione ce l'ho sul groppone, ma risale ormai alla preistoria, quando scrissi in basic alcuni programmi di calcolo strutturale.
Ma, piu' che capire il codice, mi interessa conoscere la logica che hai messo alla base del tuo ragionamento, sfociato poi nel programma. Cioe', in pratica, cosa fa questo programma ?
Insomma, qui si potrebbe aprire un’appendice al quiz: chi se la sente di scrivere un bel diagramma a blocchi con la sequenza di istruzioni da dare alla macchina per farla arrivare al risultato? Si tratta di puro e semplice ragionamento, non è “roba” per i soli informatici.
Una volta fatto, può essere tradotto in qualunque linguaggio di programmazione, anche in Cobol! (Ma non chiedetelo a me, per favore, preferisco dedicare il mio tempo libero a Bohr e Turing!)
Leggo solo ora il commento di Mau, che credo risponda gia' alla mia domanda. Quindi, il programma fa una ricerca di tutte le possibili combinazioni tra le 4 operazioni e i 4 numeri dati e le confronta con il valore cercato (10) , se ho capito bene. Chissa' che non di possa fare una cosa del genere pure con Excel.
(Scusate gli errori ortografici, sto sctivendo con lo smartphone)
Sono pienamente d'accordo con Artù
. Va esattamente nella direzione che dicevo io: capire esattamente cosa fa il programma tradotto in blocchi o frasi indipendenti dai codici utilizzati. I programmi, in genere, prima si pensano e poi si scrivono. Ecco, Artù ed io (forse non i soli) siamo interessati a seguire bene la logica seguita prima della stesura... 
diciamo Che l importanza. Del metodo di Marco si vede poco in questo singolo caso in cui un ragionamento diretto avrebbe portato più velocemente e direttamente allo scopo; fatto sta che esso rimane valido se a 10 sostituiamo un altro valore. Quindi non ha risolto solo un problema, ma tanti altri.
dimenticavo.. E a 1 1 3,8 qualsiasi altra combinazione di numeri interi.in questo sta l importanza della programmazione , qualsiasi sia il linguaggio.
Questa pagina mostra che si può benissimo fare anche con excel...
Si applicano le possibili operazioni alle possibili coppie di numeri. Il risultato è la tabella 1. (gialla)
Si opera poi sul terzo numero e il risultato 1 in tutti i modi possibili, ottenendo il risultato 2 ( azzurra e rosa)
Infine entra in gioco l'ultimo dato che si compone con i possibili operatori al risultato 2, dando il risultato 3 (la tabella prosegue con le altre righe...)
Su sfondo viola il risultato finale (10) e i valori che lo hanno generato nei passaggi precedenti (0,8 e 0,2 )
Concordo pienamente con Umberto. Ad esempio, nella ultima tabella excel (risultato 3) troviamo tutti i valori che si possono ottenere dalle varie combinazioni. Questo significa anche la certezza che, nello specifico caso del risultato = 10, la soluzione è "unica" , cosa che non credo si possa dimostrare altrimenti.
Se poi sostituiamo ai dati 1 1 5 8 altri valori, abbiamo già la risposta.
La logica delle operazioni (parlo della soluzione excel, ma credo che corrisponda anche alla idea di Marco) è di generare risultati parziali a partire da tutte le coppie di dati possibili , manipolandole con gli operatori aritmetici.
Successivamente si fa interagire un terzo numero con la prima serie di risultati , applicando le operazioni , e si ottiene una seconda serie.
Infine si fa interagire il quarto numero con i risultati della seconda serie utilizzando i soliti operatori.
Avremo così sotto i nostri occhi la terza serie di risultati e tra essi basterà cercare il valore desiderato. Si risale facilmente attraverso le tabelle precedenti alle operazioni che lo hanno generato. (risalendo la concatenazione dei dati sullo sfondo viola)
perfetto... speriamo che sia sufficiente per la maggior parte dei lettori e non per i soliti esperti... Io devo pensare anche a quelli... L'orbita degenere del quiz sulla caduta della Terra è l'esempio classico tra una risoluzione basata sulle regole e una basata sull'intuizione e la fantasia... Insomma, ce n'è per tutti i gusti... Mi ricordano tanto gli esami della Normale di Pisa...
Una precisazione sul numero delle combinazioni.
Delle 1536 totali, tenendo conto del fatto che due dei quattro numeri sono uguali ( i due 1), si arriva a 896 combinazioni distinte, che corrispondono a 7/12 , e non alla metà di 1536, ossia 768.
Si può comprendere facilmente il risultato considerando che a partire dalle 12 combinazioni a coppie dei 4 numeri ci si riduce a solo 7 combinazioni distinte e, applicando le 4 operazioni, si hanno 28 risultati.
Successivamente i 28 risultati si possono combinare in 2 modi ai numeri restanti e, applicando le 4 operazioni si generano 28×2×4= 224 risultati.
Infine i 224 risultati si combinano con l'ultimo numero nelle 4 operazioni originando 224×1×4= 896 risultati.
Complimenti a Marco per avere risolto il quiz e per il suo programma.
Un contributo alla discussione su quante sono le possibili espressioni valide diverse che si possono ottenere con i 4 numeri non ripetuti e le 4 operazioni. A me vengono 7680. Nel caso particolare vengono dimezzate per la presenza di due 1 nei 4 numeri diventando 3840. Di queste 30 contengono una divisione per 0. Questi valori non tengono conto delle proprietà commutativa ed associativa che producono risultati uguali per espressione diverse.
Per calcolarle ho utilizzato la notazione polacca inversa citata prima da Leandro che permette di evitare l'uso delle parentisi. Ci sono 5 tipi di sequenze valide con 4 numeri, che elenco sotto. Con N indico un numero e con O indico una operazione delle 4 ammesse dal quiz.
N N N N O O O es 1 1 5 8 ++: equivalente a 1:(1+(5+8))
N N N O N O O es 5 8 1 - 1 + x equivalente a 5x( (8-1)+1)
N N N O O N O es 8 1 5 x + 1 - equivalente a 8+1x5-1
N N O N O N O es 5 1 + 1 + 8 x equivalente a ((5+1)+1)*8
N N O N N O O es 8 1 + 5 1 - x equivalente a (8+1)x(5-1)
(Le altre non sono ammissibili perché ci sarebbero operazioni che non hanno gli operandi,
es. N O N N N O O es 5 + 1 1 8 - - x il + non ha due operandi a sinistra)
In ciscuna sequanza i numeri che compaiono possono essere scelti in 4x3x2x1 modi diversi, mentre le operazioni in 4x4x4 modi diversi. Per ciscun tipo ci sono quindi 1536 sequenze diverse che si dimezzano nel nostro caso particolare per la presenza dei due 1 tra i numeri. In totale ci sono quindi 1536x5=7680 sequenze potenzialmente diverse. Diventano 3840 nel nostro caso.
Vi sottopondo una considerazione sulla completezza delle sequenze ammesse ottenibili con l'algoritmo:
Dato 1 Operatore Dato 2 = Risultato 1
Dato 3 Operatore Risultato 1 = Risultato 2
Dato 4 Operatore Risultato 2 = Risultato 3
Non mi sembra che da questo algoritmo possano uscire sequenze del tipo (5+1)x(8+1). Comunque non servono per ottenere la risposta del quiz che non è di questo tipo.