Scrivi un programma che traduce il testo ASCII in output braille . Requisiti:

• L'input può provenire da stdin, dalla riga di comando o da qualche altra sorgente di input esterna.
• L'output dovrebbe essere riconoscibile come braille, la forma dell'output dipende da te. Un esempio potrebbe essere oper un punto sollevato e .per un punto non sollevato. La rappresentazione testuale del modello come 1-3-4non è accettabile. Non è necessario il confezionamento a linea lunga.
• Per una soluzione minima sono necessari solo i 26 caratteri alfabetici e lo spazio. Tutti i caratteri di input non supportati dalla soluzione devono essere ignorati.

Il punteggio è per numero di caratteri nel codice sorgente. Sanzioni e bonus sono:

• +50 di penalità per l'utilizzo di caratteri Braille Unicode come output.
• -50 bonus per capitelli, numeri e punteggiatura di supporto.
• -200 bonus per legature di supporto e contrazioni di una lettera dal Braille inglese (grado 2) . (Renderà questa una sfida separata poiché è un problema abbastanza diverso.)

Richiamo e output del campione (soluzione minima):

$ braille Hello world
o .  o .  o .  o .  o .  . .  . o  o .  o .  o .  o o
o o  . o  o .  o .  . o  . .  o o  . o  o o  o .  . o
. .  . .  o .  o .  o .  . .  . o  o .  o .  o .  . .

Python, 162

l=map((" a c,bif/e d:hjg'k m;lsp o n!rtq%12s. w -u x v   z y"%'').find,raw_input().lower())
for i in 1,4,16:print'  '.join('.o.o    ..oo'[(n&i*3)/i::4]for n in l)

Attualmente supporta lettere minuscole e punteggiatura, ma è ancora in fase di elaborazione.

Esempio:

$ python braille.py
Hello, world!
o .  o .  o .  o .  o .  . .  . .  . o  o .  o .  o .  o o  . .
o o  . o  o .  o .  . o  o .  . .  o o  . o  o o  o .  . o  o o
. .  . .  o .  o .  o .  . .  . .  . o  o .  o .  o .  . .  o .

Python - 90 75 + 50 = 125

Usa lettere minuscole.

for l in input():
 a=ord(l)-96
 if a<0:a=0
 print("⠀⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚⠅⠇⠍⠝⠕⠏⠟⠗⠎⠞⠥⠧⠺⠭⠽⠵"[a],end="")

One-liner (grazie a ɐɔıʇǝɥʇuʎs)

for l in input():print("⠀⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚⠅⠇⠍⠝⠕⠏⠟⠗⠎⠞⠥⠧⠺⠭⠽⠵"[max(0,ord(l)-96)],end="")

C, 269

#define C char
#define O*p++=(*t&1)*65+46;*t>>=1;
main(int c,C**v){C b[99]={1,5,3,11,9,7,15,13,6,14},o[99],*q=o,*p=v[1],*t;while(c=*p++)*q++=c=='w'?46:c>='a'&&c<='z'?c-='a'+(c>'w'),b[c%10]|(c>9)*16|(c>19)*32:0;for(c=3;c;c--){p=b;for(t=o;t<q;t++){O;O*p++=32;}puts(b);}}

Questa implementazione richiede che il suo argomento, se contiene spazi, deve essere citato:

# braille "hello world"

BBC Basic 103 caratteri ASCII o 92 token

A$="HXIKJY[ZQShxikjy{zqsl|Wmon"FORK=1TO26A=ASC(MID$(A$,K))VDU23,K+96,A AND9;0,A/2AND9;0,A/4AND9;:NEXT

Forse non esattamente quello che intendeva l'OP, questo ridefinisce il carattere per i caratteri minuscoli. VDU 23,n,a,b,c,d,e,f,g,hassegna una bitmap 8x8 al carattere n, composto da otto byte. Seguire un parametro con un punto e virgola anziché una virgola fa sì che venga trattato come un numero little-endian a due byte.

I modelli braille per le lettere aattraverso zsono memorizzati in A $, secondo il seguente modello di bit. Questo viene estratto da maschere con 9 = binario 1001e diritti (la divisione per 2 e 4 viene utilizzata come standard BBC di base non ha un operatore a turni).

 8 1
16 2
32 4

Codice Ungolfed

A$="HXIKJY[ZQShxikjy{zqsl|Wmon"
FORK=1TO26
  A=ASC(MID$(A$,K))
  VDU23,K+96,A AND9;0,A/2AND9;0,A/4AND9;
NEXT

Esempio di utilizzo

Questo viene fatto in modalità schermo 6 per chiarezza (digitare MODE6 non appena si apre l'emulatore della riga di comando.)

In realtà, dopo aver eseguito il codice, tutte le lettere minuscole (incluso l'inserimento da tastiera) vengono visualizzate in Braille.

Emulatore su http://bbcbasic.co.uk/bbcwin/bbcwin.html .

Vedi anche questa mia risposta simile: /codegolf//a/28869/15599

Bash + coreutils

Soluzione minima - solo lettere minuscole, 83 (33 caratteri unicode + 50 penalità):

tr a-z ⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚⠅⠇⠍⠝⠕⠏⠟⠗⠎⠞⠥⠧⠭⠽⠵⠺

Capitali, numeri e punteggiatura, 120 (120 caratteri unicode + 50 penalità - 50 bonus):

a=⠁⠃⠉⠙⠑⠋⠛⠓⠊⠚⠅⠇⠍⠝⠕⠏⠟⠗⠎⠞⠥⠧⠭⠽⠵⠺
sed 's/\([0-9]\)/⠼&/g;s/\([A-Z]\)/⠠&/g'|tr ",;':\-⎖.!“?”()/a-zA-Z1-90" ⠂⠆⠄⠒⠤⠨⠲⠖⠦⠦⠴⠶⠶⠌$a$a$a

Esempio di output:

$ echo {A..Z} {a..z} {0..9} ".,;:" | ./braille.sh 
⠠⠁ ⠠⠃ ⠠⠉ ⠠⠙ ⠠⠑ ⠠⠋ ⠠⠛ ⠠⠓ ⠠⠊ ⠠⠚ ⠠⠅ ⠠⠇ ⠠⠍ ⠠⠝ ⠠⠕ ⠠⠏ ⠠⠟ ⠠⠗ ⠠⠎ ⠠⠞ ⠠⠥ ⠠⠧ ⠠⠭ ⠠⠽ ⠠⠵ ⠠⠺ ⠁ ⠃ ⠉ ⠙ ⠑ ⠋ ⠛ ⠓ ⠊ ⠚ ⠅ ⠇ ⠍ ⠝ ⠕ ⠏ ⠟ ⠗ ⠎ ⠞ ⠥ ⠧ ⠭ ⠽ ⠵ ⠺ ⠼⠚ ⠼⠁ ⠼⠃ ⠼⠉ ⠼⠙ ⠼⠑ ⠼⠋ ⠼⠛ ⠼⠓ ⠼⠊ ⠲⠂⠆⠒
$ 

PHP, 331

<?php $d=split("/",gzinflate(base64_decode("NYzBDQBACIM26o3G/r+LRf2QYAOZe4SCLKgU7A9lEWVOzrQVrAiwghWhLKLMyZlawTTGMIYxPg==")));$d[-65]="......";$i=str_split(preg_replace("/[^a-z ]/","",trim(fgets(STDIN))));$o=["","",""];$S="substr";foreach($i as $c){$v=ord($c)-97;for($x=0;$x<3;$x++)$o[$x].=$S($d[$v],$x*2,2)." ";}echo join($o,"\n");

Nessun bonus per ora.

JavaScript - 286

w=prompt().split('');for(i=0;i<w.length;i++){z=w[i];o="o",p=".";b=[1,5,3,11,9,7,15,13,6,14];e=[c="",1,3];g=z.charCodeAt(0)-97;if(g>22)g--;f=e[g/10|0];d=b[g%10];if(g==22){d=14;f=2;}c+=d&1?o:p;c+=d&2?o:p;c+="\n";c+=d&4?o:p;c+=d&8?o:p;c+="\n";c+=f&1?o:p;c+=f&2?"o\n":".\n";console.log(c);}

Primo tentativo. Nessun bonus.

CJam - 51

q{i32%"@`hptdx|lX\bjrvfz~nZ^ck]swg"=i2b1>2/}%zSf*N*

Provalo su http://cjam.aditsu.net/

Esempio di input:

braille is strange

Esempio di output:

10 10 10 01 10 10 10 00 01 01 00 01 01 10 10 11 11 10 
10 11 00 10 10 10 01 00 10 10 00 10 11 11 00 01 11 01 
00 10 00 00 10 10 00 00 00 10 00 10 10 10 00 10 00 00 

Supporta solo lettere minuscole e spazio. Altri caratteri vengono associati ai caratteri supportati (in particolare lettere maiuscole a lettere minuscole).

Spiegazione:

I caratteri Braille sono codificati usando 1 per un punto in rilievo e 0 per un punto non in rilievo, da sinistra a destra e dall'alto verso il basso. Questo dà 6 cifre di base 2; viene anteposto un 1 per evitare di eliminare gli zeri iniziali, quindi il numero viene convertito in base 10 e quindi nel corrispondente carattere ASCII.
Esempio: t -> ⠞ -> 01/11/10 -> 1011110 -> 94 -> ^

Il programma converte ogni carattere nella tripletta di coppie di bit (come [[0 1][1 1][1 0]]) ottenendo una matrice di coppie di bit. La matrice viene quindi trasposta e vengono aggiunti i separatori (spazi all'interno delle righe, nuove righe tra le righe).

qlegge l'input in una stringa = array di caratteri
{…}%applica il blocco a ciascun carattere
i32%ottiene il codice ASCII mod 32 (spazio-> 0, a-> 1, b-> 2, z-> 26)
"@`hptdx|lX\bjrvfz~nZ^ck]swg"è una stringa contenente i caratteri braille codificato come spiegato prima
=ottiene il corrispondente carattere braille codificato dalla stringa
i2bottiene il codice ASCII quindi converte in base 2 (ottenendo una matrice di 7 cifre)
1>rimuove la prima cifra 1
2/divide la matrice in (3) coppie
ztraspone la matrice
Sf*unisce ogni riga con spazi
N*unisce le righe con nuove righe

C, 249 244

#define B?111:46
#define P(a,b)printf("%c%c ",a B,b B):
a,i;main(int c,char**v){for(char*p;p=v[1],a<3;puts(""),++a)while(i=*p++)i==32?P(0,0)i/97&122/i?c=(i+=(i==119)*17-97-(i>119))%10,a?a^1?P(i/10%3,i/20)P(c>4|c==1,c/3&&c%3-2)P(c<8,5*c/8%2)0;}

L'input è un argomento della riga di comando, che deve essere evitato o citato se la stringa contiene spazi. I caratteri supportati sono lettere minuscole e spazio. I caratteri non supportati vengono eliminati silenziosamente.

Modifica: rasato 5 byte semplificando una condizione

perl, 195 + 2-50 = 147

Questo gestisce capitale, numero e punteggiatura, senza fare affidamento su unicode (195 byte + 2 byte (per -pl) - 50 bonus)

~s/([A-Z])/|$1/g,~s/(\d)/#$1/g,tr/1-90/a-ij/;for$i(1,2,4){map{for$j(1,8){$s.=index(" a,b'k;l^cif/msp_e:h*o!r_djg_ntq|_?_-u(v_____x____._)z\"___w_#y",l$
"}$_=$s

Con rientro:

~s/([A-Z])/|$1/g,
~s/(\d)/#$1/g,
tr/1-90/a-ij/;
for$i(1,2,4){
  map{
    for$j(1,8){
     $s.=index(" a,b'k;l^cif/msp_e:h*o!r_djg_ntq|_?_-u(v_____x____._)z\"___w_#y",lc($_))&$j*$i?o:_
    }
   $s.=_
  }split//;
  $s.="
"}
$_=$s

Uscita campione

perl -pl brail.pl
Hello, 99!
___o__o__o__o__o_________o__o__o__o____
___oo__o_o__o___o_o______o_o___o_o__oo_
_o_______o__o__o________oo____oo____o__

Javascript ES6 - 282 309 297 283 270 - 50 = 232 259 233 220 byte

Questo sarebbe più breve, ma verificare la presenza di lettere maiuscole fa male .

f=_=>{z='toLowerCase';k=(a,b)=>a%b>~-b/2?1:0;t=(a,b)=>k(a,b)+`${k(a,b/2)} `;b=c=d='';for(v of _){v==v[z]()?0:(b+=0,c+=0,v=v[z](d+=1));$=` ,'-";9015283467@./+^_>#i[s!jwt)a*kue:ozb<lvh\\r(c%mxd?nyf$p&g]q=`.search(v);b+=t($,64);c+=t($,16);d+=t($,4)}alert(`${b}
${c}
${d}`)}

EDIT: Grazie a mbomb007 per avermi salvato due byte - sfortunatamente, ho scoperto che un po 'di golf precedente aveva rovinato tutto, quindi ho dovuto aggiungere 27 caratteri.

EDIT: tutti i 12 byte salvati spostando gli spazi.

EDIT: realizzato che era sciocco per l'output come caratteri e risparmiato parecchi byte. Ho anche salvato alcuni caratteri scambiando k = (a, b) => a% (2 * b)> b-1? 1: 0 per k = (a, b) => a% b> ~ -b / 2 1: 0.