diff --git a/it/task-1.md b/it/task-1.md new file mode 100644 index 0000000..fd273bb --- /dev/null +++ b/it/task-1.md @@ -0,0 +1,35 @@ + + +
+ CodeAbbey Monks struggle with bug
+ Artist's impression of programmers struggling with The Bug.
+ Note that proper tools may be helpful! +
+ +Dato che a volte iniziare può essere difficile, proviamo a risolvere il problema più dempilce possibile. +L'obiettivo è fare pratica con l'invio delle risposte, ecc. + +Dobbiamo sommare due numeri e comunicare il risultato. Anche se puoi farlo manualmente, prova a scrivere un programma semplice +in qualsiasi linguaggio tu conosca, ti piaccia o voglia imparare. + +_[**Per favore guarda QUESTO VIDEO da codeabbey author**](https://www.youtube.com/watch?v=c6WWZe12ves) +to get visual demo of writing and submitting solution (as briefly described below)._ + +###Come inviare la soluzione + +Se hai effettuato l'accesso, vedrai i seguenti campi qui sotto: + +- **Test data** contiene "i dati di input" o "casi da testare" - due numeri che dobbiamo sommare. +- **Your answer** - è dove inserisci il risultato dopo aver alaborato i dati. +- **Your solution** - è dove salvi il codice del programma. Non viene controllato + (almeno automaticamente), ma ti aiuterà a riutilizzare il codice nelle attività successive. + Puoi rivedere l'attività in qualsiasi momento per visualizzare la soluzione inviata +Esempio: + + input data: + 3 5 + + soluzione: + 8 +Forniamo **[esempi](../wiki/running)** del programma in diversi linguaggi popolari, +ma ti consigliamo vivamente di non consultarli prima di aver risolto questa attività. :) diff --git a/it/task-10.md b/it/task-10.md new file mode 100644 index 0000000..d6c354f --- /dev/null +++ b/it/task-10.md @@ -0,0 +1,29 @@ + +Un problema molto comune nella programmazione computazionale è determinare la legge di base a cui obbedisce un fenomeno. +A scopo didattico, esercitiamoci con una semplice variante: scoprire la dipendenza lineare tramite due osservazioni date (ad esempio, come il +prezzo di un prodotto dipende dalle sue dimensioni, dal suo peso, ecc.) + +La funzione lineare è definita dall' equazione: + + y(x) = ax + b + +Dove `a` e `b` sono delle costanti. +Ad esempio, con `a=3, b=2` la funzione produrrà i valori `y = 2, 5, 8, 11...` +per `x = 0, 1, 2, 3...` + +Il tuo compito è determinare `a` e `b` tramite due punti appartenenti alla funzione. +Ovvero, ti vengono fornite due coppie di valori `(x1, y1), (x2, y2)` che soddisfano l'equazione della funzione +- e dovresti ripristinare l'equazione stessa. + +**I dati di input** contengono il numero di casi di test nella prima riga +e poi i casi di test stessi in righe separate. +Ogni caso contiene `4` numeri interi (`x1 y1 x2 y2`). +**Anche le risposte** devono essere numeri interi e vanno scritte in riga, separate da spazi e racchiudendo ogni coppia tra parentesi, ad esempio: + dati input: + 2 + 0 0 1 1 + 1 0 0 1 + + risposte: + (1 0) (-1 1) + diff --git a/it/task-11.md b/it/task-11.md new file mode 100644 index 0000000..fe6fdd3 --- /dev/null +++ b/it/task-11.md @@ -0,0 +1,42 @@ + +Questo esercizio di programmazione ha lo scopo di introdurre le basi del sistema numerico. Inizieremo ad apprendere +questo concetto giocando con il sistema decimale che usiamo quotidianamente (anche se è importante tenere presente che il computer +non lo utilizza internamente, ma converte i numeri in esso solo quando devono essere mostrati all'utente). + +Poiché qualsiasi numero maggiore di 9 è rappresentato da più cifre, possiamo calcolare la somma di queste cifre. Ad esempio, +per i numeri `1492` e `1776` otteniamo: + + 1 + 4 + 9 + 2 = 16 + 1 + 7 + 7 + 6 = 21 + +In questo compito ti verranno forniti diversi numeri e ti verrà chiesto di calcolare la somma delle loro cifre. + +**Importante:** sebbene molti linguaggi di programmazione abbiano funzioni integrate per convertire i numeri in stringhe +(da cui è possibile estrarre cifre), non dovresti usarle (dato che il tuo obiettivo è imparare alcuni trucchi di programmazione). + +**Invece** è necessario implementare un algoritmo con divisione ripetitiva per 10 (base del sistema numerico) e somma dei +resti. Leggi l'articolo [Numero in cifre][numtodig] per i dettagli sull'algoritmo. + +[numtodig]: ../wiki/number-to-digits + +###Enunciato del problema + +**Datidi input** saranno nel seguente formato: + +- la prima riga contiene `N`, il numero di valori da elaborare; +- seguiranno le righe `N` che descrivono i valori per i quali la somma delle cifre deve essere calcolata con `3` numeri interi `A B C`; +- per ogni caso è necessario moltiplicare `A` per `B` e aggiungere `C` (ovvero `A * B + C`), quindi calcolare la somma delle cifre del risultato. + +**Risposta** dovrebbe avere `N` risultati, separati da spazi. Ad esempio: + + dati di input: + 3 + 11 9 1 + 14 90 232 + 111 15 111 + + risposta: + 1 16 21 + + +Qui il primo caso richiede di calcolare `11*9+1 = 100` e la sua somma di cifre è `1+0+0 = 1`. diff --git a/it/task-12.md b/it/task-12.md new file mode 100644 index 0000000..c226bef --- /dev/null +++ b/it/task-12.md @@ -0,0 +1,48 @@ +Gestire i resti può causare grossi grattacapi ai programmatori alle prime armi. Scriviamo un semplice programma che +ha questa operazione al suo centro per studiare meglio la divisione intera. Allo stesso tempo, faremo un po' di pratica nella +gestione delle date, che a volte crea grattacapi anche ai programmatori più esperti. + + +In aritmetica, il resto (o modulo) è la quantità "rimasta" dopo aver eseguito la divisione di due numeri interi +che non sono divisibili in parti uguali (da [Wiki][wiki]). Questo esercizio fornirà ulteriore pratica con l'operazione modulo. + +[wiki]: http://en.wikipedia.org/wiki/Remainder + +Supponiamo di ricevere due timestamp, ad esempio quando il treno o il traghetto inizia il suo viaggio e quando lo termina. +Potrebbe apparire così: + + start: May 3, 17:08:30 + end : May 8, 12:54:15 + +E siamo curiosi di sapere quanto tempo (in giorni, ore, minuti e secondi) viene impiegato per viaggiare (forse, per +scegliere una variante più veloce). Come si potrebbe ottenere questo risultato? + +Uno dei modi più semplici è: + +- convertire entrambi i timestamp in numeri grandi, che rappresentano i secondi dall'inizio del mese (o dell'anno o del secolo); +- calcolare la loro differenza, ovvero il tempo di percorrenza in secondi; +- riconvertire questa differenza in giorni, ore, minuti e secondi. + +La prima operazione potrebbe essere eseguita moltiplicando i minuti per `60` e le ore per `60*60` ecc. e sommando tutti i valori. +La terza operazione dovrebbe essere eseguita al contrario, eseguendo diverse divisioni mantenendo i resti. + +In questo compito ci vengono fornite diverse coppie di timestamp. Supponiamo che entrambe le date della coppia siano sempre nello +stesso mese, quindi verrà fornito solo il numero del giorno. Vogliamo calcolare la differenza tra i timestamp in ciascuna coppia. + +**Dati di input:** la prima riga contiene il numero di casi di test, le altre righe contengono i casi di test stessi. +Ogni caso di test contiene `8` numeri, `4` per ogni timestamp: `giorno1 ora1 min1 sec1 giorno2 ora2 min2 sec2` (il secondo +timestamp sarà sempre successivo al primo). +**Risposta:** per ogni caso di test, la differenza deve essere visualizzata come segue `(giorni ore minuti secondi)` - si prega di +notare le parentesi quadre - separate da spazi. + +Esempio: + + dati input: + 3 + 1 0 0 0 2 3 4 5 + 5 3 23 22 24 4 20 45 + 8 4 6 47 9 11 51 13 + + risposte: + (1 3 4 5) (19 0 57 23) (1 7 44 26) + diff --git a/it/task-13.md b/it/task-13.md new file mode 100644 index 0000000..4d7e94d --- /dev/null +++ b/it/task-13.md @@ -0,0 +1,22 @@ +Questo programma assomiglia ad algoritmi più complessi per il calcolo del CRC e di altri checksums nonchè a funzioni hash su +stringhe di caratteri. Inoltre fornisce un ulteriore esercizio sulla suddivisione dei valori in cifre decimali. Potresti +provare [Somma delle Cifre](./sum-of-digits) prima di questo. + +Calcoliamo la somma delle cifre, come in precedenza, moltiplicando ogni cifra per la sua posizione (contando da sinistra a destra +partendo da 1). Ad esempio, dato il valore `1776` calcoliamo la somma **ponderata** delle cifre (chiamiamola "wsd") come segue: + + wsd(1776) = 1 * 1 + 7 * 2 + 7 * 3 + 6 * 4 = 60 + +**Dati di Input** fornirà il numero di test nella prima riga. +I valori veri si trovano nella seconda riga. Per ciascuno di questi valori si deve calcolare la somma ponderata delle cifre. +**Risposta:** come di consueto, Inserire i risultati su una riga, separandoli con spazi. + +Example: + + dati input: + 3 + 9 15 1776 + + risposta: + 9 11 60 + diff --git a/it/task-15.md b/it/task-15.md new file mode 100644 index 0000000..1ff7834 --- /dev/null +++ b/it/task-15.md @@ -0,0 +1,26 @@ +Questo problema introduce il popolare algoritmo della "ricerca lineare" che dovrebbe essere appreso a fondo e come spesso accade +utilizzato nella programmazione di compiti più complessi (ordinamento ecc.). + +Operazione molto comune su sequenza di valori, o array è quello di trovare il valore minimo o massimo. Per farlo ho bisogno di +memorizzare **massimo corrente** (o minimo) in una variable, e quindi scorrere attraverso l'array, confrontando ciascun valore +con questa variabile. Ogni volta che il valore successivo è superiore a quello della variabile temporanea questo valore +dovrebbe essere copiato in essa (come nuovo massimo). + +Alla fine del passaggio questa variabile temporanea manterrà il valore estremo (min o max. + +**Dati Input** ti daranno esattamente `300` numeri in una singola riga. +**Risposta** dovrebbe contenere il massimo e il minimo di questi valori, separati da spazio. + +Importante: a questo problema alcuni chiedono **"Come devo copiare tanti numeri nel mio codice, come creo +un array / elenco dei numeri..."** +Ti prego, non fare così! Invece [**Guarda il mio video demo**](https://www.youtube.com/watch?v=c6WWZe12ves) +(dal minuto 4:00) puoi vedere come usiamo lo +standard input per leggere i numeri quando si esegue on-site! + +**Esempio:** + + dati di input: + 1 3 5 7 9 11 ... 295 297 299 300 298 296 ... 12 10 8 6 4 2 + + risposta: + 300 1 diff --git a/it/task-17.md b/it/task-17.md new file mode 100644 index 0000000..f59fd19 --- /dev/null +++ b/it/task-17.md @@ -0,0 +1,38 @@ +I checksum sono piccoli valori calcolati da una grande quantità di dati, per verificare se i dati sono coerenti +ovvero se contengono errori. + +Ad esempio, se Anna invia un file a Bob, può calcolarne il checksum e comunicarlo a Bob, che +calcolerà il checksum del file ricevuto, e lo confronterà con il valore comunicato da Anna. + +_Altro esempio comune - qualsiasi carta di credito che utilizzi ha un checksun nell'ultima cifra del suo numero quindi qualsiasi +dispositivo potrebbe impedirti di inserire un numero errato per errore (puoi approfondire l'argomento nell'esercizio +[Luhn Algorithm](./luhn-algorithm))._ + +Per programmare diverse altre attività, utilizzaremo un metodo simile per verificare se l'array è corretto o no. Per +evitare problemi con tali attività, ora esercitiamoci con l'algoritmo di calcolo del checksum che verrà utilizzato. + +###Enunciato del problema + +Vi verrà fornito l'array per il quale calcolare il checksum. Eseguite il calcolo come segue: +per ogni elemento dell'array (partendo dall'inizio) aggiungete questo elemento alla variabile `result` e moltiplicate questa somma +per `113` - questo nuovo valore calcolato con modulo `10000007` dovrebbe diventare il nuovo valore di `result`, e così via. + +Leggi l' [articolo sul checksum](../wiki/checksum) per un adescrizione dettagliata di questo algoritmo. +Li puoi trovare anche un'esempio di calcolo. + +**Dati Input** indicheranno la lunghezza di un array nella prima riga. +I valori dell'array seguono nella seconda riga, separati da spazi. +**Risposta** dovrebbe avere un'singolo valore: il checksum calcolato. + +Esempio: + + dati input: + 6 + 3 1 4 1 5 9 + + risposta: + 8921379 + +_Tutti i valori di input sono compresi tra `0` e `1,000,000,000` - assicurarsi di prestare attenzione ai possibili overflow + +durante i calcoli!_ diff --git a/it/task-2.md b/it/task-2.md new file mode 100644 index 0000000..da5bb7c --- /dev/null +++ b/it/task-2.md @@ -0,0 +1,30 @@ +
+demo of summing an array +
+ +Ora il nostro obiettivo è imparare i **loop** - ovvero le azioni ripetute. +Cerchiamo di calcolare la somma di più numeri (più di due). Sarà utile farlo in un loop. +Come mostrato nell'immagine sopra,puoi creare la variable `sum` e aggiungerci tutti i valori dell'elenco. +Forse il ["for" loop](http://en.wikipedia.org/wiki/For_loop) andrà bene, dato che il numero di valori è noto a priori. + +In caso di problemi, prova prima [Sums In Loop](./sums-in-loop)- probabilmente è più semplice. + +**I dati di input** hanno il seguente formato: + +- la prima linea contiene `N` - quantità di valori da sommare; +- la seconda linea contiene `N` valori veri e propri. + +**La risposta** dovrebbe contenere un singolo valore: la somma di `N` valori. + +Esempio: + + input data: + 8 + 10 20 30 40 5 6 7 8 + + risposta: + 126 + +**Nota** poichè sono presenti diverse decine di numeri, non dovresti copiarli manualmente nel tuo programma. +Fai invece in modo che il tuo programma li legga dallo standard input(dove puoi copiarli tutti insieme). Tieni presente che +se esegui il codice sul nostro server, i dati vengono automaticamente copiati sullo standard input per comodità. diff --git a/it/task-28.md b/it/task-28.md new file mode 100644 index 0000000..2e46003 --- /dev/null +++ b/it/task-28.md @@ -0,0 +1,40 @@ +Applicheremo le nostre competenze di programmazione a qualche problema quasi scientifico, - dato che è +un po'noioso imparare solo cose astratte. + +La semplice misura della costituzione corporea fu proposta a metà del XIX secolo. Dipende solo dall'altezza e +dal peso di una persona - ed è chiamata **Indice di massa corporea** o **BMI**. E' definito come: + + BMI = peso / altezza^2 + +Dove il peso è espresso in `kilogrammi` e l'altezza in `metri`. + +Sono proposti quattro gradi generali: + + Sottopeso (under) - BMI < 18.5 + Normale (normal) - 18.5 <= BMI < 25.0 + Sovrappeso (over) - 25.0 <= BMI < 30.0 + Obesità (obese) - 30.0 <= BMI + +Ad esempio, se ho un peso di `80 kg` e un'altezza di `1.73 m` Posso calcolare: + + BMI = 80 / (1.73)^2 = 26.7 + +ovvero leggermente sovrappeso. + +Non discuteremo se questa gradazione sia appropriata o meno. Dovresti semplicemente calcolare i voti per diverse +persone. + +**Dati Input** contengono il numero delle persone nella prima linea. +Le altre righe conterranno due valori ciascuna - peso in kilogrammi e altezza in metri. +**Risposta** dovrebbe contenere le parole `under`, `normal`, `over`, `obese` per ogni caso di test corrispondente, +separate da spazi. Per esempio: + + dati input: + 3 + 80 1.73 + 55 1.58 + 49 1.91 + + risposta: + over normal under + diff --git a/it/task-3.md b/it/task-3.md new file mode 100644 index 0000000..eaa6c0c --- /dev/null +++ b/it/task-3.md @@ -0,0 +1,27 @@ +
+ summing two arrays +
+
+ +Se hai già imparato a scrivere un programma con ciclo semplice dal problema [Sum in Loop][prevtask], +questo nuovo esercizio sarà solo una semplice modifica. + +[prevtask]: ./sum-in-loop + +Ora ci vengono fornite diverse coppie di valori e vogliamo calcolare la somma per ciascuna coppia.. + +**Dati di Input** conterranno in numero totale delle coppie da elaborare nella prima riga. +Le righe successive conterranno le coppie da sommare, una coppia per riga. +**Risposta** Dovrebbe contenere i risultati separati da spazi. + +Esempio: + + dati: + 3 + 100 8 + 15 245 + 1945 54 + + risposta: + 108 260 1999 + diff --git a/it/task-36.md b/it/task-36.md new file mode 100644 index 0000000..459a4f3 --- /dev/null +++ b/it/task-36.md @@ -0,0 +1,46 @@ + +Se conoscete il vecchio gioco [Bulls and Cows](./bulls-and-cows), questo problema di programmazione vi sembrerà familiare. + +Andrew e Peter giocano a indovinare il codice. Andrew sceglie un `numero segreto` composto da `3` cifre. Peter cerca di +indovinarlo, proponendo diversi valori, uno alla volta. + +Per ogni `ipotesi` Andrew deve dire quante cifre sono corrette, ovvero **sono le stesse** nel valore proposto e nel suo +numero segreto, e sono posizionate nella **stessa posizione**. Ad esempio, se il numero segreto è `125` e Peter dice `523`, allora +Andrew risponde con `1`. Ecco un esempio del gioco: + + Andrea sceglie un numero segreto: 846 + + Ipotesi diPeter Risposta diAndrew + 402 0 + 390 0 + 816 2 + 848 2 + 777 0 + 815 1 + 846 3 + +Quindi Peter ha indovinato il numero corretto dopo `6` tentativi. + +Devi scrivere un programma che legga le ipotesi fornite da Peter (tranne l'ultima) e stampi il numero segreto +scelto da Andrew. È garantito che esista esattamente una soluzione. + +I **dati di input** conterranno il numero di ipotesi nella prima riga. +Seguiranno poi le risposte con i relativi tentativi, ciascuna contenente il numero fornito da Peter e la risposta data da Andrew. +A differenza degli esempi, i numeri saranno composti da `4` cifre. +La **risposta** dovrebbe contenere il numero segreto (anch'esso di `4` cifre). Vedi esempio: + + dat input: + 6 + 402 0 + 390 0 + 816 2 + 848 2 + 777 0 + 815 1 + + risposta: + 846 + + +*Qui utilizziamo valori a 3 cifre per brevità, ma l'algoritmo è lo stesso.* + diff --git a/it/task-39.md b/it/task-39.md new file mode 100644 index 0000000..0407dcb --- /dev/null +++ b/it/task-39.md @@ -0,0 +1,42 @@ + +Il prolifico trader Paul Penniless vuole diventare milionario. Cerca di acquistare o vendere azioni e trarre profitto dalle +variazioni dei prezzi. Ad esempio, se è fortunato ad acquistare `200` azioni a `20` dounds l'una e a rivenderle in una settimana a `23`, +guadagna `600` dounds in pochi giorni. + +Paul ha letto un'articolo sulla [Standard Deviation](../wiki/standard-deviation) e ora ha una nuova idea. Ha subito capito +che il problema principale è che il broker (la società che fornisce servizi per giocare al mercato) prende una commissione dell' +1% per ogni operazione. Quindi, nell'esempio precedente, Paul perde 40` dounds quando acquista azioni e altri 46` quando le rivende. +Quindi il profitto reale non è 600`, ma solo 600 - 40 - 46 = 514` dounds. + +Ora è ovvio per lui che dovrebbe preferire operazioni con azioni più **volatili**, ovvero il cui prezzo +cambia in un intervallo più ampio, in modo che il suo profitto derivante dalle variazioni di prezzo sia più significativo +ispetto alla commissione del broker. + +Ad esempio, se il prezzo iniziale delle azioni fosse stato di `50` (anziché `20`) e fosse salito a `52` quando Paul le ha vendute, il suo +profitto per `200` azioni sarebbe stato di soli `400` dound. Tuttavia, la commissione sarebbe stata di `100` dound all'acquisto e di `104` +dound alla vendita, quindi il suo guadagno reale sarebbe stato di soli `196` dound: più della metà del denaro è stata incassata dal broker! + +Paul ha deciso che avrebbe scelto se negoziare o meno azioni di un certo tipo in base alla seguente regola: +la deviazione standard dei prezzi di queste azioni nelle ultime due settimane dovrebbe essere almeno **quattro volte maggiore** della +commissione del broker (che è `1%`), ovvero per un'azione con prezzo medio `50` la commissione è `0,5` e la deviazione standard +dovrebbe essere uguale o maggiore di `2`. + +Ad esempio, se il prezzo era `99` dound per `7` giorni e `101` per gli altri `7` giorni, il prezzo medio è `100`, +e la commissione di intermediazione (per azione) è `1` dound. Anche la deviazione standard sarebbe `1` dound, quindi queste azioni non +meritano di essere acquistate o vendute. + +**I dati di input** conterranno il numero di azioni (tipi o nomi di azioni) per cui devono essere eseguiti i calcoli. +Le righe successive contengono le descrizioni delle azioni - il nome dell'azione (quattro lettere latine) e poi i valori `14` - i prezzi per +ogni giorno nelle ultime due settimane. +**La risposta** dovrebbe contenere i nomi delle azioni che sono sufficientemente volatili secondo i criteri di Paul (nello stesso ordine in cui +sono state fornite nell'input). + +Esempio: + + dati input: + 2 + JOOG 99 99 99 99 99 99 99 101 101 101 101 101 101 101 + GOLD 95 105 95 105 95 105 95 105 95 105 95 105 95 105 + + risposta: + GOLD diff --git a/it/task-4.md b/it/task-4.md new file mode 100644 index 0000000..8811e6c --- /dev/null +++ b/it/task-4.md @@ -0,0 +1,34 @@ +
+ Choosing minimum animation +
+ +La maggior parte dei programmi dovrebbe essere in grado di prendere decisioni. Ora ci eserciteremo con la +programmazione condizionale. +Questo di solito avviene tramite le istruzioni `if ... else` che possono apparire così: + + IF una_condizione THEN + fai_qualcosa + ELSE + fai_altra_cosa + ENDIF + +A seconda del linguaggio di programmazione, la sintassi potrebbe essere diversa e la parte `else` e quasi sempre facoltativa. +Per sapere di più, consulta l'articolo di Wikipedia [Conditional statements][cond]. + +[cond]: http://en.wikipedia.org/wiki/Conditional_(computer_programming) + +tra due numeri, selezionere quallo con il valore minimo. Di seguito diverse coppie per un test approfondito + +**Dait Input** conterranno il numero di casi test nella prima riga. +Le righe successive conterranno una coppia di numeri per il confronto. +Per **Risposta** inserisci lo stesso numero di valori minimi separati da uno spazio, ad esempio: + + dati: + 3 + 5 3 + 2 8 + 100 15 + + risposta: + 3 2 15 + diff --git a/it/task-5.md b/it/task-5.md new file mode 100644 index 0000000..2379fe0 --- /dev/null +++ b/it/task-5.md @@ -0,0 +1,20 @@ +Per esercitarci di più con le istruzioni condizionali, scriveremo un programma che utilizza condizioni complesse. +Ovvero un'istruzione `if ... else` potrebbe (e dovrebbe) essere annidata all'interno di altre per risolvere questo problema. + +Verranno fornite diverse terne di numeri. Il vostro compito è selezionare il minimo tra ciascuna. + + +**Dati Input** conterranno nella prima riga il numero di terzine che seguiranno. +Le righe successive conterrano un riga ciascuna. +**Risposta** deve contenere il numero minino della terzina, separato da spazi. + +Esempio: + + data: + 3 + 7 3 5 + 15 20 40 + 300 550 137 + + risposta: + 3 15 137 diff --git a/it/task-54.md b/it/task-54.md new file mode 100644 index 0000000..f01e959 --- /dev/null +++ b/it/task-54.md @@ -0,0 +1,39 @@ + +*Questo compito è ispirato alla discussione nel [Blog sugli algoritmi di Faisal Rahman](http://algoexplode.wordpress.com/) su un compito simile da +[ProjectEuler](http://projecteuler.net/problem=9)* + +Come sappiamo, il [Teorema di Pitagora](./pythagorean-theorem) ci parla della semplice equazione: + + a^2 + b^2 = c^2 + +Esistono realmente terne `a, b, c` di numeri **interi** che soddisfano questa equazione. Questo non è un fatto ovvio, +inoltre non esistono terne di questo tipo per altre potenze eccetto `2` - questo è il famoso +[Teorema di Fermat](http://en.wikipedia.org/wiki/Fermat's_Last_Theorem) che non poté essere risolto per più di `350` +anni. + +Tuttavia, per la potenza di `2` esistono innumerevoli terne di questo tipo. Una di queste, per esempio, `3, 4, 5`. + +Tuttavia, non è sempre facile trovare una terna che soddisfi alcune condizioni specifiche: + +**In questo problema devi scrivere un programma che, dato il valore di `s = a + b + c` +trovi l'unica terna che soddisfa l'equazione.** + +Ad esempio, data la somma di `12`, si adattano solo `3, 4, 5`, per la somma di `30` si adattano solo `5, 12, 13` ecc. + +**I dati di input** conterranno il numero di casi di test nella prima riga. +Le altre righe conterranno un singolo valore ciascuna, la somma per la quale si desidera trovare la tripla. +**La risposta** dovrebbe contenere i valori di `c^2` per ogni tripla trovata (ovviamente è uguale a `a^2 + b^2`), +separati da spazi. + +**Nota:** i valori reali di `s` sarebbero sufficientemente grandi, circa `10e+7`, quindi le soluzioni più semplici potrebbero essere inefficienti. + +Esempio: + + dati input: + 2 + 12 + 30 + + risposta: + 25 169 + diff --git a/it/task-6.md b/it/task-6.md new file mode 100644 index 0000000..55abbdf --- /dev/null +++ b/it/task-6.md @@ -0,0 +1,27 @@ +Quando un programma gestisce numeri che hanno una parte frazionaria, a volte vogliamo **arrotondare** a numeri +interi. Questo ci servirà per programmare alcuni problemi successivi (ad esempio per semplificare delle risposte), quindi +svolgiamo il seguente esercizio dedicato per imparare questo trucco. + +Ci sono diverse coppie di numeri. Per ogni coppia devi dividere il primo per il secondo e restituire +il risultato arrotondato all'intero **più vicino**. + +Nel caso in cui il risultato contenga esattamente `0.5`, il valore deve essere arrotondato "per eccesso" +(ad esempio aggiungendo `0.5` se positivo o sottraendolo se negativo). +Per spiegazioni approfondite, consultare l'articolo di Wikipedia [Arrotondamento - per eccesso](https://en.wikipedia.org/wiki/Rounding#Rounding_half_away_from_zero). +In qualsiasi altro problema, quando si parla di arrotondamento, si suppone che venga utilizzato lo stesso algoritmo +di arrotondamento (a meno che non venga specificato esplicitamente altro). + +**Dati Input** forniranno il numero di casi di test nella prima riga. +Le righe successive conterranno un caso di test (ovvero la coppia di numeri) ciascuna. +**Risposta** dovrebbe contenere i risultati della divisione e dell'arrotondamento per ciascuna coppia separati da spazi. + +Esempio: + + dati input: + 3 + 12 8 + 11 -3 + 400 5 + + risposta: + 2 -4 80 diff --git a/it/task-7.md b/it/task-7.md new file mode 100644 index 0000000..e1ddb1e --- /dev/null +++ b/it/task-7.md @@ -0,0 +1,32 @@ + +Questo esercizio di programmazione è più o meno lo stesso del conteggio delle somme in un ciclo, ma richiede qualche calcolo in più. + +
+ fahrenheit and celsius +
+ +*Nota: il problema [Rounding](./rounding) spiega l'algoritmo di arrotondamento utilizzato in questa attività.* + +Esistono due sistemi di misurazione della temperatura molto diffusi: Celsius e Fahrenheit. Il primo è molto diffuso in Europa, +mentre il secondo è molto utilizzato, ad esempio, negli Stati Uniti. + +Secondo la scala Celsius, l'acqua congela a 0 gradi e bolle a 100 gradi. Secondo la scala Fahrenheit, l'acqua congela +a 32 gradi e bolle a 212 gradi. Puoi trovare maggiori informazioni su [wikipedia on Fahrenheit][wiki]. Usa questi due punti +per la conversione di altre temperature. + +[wiki]: http://en.wikipedia.org/wiki/Fahrenheit + +Devi scrivere un programma per convertire i gradi Fahrenheit in Celsius. + +I **dati di input** contengono `N+1` valori, il primo dei quali è `N` stesso (**Nota**: non dovresti provare a convertirlo). +La ​​**risposta** dovrebbe contenere esattamente `N` risultati, arrotondati all'intero più vicino e separati da spazi. + +Esempio: + + dati input: + 5 495 353 168 -39 22 + risposta: + 257 178 76 -39 -6 + + +*Si prega di notare che il primo `5` non è una temperatura, ma la quantità di valori da convertire!* diff --git a/it/task-8.md b/it/task-8.md new file mode 100644 index 0000000..98bfcee --- /dev/null +++ b/it/task-8.md @@ -0,0 +1,41 @@ +Quando parliamo di **progressione aritmetica** (o sequenza aritmetica) intendiamo una serie +di numeri con una proprietà speciale: ogni valore è seguito dall'altro, maggiore di un valore predefinito +(passo). + +Cioè la differenza tra il valore `(K+1)`-esimo e il valore `K`-esimo è una costante. Ecco alcuni esempi di sequenze + + 1 2 3 4 5 6 7 ... + 4 6 8 10 12 14 16... + 10 13 16 19 22 25 28... + +Pertanto, la sequenza aritmetica è completamente definita dal primo elemento (`A`) e dal valore di incremento +- passo - (`B`). I primi elementi potrebbero essere espressi come + + A + (A + B) + (A + 2B) + (A + 3B) + ... + +Devi calcolare la somma dei primi elementi di una sequenza aritmetica. +[Pagina di Wikipedia][wiki] sulla progressione aritmetica potrebbe essere di grande aiuto per chi +la incontra per la prima volta. + +[wiki]: http://en.wikipedia.org/wiki/Arithmetic_progression + +**Dati di input:** la prima riga contiene il numero di casi di test. +Le altre righe contengono casi di test sotto forma di triplette di valori `A B N` dove `A` è il primo valore della sequenza, +`B` è la dimensione del passo e `N` è il numero di primi valori da considerare. +**Risposta:** si devono ottenere i risultati (somme dei primi `N` elementi) per ogni sequenza, separati da spazi. + + +Esempio: + + dati: + 2 + 5 2 3 + 3 0 10 + + risposta: + 21 30 + +_Spiegazione dell'esempio. Nel primo caso abbiamo una sequenza che inizia con `5` e aumenta di `2` ogni volta. +Vogliamo sommare `3` elementi da essa `5 + 7 + 9 = 21`. Il secondo è più semplice. Inizia con `3` ma l'incremento è `0`, +quindi è `3 + 3 + ... + 3 = 30` (totale di `10` elementi)._ + diff --git a/it/task-9.md b/it/task-9.md new file mode 100644 index 0000000..d63d2b8 --- /dev/null +++ b/it/task-9.md @@ -0,0 +1,26 @@ + +Un triangolo è un oggetto costituito da tre segmenti (lati del triangolo), collegati da estremità. +[Wiki sui triangoli][wiki] fornisce una spiegazione più dettagliata. +Se abbiamo tre segmenti di lunghezza `A B C`, possiamo costruire un triangolo con essi +(ad esempio con `3 4 5` o `3 4 7`, sebbene questo abbia area zero) oppure lo troviamo impossibile +(ad esempio `1 2 4`). + +[wiki]: http://en.wikipedia.org/wiki/Triangle + +Ti vengono fornite diverse terne di valori che rappresentano le lunghezze dei lati dei triangoli. +Dovresti dire da quali terne è possibile costruire un triangolo e da quali no. + +**Dati di input:** La prima riga conterrà il numero di terzine. +Le altre righe conterranno le terzine stesse (ciascuna su una riga separata). +**Risposta:** Dovresti restituire `1` o `0` per ogni terzina (`1` se il triangolo può essere +costruito e `0` altrimenti). + +Esempio: + + dati: + 2 + 3 4 5 + 1 2 4 + + risposte: + 1 0 diff --git a/it/task.478.md b/it/task.478.md new file mode 100644 index 0000000..7932e98 --- /dev/null +++ b/it/task.478.md @@ -0,0 +1,37 @@ +_Questo problema è stato gentilmente creato da [**Clive Fraser**](/index/user_profile/csfpython) - many thanks!_ + +Il robot Alfie lavora in un grande complesso industriale. Il complesso è un quadrato di 5 km di lato. Il compito di Alfie è quello di raccogliere articoli parzialmente o completamente finiti da un punto di raccolta/consegna del complesso e di consegnarli a un altro punto. Il complesso industriale ha diverse corsie che corrono parallele ai lati del quadrato: una da est a ovest e l'altra da nord a sud. Quindi queste corsie si incrociano sempre ad angolo retto. Le corsie corrono sopra l'area di lavoro della fabbrica in modo che Alfie possa muoversi senza interferire con nessuna delle aree di lavoro. I punti di raccolta/consegna sono tutti posizionati all'intersezione dei due insiemi di corsie. Alfie sceglierà sempre la distanza più breve tra due punti, ma è vincolato a seguire le corsie; quindi deve sempre viaggiare parallelamente a uno dei bordi del quadrato. I punti di ritiro/consegna sono distinti dalle loro coordinate (x,y), dove x e y sono rispettivamente le distanze (in metri) a est e a sud di uno degli angoli del quadrato che ha coordinate (0,0). + +Alfie ha la sua stazione di attracco nel punto (0,0). Una volta arrivato alla stazione di attracco, ad Alfie viene inviato un elenco delle consegne da effettuare. Ognuna di queste indica le coordinate del punto di ritiro/consegna in cui deve ritirare un pacco e le coordinate del punto in cui il pacco deve essere consegnato. Per migliorare l'efficienza, ogni consegna viene spedita in una cassa di dimensioni standard. All'interno della cassa possono esserci molti articoli, ma Alfie considera una cassa come un'unica consegna. Se un punto di ritiro/consegna deve inviare più casse alla stessa destinazione, ciascuna di queste deve essere elencata come una consegna separata. Alfie è progettato per poter trasportare due casse (al massimo) contemporaneamente. + +When Alfie gets a list of deliveries he uses a specially designed software package to work out the optimum route for the collection and delivery of all of the crates. The route takes him from his docking station, through all of the collections and deliveries and then back to the docking station. The software ensures that Alfie will never need to be carrying more than 2 crates. The software also ensures that the total distance travelled by Alfie is a minimum. + +Quando Alfie riceve un elenco delle consegne, utilizza un software appositamente progettato per calcolare il percorso ottimale per il ritiro e la consegna di tutte le casse. Il percorso lo porta dalla sua stazione di attracco, attraverso tutti i ritiri e le consegne, per poi tornare alla stazione di attracco. Il software garantisce che Alfie non debba mai trasportare più di 2 casse. Il software garantisce inoltre che la distanza totale percorsa da Alfie sia minima. + +In questo problema ti verrà fornito un elenco delle consegne per Alfie e ti verrà chiesto di calcolare la distanza percorsa da Alfie per effettuare tutte le consegne, partendo dalla stazione di attracco e tornandovi. + +La prima riga del problema sarà un singolo intero N che indica il numero di ritiri e consegne da effettuare. Ciascuna delle successive N righe sarà composta da quattro interi X1, Y1, X2 e Y2, separati da spazi. (X1,Y1) indica la posizione del punto da cui deve essere ritirata una cassa. (X2,Y2) indica la posizione del punto in cui la stessa cassa deve essere consegnata. Il risultato è la lunghezza (in metri) del percorso ottimale seguito da Alfie per completare l'elenco delle consegne e tornare alla stazione di attracco. + +Nell'esempio seguente, N = 3, quindi ci sono 3 casse da ritirare e consegnare. Il percorso ottimale ha una lunghezza di 18206 metri e viene eseguito come descritto nella tabella seguente. (Nota che le casse trasportate si riferiscono al numero di casse trasportate da Alfie, dopo aver raggiunto la posizione indicata) + + Posizione Distanza Totale Colli trasportati + + (0,0) 0 0 Inizia alla stazione di attracco + (737,482) 1219 1 Raccogli la cassa numero 2 + (3855,4069) 7924 2 Raccogli la cassa numero 1 + (4230,4175) 8405 1 Consegna la cassa numero 2 + (4837,3926) 9261 2 Raccogli la cassa numero 3 + (2127,1979) 13918 1 Consegna la cassa numero 3 + (1542,2070) 14594 0 Consegna la cassa numero 1 + (0,0) 18206 0 Ritorna alla stazione di attracco + +Esempio: + + input: + 3 + 3855 4069 1542 2070 + 737 482 4230 4175 + 4837 3926 2127 1979 + + risposta: + 18206