Stamattina mi è venuto in mente un enigma interessante guardando i pulsanti dell'ascensore.

È necessario generare un elenco di tutti i modelli Braille che si adattano a una griglia 2x3. Usa un hash #per indicare una protuberanza e un trattino -per indicare un'area piatta.

Esempio di output previsto:

#-
--
--

##
--
--

#-
#-
--

(and so on...)

Regole:

• Il programma deve separare ogni modello di almeno un carattere o una riga.
• I modelli possono essere generati in qualsiasi ordine.
• Tutti i modelli, indipendentemente da ciò che l'alfabeto Braille effettivamente utilizza, dovrebbero essere prodotti. Il modello completamente vuoto è facoltativo.
• Dovrebbero essere generati solo schemi di protuberanze unici. I seguenti schemi sono considerati equivalenti in quanto i dossi sono in una disposizione identica. In questi casi, utilizzare il modello più vicino all'angolo in alto a sinistra (ovvero la prima opzione in questo esempio.)

#-  -#  --  --
#-  -#  #-  -#
--  --  #-  -#

Punti bonus se puoi farlo funzionare per qualsiasi griglia di dimensioni x per y . ( EDIT: entro limiti ragionevoli. Fino a 4x4 è sufficiente per la prova del concetto.)

Leggendo l'articolo wiki, sembra che ci siano 45 modelli (incluso lo spazio vuoto) che soddisfano le regole di questo puzzle.

GolfScript, 34 32 caratteri

44,{84+2base(;{'-#'=}/@\n.}%2/n*

Scopre che ci sono soluzioni più brevi rispetto semplicemente generando tutti 64 modelli e filtrando i cattivi. In effetti, mappando opportunamente i bit alle posizioni della griglia, è possibile mappare tutti i modelli validi (non vuoti) su un intervallo consecutivo di numeri, come fa questo programma.

In particolare, la mappatura che utilizzo è:

5 4
3 1
2 0

dove i numeri indicano la posizione del bit (a partire dal bit meno significativo 0) mappato a quella posizione nella griglia. Con questa mappatura, le griglie valide corrispondono ai numeri da 20 a 63 inclusi.

Questo è quasi lo stesso dell'ovvia mappatura ottenuta scrivendo il numero a 6 bit in binario e aggiungendo interruzioni di riga tra ogni secondo bit, tranne per il fatto che i bit 1e 2vengono scambiati - e in effetti è esattamente così che il mio programma lo calcola. (Aggiungo anche 64 ai numeri prima di convertirli in binari, quindi rimuovo il bit extra alto; questo è solo per azzerare i numeri a 6 bit, poiché basealtrimenti GolfScript non restituirebbe alcun zero iniziale.)

Ps. Demo online qui. (Il server sembra sovraccarico di recente; se si ottiene un timeout, riprovare o scaricare l'interprete e testarlo localmente.)

Modifica: gestito per salvare due caratteri evitando la creazione e il dumping di array non necessari. Accidenti!

Mathematica 97

Grid /@ Cases[(#~Partition~2 & /@ Tuples[{"#", "-"}, 6]), x_ /; 
         x[[All, 1]] != {"-", "-", "-"} && x[[1]] != {"-", "-"}]

Il bianco non è incluso:

Length[%]

44

NB! = È un singolo personaggio in Mathematica.

C # - 205

class C{static void Main(){var s="---##-##";Action<int,int>W=(i,m)=>{Console.WriteLine(s.Substring((i>>m&3)*2,2));};for(int i=0;i<64;++i){if((i&3)>0&&(i&42)>0){W(i,0);W(i,2);W(i,4);Console.WriteLine();}}}}

Versione leggibile:

class C
{
    static void Main()
    {
        var s = "---##-##"; // all two-bit combinations
        // a function to write one two-bit pattern (one line of a Braille character)
        Action<int,int> W = (i,m) => { Console.WriteLine(s.Substring(((i >> m) & 3) * 2, 2)); };
        // for all possible 6-bit combinations (all possible Braille characters)
        for(int i = 0; i < 64; ++i)
        {
            // filter out forbidden (non-unique) characters
            if ((i & 3) > 0 && (i & 42) > 0)
            {
                // write three rows of the Braille character and an empty line
                W(i,0);
                W(i,2);
                W(i,4);
                Console.WriteLine();
            }
        }
    }
}

Perl, 71 67 65 char

y/10/#-/,s/../$&
/g,/^#/m&&print
for map{sprintf"%06b
",$_}18..63

Converti int in binario, esegui la traslitterazione e aggiungi una nuova riga ogni due caratteri. Il /^#/mtest elimina due pattern (20 e 21) che non hanno un rilievo sollevato nella colonna più a sinistra.

Soluzione generale, 150 106 103 100 char

Leggi xe ydagli arg della riga di comando. Le newline sono significative

y/01/-#/,s/.{$x}/$&
/g,/^#/m*/^.*#/&&print
for map{sprintf"%0*b
",$x*$y,$_-1}1..1<<($y=pop)*($x=pop)

Scorrere oltre 0..2 ^xy come prima, convertendo ogni int in binario, sostituendo -e #per 0e 1, e inserendo una nuova riga dopo ogni $xcarattere.

/^#/mverifica che sia presente un rilievo sollevato nella colonna più a sinistra e /^.*#/verifica che sia presente un rilievo sollevato nella riga superiore. Vengono stampati solo i motivi che superano entrambi i test.

Pitone, 120 118 113 95 118

for j in range(256):
    if j/4&48and j/4&42:print''.join('_#'[int(c)]for c in bin(j/4)[2:].rjust(6,'0'))[j%4*2:j%4*2+2]

Modifica: usato il suggerimento di Winston Ewert e aggiunta la soluzione di griglia x by y

Modifica: in qualche modo ho perso l'ultimo vincolo sull'unicità. Questo script genera tutte le sequenze possibili, non solo il 45.

Modifica: backup su 118 ma ora corretto

J, 35 33 caratteri

3 2$"1'-#'{~(2 A.i.6){"1#:20+i.44

Utilizza l'approccio che Ilmari Karonen ha trovato nella loro soluzione Golfscript. Tuttavia, dal momento che il verbo J #:(antibase) memorizza i bit (o, beh, le cifre nel caso generico) in un elenco, dobbiamo indicizzarlo da sinistra anziché da destra (ovvero l'indice 0 è il bit più a sinistra, il più alto).

La soluzione è piuttosto semplice: 20+i.44fornisce un elenco di numeri 20..63, compreso. #:prende l'anti-base 2 di ciascun elemento in questo elenco e quindi produce un elenco di bitpattern per ciascun numero in quell'intervallo. {seleziona (sostanzialmente riordina) i bit nel modello giusto, quindi {viene nuovamente utilizzato per utilizzare le cifre come indici nella stringa '- #' per preparare l'output. Infine, disponiamo ogni voce in un rettangolo 2 per 3 con $(forma).

3 2$"1'-#'{~(2 A.i.6){"1#:20+i.44      N.B. use A. (anagram) to generate the right permutation

3 2$"1'-#'{~0 1 2 4 3 5{"1#:20+i.44

Python - 121 112

lo spazio in bianco non è incluso

from itertools import*
print'\n'.join('%s%s\n'*3%b for(b,n)in zip(product(*['_#']*6),range(64))if n&48and n&42)