Golf Programming Live!

Quanta vita riuscite ad infondere in un singolo carattere del vostro programma?

Penso che conosciate tutti il gioco Life e quindi non lo descriverò se non per ricordarne le regole. Chi non lo conoscesse ancora potrà rivolgersi all’apposita pagina di wikipedia per approfondirne le potenzialità e la storia.

In pratica il gioco si svolge su una griglia su cui vengono disposte a caso alcune cellule che possono nascere, vivere o morire a seconda
del numero di altre cellule con cui sono in contatto.

Le regole che permettono di evolvere uno stato nel successivo sono semplicissime:

  • Una cella spenta (morta) si accende (vive) se ha esattamente tre celle vicine vive.
  • Una cella viva (accesa) sopravvive (resta accesa) se ha due o tre celle vicine accese.
  • In tutti gli altri casi le cella resta spenta o si spegne.

Continua a leggere “Golf Programming Live!”

Golf programming: Codice Morse

L’altro giorno stavo curiosando tra i polverosi archivi di questo blog e mi sono ritrovato tra le mani un post della serie code-golf annunciato più volte e mai pubblicato. Rimedio adesso cominciando ufficialmente, la nuova serie di prove di golf.

Il codice Morse.

Croce e delizia di generazioni di radioamatori ordinari il codice morse è uno dei pilastri, permettetemi di dirlo, della moderna tecnologia. Noi ci prepariamo a demistificarlo costruendoci attorno il più piccolo programma che permetta di tradurre una stringa ascii in una sequenza di punti e linee pronta per essere trasmessa dal primo telegrafo su cui metterete le mani.

Un messaggio trasmesso utilizzando il codice morse usa un protocollo di comunicazione basato sul tempo. Una linea deve durare esattamente il triplo di un punto, il tempo da lasciar passare tra una lettera e l’altra corrisponde ad una linea, mentre ra i diversi simboli che compongono una lettere deve passare il tempo necessario a trasmettere un punto. Due parole sono separate tra loro da cinque punti di assenza di segnale. Non sto ad annoiarvi con questi ed altri dettagli, chi lo volesse può cominciare a leggere la pagina dedicata al codice morse su wikipedia, perché io stesso mi sono annoiato un po’ a leggerli. Cercherò semplicemente di trasporle in qualcosa che renda questa particolarità adatta a questo contest.
Continua a leggere “Golf programming: Codice Morse”

Golf Programming: Code Golf Ruler

Gennaio è passato, cerchiamo di recuperare il tempo perso e partiamo quanto prima con la prova di Golf Programming di Febbraio.

Vi siete stancati di stare a contare i caratteri che compongono la vostra soluzione di code golf? Il contest di questo mese vi darà una mano.

Si tratta di stampare, al solito sprecando meno caratteri possibile, un righello in modo da poterlo usare per misurare ad occhio le nostre creazioni.

Un esempio lo trovate qui sotto, il resto delle specifiche dopo il solito richiamo alle regole.

+-------------------------------------------------------------------------+
| |    |    |    |    |    |    |    |    |    |    |    |    |    |    | |
| 0        10        20        30        40        50        60        70 |
|                                                                         |
+-------------------------------------------------------------------------+

Continua a leggere “Golf Programming: Code Golf Ruler”

Golf programming: Sono Pazzi Questi Romani

E’ passato un mese dall’ultimo contest di golf programming. E’ arrivato il momendo di ricominciare a consumare, il meno possibile, le nostre tastiere per risolvere quello del mese di novembre.

Le Regole

Si tratta delle solite regole, in ossequio al contesto le ho riportare con il copia e incolla 🙂 :

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

Il programma da scrivere questa volta riguarda i numeri romani. Quelli che compaiono nelle prefazioni dei libri, per intenderci. O in qualche versione di latino o su centinaia di monumenti.

Questa volta bisogna scrivere un programma che conti, uno per riga, fino a 3999. Partiremo da 1 per arrivare fino a 3999 perché non è possibile, con i caratteri ascii, usare i caratteri romani per esprimere numeri più grandi di 4000. Non mi resta che lasciarvi al vostro compito con un link ad un file di riferimento con tutti la sequenza di numeri da replicare ed aspettare le vostre soluzioni.

La mia, al solito, tra circa una settimana tra i commenti.

Golf Programming: Paroliamo

L’ultima prova della serie anagrammi si è rivelata particolarmente semplice. Complichiamola appena un pò modificando l’algoritmo in modo da costringerci a modificare l’approccio al problema.

Le Regole

Le regole del contest:

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

Anche la funzione di questo mese, come quella del mese scorso,  prende in input due stringhe ma restituisce/stampa vero se con le lettere che compongono il primo parametro è possibile comporre il secondo. A differenza del programma sugli anagrammi, non è necessario utilizzare tutte le lettere della prima parola per comporre la seconda.

Ad esempio, con la parola MANAGER è possibile (e quindi la funzione deve restituire vero) comporre, tra le altre, le parole RANA, RAME, GARA o GRANE.

L’ordine dei parametri è importante. Con la parola MANAGER non è possibile costruire GERMANIA, mentre è vero il contrario.

La parola OSTE, poi, non può essere usata per comporre TESTO, le lettere ci sono tutte ma manca una T. Di conseguenza la funzione dovrebbe restituire falso.

Al solito posterò la mia soluzione come commento alla fine della settimana entrante, per dare il tempo a chi vuole partecipare di scatenare la propria fantasia.

Golf Programming: Anagrammi

Rientriamo dopo le ferie con un’altra sfida classica, giusto per toglierci di dosso eventuale ruggine. Al solito riporto le regole per chi cominciasse adesso a seguire questa pseudo rubrica.

Le Regole

Ormai le regole dovrebbero essere familiari, le riporto per scrupolo:

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

La funzione di questo mese prende in input due stringhe e stampa vero se una delle due è anagramma dell’altra o falso in caso contrario (ovviamente sono consentite anche, per i linguaggi che lo permettono, 0 ed 1 o 0 e ~0).

Al solito posterò la mia soluzione come commento alla fine della settimana entrante, per dare il tempo a chi vuole partecipare di scatenare la propria fantasia.

Golf Programming: Copertura di un segmento

Il pingback di Sandro al post del precedente Golf contest mi ha fatto raggiungere un sito che mi ha dato lo spunto per la prova di Luglio. Ok, uno spunto forse è pretendere troppo, diciamo che l’ho tradotto spudoratamente e adattato al contest togliendo la sommatoria finale.

Ancora una volta si tratta di un classico, dovrete scruvere la versione concisa di un algoritmo per il calcolo della copertura di un segmento.

Le Regole

Ormai le regole dovrebbero essere familiari, le riporto per scrupolo:

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

Il problema di questo mese consiste nel calcolare la mappa di copertura di un segmento. In parole povere:

Un segmento è diviso in spezzoni (da 1, non 0, ad n) ed in input arrivano degli intervalli di copertura, gli estremi delle macchie che coprono il segmento.
Le macchie in input possono sovrapporsi, essere completamente contenute in altre macchie e, ovviamente, contenerne altre.
Il pezzo di programma da scrivere deve prendere in input questa sequenza di intervalli e restituire la sequenza di copertura minima,in altre parole deve
ottenere lo stesso risultato della sequenza in input con il minor numero di macchie possibile (fondendo tra di loro quelle che si intersecano o sovrappongono).

Il compito non è troppo difficile e, con un po’ di attenzione si dovrebbe arrivare contemporaneamente al codice più stringato possibile ed all’algoritmo ottimo (o almeno molto vicini a quest’ultimo).

Il formato dell’input

Sul post originale al quale ho attinto l’imput è composto da due array, uno con la coordinata dell’inizio della macchia e, l’altro, nella cella corrispondente,  con la coordinata finale della macchia. Ovviamente, trattandosi di un segmento, per coordinata si intende un singolo numero. Per il php, il linguaggio che ho scelto per partecipare ai contest questo formato è preferibile ma se qualcuno ha intenzione di modificarlo per adattarlo meglio al linguaggio che sceglierà può tranquillamante farlo (siamo qui per divertirci, dopo tutto). L’elenco dei segmenti, qualunque esso sia, non è ordinato secondo nessun criterio vi possa venire in mente.

Un formato alternativo potrebbe essere un solo array di coppie di coordinate, inizio fine.

Cercherò di spiegarmi meglio con un esempio, anche questo preso dal post in questione.

[17,85,57], [33,86,84] che diventa  [17, 57], [33 86]

un’alternativa potrebbe essere

[[17,33], [85,86], [57,84]] che a sua volta diventa [[17,33], [57,86]]

Il formato dell’output

Una volta scelto il formato in input il formato in output dovrà corrispondere il più possibile a quello dei dati di ingresso. Scrivo il più possibile perché quasi mai è possibile restituire in output entità multiple senza almeno incapsularle in una struttura che le contenga. Non è possibile creare side-effect, modificare i parametri in input come risultato della computazione.

Vi lascio alla soluzione del quesito con un paio di esempi di input:

[ 15, 30, 40, 6, 15, 11, 23, 26, 39 ]
[ 21, 37, 42, 8, 15, 17, 25, 32, 43 ]

o, in alternativa, [[15,21], [30,37], [40,42], [6,8], [15,15], [11,17], [23,25], [26,32], [39,43]]

[45, 100, 125, 10, 15, 35, 30, 9]
[46, 200, 175, 20, 25, 45, 40, 10]

alias [[45,46], [100,200], [125,175], [10,20], [15,25], [35,45], [30,40], [9,10]]

Il resto sta a voi. Scrivete il meno possibile 😉

Golf Programming: permutazioni

Proseguiamo con il golf programming con un nuovo problema da risolvere.
Anche questa volta si tratta di un classico (anche se programmarlo secondo le regole del golf me lo ha fatto vedere sotto una nuova luce).

Le Regole

Per che non le ricordasse, e per chi comincia da questa puntata a seguire la rubrica, riporto le regole:

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

L’algoritmo da implementare deve, data una stringa, calcolare tutte le sue possibili permutazioni.
Al solito, un esempio servirà a chiarire tutto meglio di una descrizione formale:

data in input la stringa abc, il programma deve stampare, le stringhe abc, acb, bac, bca, cab e cba.

Ovviamente l’ordine delle stringhe restituite non è importante mentre lo è non riportare ripetizioni: la stringa aba, ad esempio, deve dare come risultato solamente aba, aab e baa.

A parte i soliti rubysti che avranno sicuramente un costrutto nel linguaggio tipo .permuta secondo me si tratta di una sfida stimolante, specie per chi volesse risolverla in ricorsione. Come le altre volte, posterò la mia soluzione nel prossimo fine settimana. Buona sfida.

Golf programming: veni vidi dixi

Se le mie reminiscenze di latino non mi ingannano veni, vidi, dixi dovrebbe essere la parafrasi del ben più famoso detto di Giulio Cesare.

Proseguiamo con il golf programming con un nuovo problema da risolvere. Le regole sono uguali a quelle dell’altra volta:

  1. Scrivere un programma, il più breve possibile, che risolva il problema enunciato prima e riportato meglio qui sotto;
  2. per ogni linguaggio utilizzato è considerato vincitore il programma scritto usando meno di caratteri;
  3. l’efficienza dell’algoritmo non è un fattore fondamentale ma il programma deve terminare senza errori;
  4. si può optare, se più concisa, per una funzione, piuttosto che un programma intero;
  5. ovviamente non di vince niente se non la soddisfazione di aver accettato una sfida ed averla vinta.

L’algoritmo

L’algoritmo da implementare deve, dato un numero, calcolare il successivo termine della sequenza look and say, una particolare successione matematica costruita descrivendo i diversi termini. Un esempio servirà a chiarire tutto meglio di una descrizione formale; scriviamo i primi cinque membri della successione che comincia con 1:

1, 11, 21, 1211, 111221, …

il primo termine è il seme della sequenza ed è scelto senza nessun vincolo. Il secondo termine descrive il primo, in questo caso abbiamo un numero uno e quindi otteniamo 11. Il terzo termine descrive (si tratta di due cifre 1) il secondo ottenendo 21, il quarto 1211 “legge” il terzo che contiene un due ed un uno e, seguitando, il quinto termine, è 111221. Il sesto, ovviamente, corrisponde a 312211.

Partenza

La sfida consiste nello scrivere una funzione che preso in input un termine qualunque della sequenza, ne restituisca il successivo.

Come al solito aspetterò fino alla fine della settimana per postare la mia versione. Chi volesse cimentarsi non ha altro da fare che postare la propria soluzione tra i commenti.

Eineki