Arte ASCII “Hello-World!” [Chiuso]

39

Il tuo obiettivo è quello di scrivere il programma più breve che produca "Hello-World!" come arte ASCII.

Regole :

  • Deve essere leggibile dall'uomo, non mi interessa la sua dimensione (colonne / righe)
  • L'output deve contenere solo spazi (""), taglienti ("#") e newline
  • L'output deve funzionare con un carattere a spaziatura fissa (ma le lettere non devono necessariamente utilizzare un carattere a spaziatura fissa)
  • Nel risultato, ogni personaggio deve essere separato l'uno dall'altro da almeno uno spazio

Aggiungi un titolo con la lingua e il numero di byte nel tuo codice.

code-golf  ascii-art  hello-world 
— sebcap26
fonte
5
bash: 33 caratteri - pastebin.com/HZ1w8z8g È accettabile?
— arte
4
Ma perché il trattino? ...
— Timwi,
1
Suppongo che rendere impossibile o sgradevolmente difficile l'uso di qualcosa di predefinito come HQ9 +.
— arte
1
@PeterTaylor: l'output costituito da spazi e hash deve funzionare con un carattere a spaziatura singola, ma le lettere rappresentate dalla pletora di hash non devono necessariamente avere la stessa larghezza.
— Timwi,
1
— Ilmari Karonen,

Risposte:

18

Mi è piaciuto assolutamente questo

Perl, 126 116 114 102 98   87 (69) caratteri (solo ascii e nessun carattere esterno)

A partire dalla soluzione ascii ora più breve che non utilizza alcun carattere esterno.

Bene, volevo presentare qualche soluzione elegante ma @Ilmari Karonen mi ha sfidato con unpack... non avrei dovuto farlo :-)

Bene, questo codice di 92 88 69 caratteri genera il brutto output illeggibile identico a quello di @Ilmari Karonen:

say map{y/01/ #/r}unpack"((b6)7a)*",'eT@j@DE
UUBjdeE
wTujjTA
eUBTddE'

Variante più elegante senza decomprimere (88 caratteri):

map{print$"x$_,$/x/4/,"#"x!/7/}7&ord,7&ord>>3for'HRyYOKLIIjIRHBa@AJIAIIIJaQHQNSRH'=~/./g

Ma penso che | | | e || .- |||., D! cosa non assomiglia a Hello-World! e non dovrebbe essere permesso, quindi la vera soluzione va qui - decomprimere la variante, 87 caratteri :

say map{y/01/ #/r}unpack"((b6)9a)*",'E`D@HB@Hd
EcD@HB@Hd
ggDsIbaIf
e`dDhRRHE
ECICPaQPf'

Produzione:

inserisci qui la descrizione dell'immagine

Variante più elegante a 98 caratteri:

map{print$"x$_,$/x/1/,"#"x!/7/}7&ord,7&ord>>3for'PW{nw^QD[w}vK@X@PcP@jCDjXQk[rRRbSQD\CWbXeX'=~/./g

Produzione:

inserisci qui la descrizione dell'immagine

Soluzione precedente (114 caratteri), diversi tipi di codifica:

print'#'x(3&ord),$"x($:=15&ord>>2),$/x!$:for'EmM}U}]MBEQSM}U}]MBOFNMQOKUMSKUOBEM]MMM]IIIMIUQIAEQWMMgFROYQOB'=~/./g

Produzione:

inserisci qui la descrizione dell'immagine

— Tomas
fonte
Ho dimenticato l'esclamazione alla fine, cioè Hello-World! Inoltre, dovrebbe essere in minuscolo e, ma so che hai fatto in maiuscolo per renderlo leggibile come un carattere alto cinque pixel ...
47

JavaScript, 178 byte

c=document.createElement("canvas").getContext("2d");c.fillText("Hello-World!",0,7);d=c.getImageData(1,0,56,7).data;s="";for(i=3;i<1568;i+=4){s+=d[i]?"#":" ";s+=(i+1)%224?"":"\n"}

Funziona con Firefox 27 Scratchpad.

#   #        #  #          #   #   #          #     #  #
#   #        #  #          #  # #  #          #     #  #
#   #   ##   #  #   ##      # # # #   ##   ## #   ###  #
#####  #  #  #  #  #  #     # # # #  #  #  #  #  #  #  #
#   #  ####  #  #  #  # ##  # # # #  #  #  #  #  #  #  #
#   #  #     #  #  #  #     # # # #  #  #  #  #  #  #   
#   #   ###  #  #   ##       #   #    ##   #  #   ###  #
— sebcap26
fonte
Riconosco Arial :-D
— Timwi
4
Questo è il mio preferito Hai usato un metodo interessante per arrivare alla soluzione. Meraviglioso!
— Darth Egregious,
2
Ingegnoso, credo che tu abbia appena creato Figlet per JavaScript;)
— WallyWest,
Dagnammit, anche questo è stato il mio primo pensiero! Ecco un voto invece. :)
— Jordan Grey,
37

Mathematica 101 99 98

Ciò rasterizza l'espressione, ottiene i dati dell'immagine binaria, converte ogni 1 in "#", ogni 0 in "" (spazio vuoto) e visualizza l'output in una griglia di 12 per 130 caratteri.

GraphicsGrid[ImageData@ImageResize[Binarize@Rasterize@Style["Hello-World!",99],130] 
  /.{1→"",0→"#"}]

Ciao

Un personaggio economizzato grazie a Jonathan Van Matre.

— DavidC
fonte
1
Perché lo spessore varia tra quelli?
— MrZander
Ho fatto la rasterizzazione sull'espressione come una singola immagine. Se l'avessi fatto lettera per lettera, sarei stato identico. Inoltre, aumentando le dimensioni della griglia di rasterizzazione, l'output tende ad avvicinarsi alla qualità dei caratteri stampati. Ma una griglia più grande produce "#" relativamente più piccoli, al punto da sembrare semplici pixel. La domanda rimane: perché 2 in un'immagine ricevono pesi diversi?
— DavidC
3
@MrZander, questa è la vera ragione per cui i caratteri hanno un suggerimento: quando si cerca di adattare i caratteri in una griglia di pixel a bassa risoluzione, come nell'arte ASCII o sulla larghezza dello stelo dello schermo non è mai davvero uniforme perché il carattere non può avere steli larghi di pixel integrali di tutte le dimensioni . Ecco una bella spiegazione con le immagini.
— Joey,
1
probabilmente il più bello
— Ronan Dejhero,
1
Jonathan Van Matre, grazie. Il primo parametro potrebbe essere ridotto a 99 ma non vorrei ridurre il secondo, a causa della qualità dell'output. (Mi rendo conto che si tratta di una sfida di code-golf, ma ho il mio orgoglio.)
— DavidC,
25

Delphi 85 byte

var s:tstringlist;begin s:=tstringlist.Create;s.LoadFromFile('\a');Write(s.Text);end.

Lo so, non è la soluzione più carina ma non c'era nessuna regola che dicesse che non si potevano usare risorse esterne.
Risultato: Risultato

— Teun Pronk
fonte
12
+1 per la creatività dell'uso di # come sfondo anziché in primo piano.
— Gerrit,
1
Puoi dichiarare s come TStringsinvece. (Ma mantieni l'istanza con TStringList.)
— Manatwork
Il file che stai caricando da qualcosa che viene effettivamente fornito con Delphi o l'hai scritto tu stesso? In quest'ultimo caso, penso che dovresti contare la sua lunghezza come parte del tuo punteggio.
— Ilmari Karonen,
@Ilmari, sono sicuro che Delphi non viene spedito con un file con l'arte ASCII "Hello-World" :) Inoltre, è descritto nella risposta, che utilizza risorse esterne.
— TLama,
3
@TLama: anche io lo pensavo, stavo solo cercando di esprimerlo educatamente. Il mio punto è che, anche se fossero consentite risorse esterne, questo programma fallirebbe comunque sul computer di chiunque tranne che sul suo autore (e, in effetti, non abbiamo prove che funzioni anche sul suo computer). Inoltre, posso battere il suo punteggio con il seguente script Perl: do X. Il contenuto della "risorsa esterna" non Xviene specificato (funziona per me, non è abbastanza?), Ma ho fornito un paio di possibili suggerimenti di seguito ...
— Ilmari Karonen,
15

Perl 5, 54 byte / 71 caratteri ASCII stampabili

Nota: questa è la seconda versione di questa risposta. Per la versione originale a 64 byte / 95 caratteri che utilizza PHP e gzinflate (), vedere la cronologia di questa risposta .

Ecco la versione ASCII stampabile a 71 caratteri:

y/01/ #/,say for unpack'(B40)4',unpack u,'4I*`1`(JJI!$FFNRJU52HIJ0*))H'

La versione a 54 byte contiene caratteri non stampabili, quindi la sto fornendo come dump esadecimale. Sui sistemi Unixish, puoi usare xxd -rper trasformare il dump esadecimale in uno script Perl eseguibile:

0000000: 792f 3031 2f20 232f 2c73 6179 2066 6f72  y/01/ #/,say for
0000010: 2075 6e70 6163 6b27 2842 3430 2934 272c   unpack'(B40)4',
0000020: 27a4 a011 008a aaa4 1126 9aec aad5 54a8  '........&....T.
0000030: a6a4 0a24 9a27                           ...$.'

Entrambi devono essere eseguiti con perl -M5.010per abilitare la sayfunzione Perl 5.10+ . Produrranno il seguente output:

Schermata di "Hello-World!" ASCII art

(Indicato come uno screenshot, perché l'enorme altezza della linea su SE rende l'arte ASCII brutta e difficile da leggere. La minuscola "e" è un po 'imbarazzante, ma credo che questo si qualifichi come leggibile, anche se a malapena.)

Ps.Se l'output della soluzione sopra sembra troppo minimalista per te, ecco una variante di 92 caratteri che produce output simile alla soluzione di Tomas :

y/01/ #/,say for unpack'(B56)*',unpack u,'CH!(`"(`"":,2``B``@GGDC\'(C#(YI!)("I)"2*,),`4,03D'

Ecco uno screenshot:

Schermata di "Hello-World!" ASCII art

Pps. sono abbastanza sicuro questo ( GolfScript, 51 caratteri ) sia la soluzione ASCII stampabile più breve, se non conti quelli che chiamano semplicemente banner / FIGLet o che imbrogliano in qualche altro modo:

'iJ@Q@HmURBIMM{JkUUJeMRAQIM'{2base(;{' #'=}/}%39/n*

L'output è lo stesso della mia soluzione Perl da 71 caratteri sopra.

— Ilmari Karonen
fonte
Direi che hai appena attraversato il confine della leggibilità :-)
— Tomas
1
È considerevolmente più leggibile nel mio terminale che qui su SE, a causa dell'enorme interlinea qui.
— Ilmari Karonen,
Voglio dire, è illeggibile comunque. A proposito, posso produrre il tuo output in 92 caratteri , senza algoritmo di compressione esterno :-)
— Tomas
@Tomas: hai ragione, zippare non sembra essere la risposta vincente qui. Ti darei un +1 per quello se non lo avessi già fatto. A proposito, posso farlo in 71 caratteri; vedi sopra. :-)
— Ilmari Karonen
1
Ilmari, non avresti dovuto sfidarmi con unpack:-) Ho trovato una soluzione di 69 caratteri (87 con la mia bella uscita).
— Tomas,
8

Shell + Figlet (35)

$ figlet -w 90 -f banner Hello-World!
#     #                                   #     #                             ### 
#     # ###### #      #       ####        #  #  #  ####  #####  #      #####  ### 
#     # #      #      #      #    #       #  #  # #    # #    # #      #    # ### 
####### #####  #      #      #    # ##### #  #  # #    # #    # #      #    #  #  
#     # #      #      #      #    #       #  #  # #    # #####  #      #    #     
#     # #      #      #      #    #       #  #  # #    # #   #  #      #    # ### 
#     # ###### ###### ######  ####         ## ##   ####  #    # ###### #####  ###
— truce
fonte
Che tipo di carattere è questo? Sembrano solo caratteri minuscoli più piccoli.
— Cruncher,
è banner -f bannerÈ stato il primo carattere che ho trovato che utilizzava # invece di * o | e _.
— cupo
— jfs
Cambiando "90" in "9" si ottiene un mondo alto e magro ciao, tuttavia, poiché l'OP non si preoccupa di colonne o righe, dovrebbe essere accettabile.
— alexyorke,
A volte gli elettori mi confondono. Come mai questo ottiene un punteggio netto di +8, ma l'altra risposta del figlet ottiene un punteggio netto di -3?
— Trauma digitale,
8

Python 260 215 186 152

>>> print'eJyNkFEKwDAIQ/93isC7/x3LyIJullHrR1BfJSIJPUHTlmiUPHbxC7L56wNCgZAxv3SjDWIxsoOb\nzMaBwyHYPJ5sVPNYxXism74vcIsFZlYyrg=='.decode('base64').decode('zip')
#   #        #  #          #   #   #          #     #  #
#   #        #  #          #  # #  #          #     #  #
#   #   ##   #  #   ##      # # # #   ##   ## #   ###  #
#####  #  #  #  #  #  #     # # # #  #  #  #  #  #  #  #
#   #  ####  #  #  #  # ##  # # # #  #  #  #  #  #  #  #
#   #  #     #  #  #  #     # # # #  #  #  #  #  #  #   
#   #   ###  #  #   ##       #   #    ##   #  #   ###  #

Python 196 183 130 114 (ma più brutto)

>>> print'eJxTVlBWgCAgAQHKqBywAJeyAgJCZREcZWUYyaUMIpUVEKqRNcLEueDqEaZBLVVWQDITADIdFBw='.decode('base64').decode('zip')
# #  #  # #        # # #        #   # #
# # # # # #  #     # # #  #  ## #  ## #
### ##  # # # # ## # # # # # #  # # #
# #  ## # #  #      # #   #  #  #  ## #

Ho usato i dati zippati nella codifica base64. e il codice lo decodifica dalla codifica base64 e quindi la decomprime.

— Eliseo
fonte
Caspita, è davvero leggibile!
7

PHP - 183 byte

Utilizzando l'arte ASCII di sebcap26 come sorgente ...

foreach(str_split(base64_decode('iASAERACCYgEgBKQAgmIxIwKoxo5+SSSCqSSSYnkksqkkkmJBJIKpJJIiOSMBEMSOQ'))as$i=>$j)echo strtr(sprintf("%8s%s",decbin(ord($j)),($i+1)%7?"":"\n"),'01',' #');

#   #        #  #          #   #   #          #     #  #
#   #        #  #          #  # #  #          #     #  #
#   #   ##   #  #   ##      # # # #   ##   ## #   ###  #
#####  #  #  #  #  #  #     # # # #  #  #  #  #  #  #  #
#   #  ####  #  #  #  # ##  # # # #  #  #  #  #  #  #  #
#   #  #     #  #  #  #     # # # #  #  #  #  #  #  #   
#   #   ###  #  #   ##       #   #    ##   #  #   ###  #
6

Brainfuck, 372 byte

(Lo so. Ma solo per completezza, ci deve essere un brainfuck ^^ Non sarà molto più breve, poiché ci sono piccole ripetizioni. Già prima e seconda linea di loop ...)

++++++++[>++++>++++<<-]>+++>>++++++++++>>+>++[-<<<<<.>.<.>..>>>[-<<<.>>>]<[-<<<.>>>]<<..<.>>>++[-<<.<.>..........<.>....>>]<<<.>.<.>>.>+>>]<<<<<...>.<.>.<.>.<.>.<.>..<..>..<...>.<.>..<.>..<.>..<..>...<..>.<.>..<...>.<.>>.<<.>.<.>.<.>...<.>.<.>.<.>..<.>.....<.>.<...>.<.>.<.>..<.>.<.>...<.>.<.>..<.>>.<<.>.<.>.<...>.<.>.<.>..<..>.......<..>.<..>...<..>..<.>...<.>..<..>..<.

Interprete qui: http://koti.mbnet.fi/villes/php/bf.php

# #     # #          #     #          #    # #
# #  #  # #          #     #          #    # #
### # # # #  ##  ### #  #  #  ##   ## #  ### #
# # #   # # #  #     # ### # #  # #   # #  #
# # ### # #  ##       ## ##   ##  #   #  ##  #

Combinando il generatore di numeri e l'immagine di @ ASKASK con i miei loop e alcune ottimizzazioni aggiuntive, otteniamo:

Brainfuck, 343 339 336 334 byte

Sembra più brutto della mia versione originale però.

+++++[->++++++>+++++++>++<<<]>++>>>+>>++[-<<<<.<.>.<..>>>[-<<<.>>>]>[-<<<.>>>]<<<<..>.<.>>>++[-<<.<.........>.<...>>>]<<.<.>.>.>>+>]<<<<..<<+++++[->>.<.<]>.>.<..>...<.>.<.>.<.>.<..>.<...>..<.>.<..>..<.>.>.<.<.>.<.>.<...>.<.>.<.>.<.>.<.....<++++++[->>.<.<]>..>.<.>.<.>.>.<.<.>.<..>.<..>.<.>.<..>.<.......>...<...>.<..>.<...>.<..>.<..>.

(immagine vedi la risposta di ASKASK)

— Johannes H.
fonte
5

EcmaScript 6, 172 161

'¡I%e!c0ĄJ¥eìo0¸ËefMs0µKcÊIs0´Ê¢1éo'.split(0).map(s=>s.split('').map(c=>{for(i=8,s='';i--;)s+=(c.charCodeAt(0)-33)&(1<<i)?'#':' ';return s;}).join('')).join('\n')

Produzione:

#         # #        #   #   #           #    #
###   ##  # #  ##    #   #   #  ##  # ## #  ###
#  # #### # # #  #   #   #   # #  # ##   # #  #
#  # #    # # #  #    # # # #  #  # #    # #  #
#  #  ### # #  ##      #   #    ##  #    #  ###

Spiegazione:

Il testo ASCII è compattato in una stringa in cui ogni bit rappresenta un pixel :

  • 0 per SPACE
  • 1 per #

Viene applicato un offset di 33 per ottenere solo caratteri stampabili.

— Florent
fonte
Le parentesi e la prima returnistruzione della funzione freccia grassa non sono necessarie.
— arte
@manatwork Ho provato a rimuoverlo ma non è stato più compilato. Sei sicuro di questo?
— Florent,
1
— manatwork
@manatwork Grazie!
— Florent,
charCodeAt(0)può essere ridotto a charCodeAt().
— Chiru,
4

Sclipting , 38 caratteri (76 byte)

갦륈똄릵꺕녔꺒녪냕녪낷뚕년꺒녦냉괄낵要감嚙긂밃⓶掘⓶終丟併껧뜴꼧밍替現겠合終

Produzione:

# # ## #  #   #     #   #  #  ##  #  ##  #
# # #  #  #  # #    #   # # # # # #  # # #
### ## #  #  # # ## # # # # # ##  #  # # #
# # #  #  #  # #    # # # # # # # #  # #  
# # ## ## ##  #      # #   #  # # ## ##  #
— Timwi
fonte
4
La pagina di informazioni sul code-golf dice "Se usi Unicode, il conteggio dei byte dovrebbe usare UTF-8". Se non sbaglio, questo rende il tuo programma di 114 byte . (I 76 byte che menzionerai sarebbero per UTF-16 senza DBA.)
— ris.
@res: l'ho cambiato, poiché non ha senso richiederlo. Il mio interprete Sclipting capisce bene UTF-16, quindi è un programma valido codificato come UTF-16.
— Timwi,
1
Timwi, il caso conta
— Tomas
3
@ user689 - in realtà "Hello-World!" con un punto esclamativo alla fine ...
1
Suppongo che "accettato dalla comunità" significhi "accettato, senza discussione della comunità , da un piccolo numero di persone con il potere di farlo".
— res
3

Brainfuck, 362 byte

Scusa @ johannes-h, ho visto il tuo ed è stato ispirato a crearne uno mio. Utilizza una combinazione di generazione di numeri più rapida all'inizio e un'immagine più semplice per generare il risultato in meno byte. Tuttavia non utilizza loop altrove, quindi è ottimizzato.

+++++[->++++++>+++++++>++<<<]>++>.<.>.<.....>.<.>.<.........>.<...>.<.........>.<...>.<.>.>.<.<.>.<..>.<..>.<.>.<.........>.<...>.<.........>.<...>.<.>.>.<...<.>.<.>.<.>.<.>.<..>.<..>...<.>.<.>.<.>.<..>.<...>..<.>.<..>..<.>.>.<.<.>.<.>.<...>.<.>.<.>.<.>.<.....>.<.>.<.>.<.>.<.>.<.>.<...>.<.>.<.>.>.<.<.>.<..>.<..>.<.>.<..>.<.......>...<...>.<..>.<...>.<..>.<..>.

che genera:

pic

— ASKASK
fonte
Hm. Quanto è più breve la generazione del numero? perché cambiare l'immagine mi sembra ingannare (almeno quando si confrontano direttamente le nostre soluzioni - perfettamente valido in questo contesto ovviamente) ^^ BUt vado a esaminare le tue in seguito :) Puoi fare il mio giro per la prima due righe tuttavia. È molto più breve (circa 10-20 byte se ricordo bene)
— Johannes H.
ho portato la tua versione a 343 byte, vedi la mia risposta
— Johannes H.
e ancora più breve, sostituendo più ripetizioni con loop. 339 ora.
— Johannes H.
Non ho mai la reputazione di commentare la tua, ma se osservi attentamente la tua nuova versione troverai un "> <" che può essere cancellato per togliere due byte :)
— CHIEDERE
3

ImageMagick + sed, 71 byte

Non vedo altre voci di ImageMagick, quindi ecco la mia puntata tardiva nel terreno:

convert +antialias label:Hello-World! xpm:-|sed '8,+9y/ /#/;s/[^#]/ /g'

Penso che la sedporzione possa probabilmente essere giocata a golf ancora un po '.

Provalo online .

Produzione:

  # # # # ## # # # # #     
  # # # # # ## ## # # #     
  # # # # ### # # # # #     
  # # #### # # #### # # # # #### # # # ### # #     
  ###### # # # # ## ## # # # # ## ## ## # ## ## #     
  # # ###### # # # # ### # # # # # # # # # # #     
  # # # # # # # ## ## # # # # # # #     
  # # ## ## # # ## ## ## ## ## ## # # ## ##        
  # # #### # # #### ## ## #### # # ### # #
— Trauma digitale
fonte
2

Postscript, 154 133

<~GasbQ8I>GO#QsOD7:?,pa&5XCgo@jeLPX:a4F9kN1nu1B@8KjD"^]WgY[MA.2VBjpTNo5$Pi%uI9Lr>,9`~>/FlateDecode filter 999 string readstring pop =

vale a dire 

    <~GasbQ8I>GO#QsOD7:?,pa&5XCgo@jeLPX:a4F9kN1nu1B@8KjD"^]WgY[MA.2VBjpTNo5$Pi%uI
9Lr>,9`~>
/FlateDecode filter 
999 string readstring pop 
=

Fonte unica per ASCII, l'ispirazione per l'arte ASCII è stata la risposta di Johannes H. :-)

# #     # #         #    #          #    # #
# #  #  # #         #    #          #    # #
### # # # #  ##  ## #    #  ##   ## #  ### #
# # #   # # #  #    # ## # #  # #   # #  #
# # ### # #  ##      #  #   ##  #   #  ##  #

(più leggibile nel terminale)

Perl, 102

print$-%44?'':"\n",vec(unpack(u,'<!040`A!:4@`A`*%7918REEM1":T4)75E(#&1"0``'),$-++,1)?'#':' 'for 0..219

Stesso risultato di cui sopra. So di aver perso entrambe le risposte Perl sopra, ma lo pubblico comunque. Almeno ci ho provato e mi stavo muovendo nella giusta direzione (e non avevo visto la risposta più breve) :-).

— user2846289
fonte
2

Pure Bash, nessuna utility esterna - 133 caratteri:

c=" #";for x in 0x{5250088045,55520A914D,74556AAA54,535205124D};do while((s=(t=x)^(x/=2)*2,t));do L=${c:s:1}$L;done;echo "$L";L=;done

Utilizza lo spostamento destro e sinistro (dividi e moltiplica per 2) e xor per trovare i bit uno.

Dati sui caratteri rubati da Blender / Ilmari Karonen.

Testato in Bash 3.2 e 4.2

A proposito, questo è solo 166 caratteri:

echo "# #  #  # #        #   #        #   # #
# # # # # #  #     # # #  #   # #  ## #
### #   # # # # ## # # # # # #  # # #  
# #  ## # #  #      # #   #  #  #  ## #"
— In pausa fino a nuovo avviso.
fonte
1

Python 3, 114

print('\n'.join(bin(x)[2:]for x in[353530052677,366448644429,499649260116,357858349645]).translate({48:32,49:35}))

Uscita (4 caratteri di altezza e e W rubato @Ilmari Karonen ):

# #  #  # #        #   #        #   # #
# # # # # #  #     # # #  #   # #  ## #
### #   # # # # ## # # # # # #  # # #  
# #  ## # #  #      # #   #  #  #  ## #

E uno più corto (107):

print('\n'.join(bin(x)[2:]for x in[11993933918769,16391913257513,12021315382193]).translate({48:32,49:35}))

Produzione:

# # ### #   #   ###   # # ### ##  #   ##   #
### ### #   #   # #   # # # # ### #   # #  #
# # ### ### ### ###   ### ### # # ### ##   #
— Miscelatore
fonte
È per lo più illeggibile. Il tuo mondo dalla seconda uscita è in realtà Uorld.
— Silviu Burcea,
@SilviuBurcea: sembra migliore su un vero emulatore di terminale. Inoltre, "Human-readable" ti dà un po 'di spazio di manovra. Sono sicuro che puoi indovinare che cosa "CIAO ⊔ORLD!" si intende.
— Blender,
Usa costanti esadecimali e ritaglia alcuni caratteri
— Floris,
@Floris: ci ho provato. Il prefisso di due caratteri li rende altrettanto lunghi fino a circa 20 cifre.
— Blender,
1

Personaggi Python 154, (dimensione 5X7 caratteri)

print'\n'.join(map(''.join,zip(*(''.join("# "[int(e)]for e in"{:07b}".format(ord(c))[1:])for c in"€÷÷÷€ÿñêêòÿ€ÿ€ÿñîîñÿûûÿŸáþÁ¿ÁþáŸÿñîîñÿàïÿ€ÿÿñîî€ÿ‚"))))

Produzione

#   #      # #         #   #   #         #     # #
#   #      # #         #  # #  #         #     # #
#   #  ##  # #  ##      # # # #   ##  ## #   ### #
##### #  # # # #  #     # # # #  #  # #  #  #  # #
#   # #### # # #  # ##  # # # #  #  # #  #  #  # #
#   # #    # # #  #     # # # #  #  # #  #  #  #  
#   #  ### # #  ##       #   #    ##  #  #   ### #
— Abhijit
fonte
1

bash:

(103 89 byte)

Codice:

base64 -d<<<rohBEmRiqIihFVRS7IitVWRSqIihVVRQru5Aoldi|xxd -b|sed -e's/ //g;s/1/#/g;s/0/ /g'|cut -b'9-55'

Produzione:

# # ### #   #    #     #   #  #  ##  #   ##   #
# # #   #   #   # #    #   # # # # # #   # #  #
### ##  #   #   # # ## # # # # # ##  #   # #  #
# # #   #   #   # #    # # # # # # # #   # #   
# # ### ### ###  #      # #   #  # # ### ##   #

Più piccolo, ma meno leggibile (basato su http://mckgyver.pbworks.com/f/1240440791/3PixelFont.jpg ):

Codice:

base64 -d<<<V0nCLsmQdklaqslQV23BTq2Q|xxd -b|sed -e's/ //g;s/1/#/g;s/0/ /g;'|cut -c'9-52'

Produzione:

 # # ### #  #  ###    #   # ### ##  #  ##  #
 ### ##  #  #  # # ## # # # # # ##  #  # # #
 # # ### ## ## ###     # #  ### # # ## ##  #
— christofsteel
fonte
1

Javascript / ES6 (108 byte)

Copia nella console:

[,0xa0a028045,0xeeae2bb5d,0xacaabaa54,0xaeae2ba5d].map(a=>a.toString(2).replace(/./g,b=>' #'[b])).join('\n')

Produzione:

"
# #     # #       # #        #   # #
### ### # # ###   # # ### ## # ### #
# # ##  # # # # # ### # # #  # # #  
# # ### # # ###   # # ### #  # ### #"

(Richiede browser compatibile ECMAScript6, ad es. Firefox 22+)

Ispirato da @maximeeuziere, @ p01, @aemkei

— Musterknabe
fonte
.join('\n')può essere ridotto a .join(` `)dove lo spazio è un nuovo carattere di riga reale.
— Chiru,
1

Autori: xem, aemkei, p01, jonas

Eseguire questo nella console JS.

JavaScript, cross-browser, 133 132 126 117 byte

for(i=s="";l=[43117609029,64070269789,46349920852,46890400349][i++];)for(j=0,s+="\n";c=l.toString(2)[j++];)s+=" #"[c]

JavaScript, ES6, funziona su Firefox, 108 byte

[,0xa0a028045,0xeeae2bb5d,0xacaabaa54,0xaeae2ba5d].map(a=>a.toString(2).replace(/./g,b=>' #'[b])).join('\n')

Risultato:

>
# #     # #       # #        #   # #
### ### # # ###   # # ### ## # ### #
# # ##  # # # # # ### # # #  # # #  
# # ### # # ###   # # ### #  # ### #
— XEM
fonte
@ p01 ha realizzato una versione più breve (118 byte) qui: twitter.com/p01/status/433230019419471872
— aemkei,
1

HTML, 209 caratteri

<pre># #     # #                      #   # #
# #     # #        # # #         #   # #
###  ## # #  #     # # #  #  ##  #  ## #
# # ##  # # # # ## # # # # # # # # # #
# # ### # #  #      # #   #  #   # ### #</pre>
Espandi frammento

Questo conta? :)

— Florrie
fonte
1

Shell, 20 caratteri:

banner Hello-world\!

Perché questo funzioni, ovviamente è necessario banner programma. Su Debian, puoi ottenerlo installando il bsdmainutilspacchetto.

Questo stampa una versione del tuo messaggio magnificamente resa, progettata per essere stampata su una delle vecchie stampanti a alimentazione continua, quindi l'output del testo sopra è lungo 322 righe per 123 colonne di larghezza e si gira la stampa su un lato per leggere il messaggio. Potresti appendere la carta risultante al muro come uno striscione, da cui il nome.

http://en.wikipedia.org/wiki/Banner_%28Unix%29

EDIT: Sembra che Debian abbia anche il sysvbannerpacchetto, che installa un programma banner che stampa il testo in orizzontale per la visualizzazione su un terminale. Tuttavia, questo stampa solo i primi 10 caratteri del messaggio, quindi è un po 'fastidioso per questo problema di code-golf!

— steveha
fonte
1
Credo che tu intendessi scrivere banner hello-world.
— Floris,
@Floris, grazie per l'heads-up. Fisso.
— steveha,
1
Si noti che il banner è apparso su Unix v7 nel 1979 e si trova praticamente su ogni Unix.
— sch
@sch, sono d'accordo che bannerè disponibile praticamente per ogni UNIX. Ho appena messo il pacchetto Debian come una prova conveniente che non stavo solo inventando qualcosa, per le persone che non lo sapevano. In questi giorni non mi aspetterei di trovare bannerinstallato per impostazione predefinita su UNIX, non più di quanto mi aspetto di trovare una stampante a alimentazione continua in un laboratorio informatico. Ma qualsiasi golf del codice sulla creazione di testo banner dovrebbe davvero avere il bannerprogramma da qualche parte. Fa parte della nostra ricca storia culturale come fanatici dei computer. :-)
— steveha,
1

bash, 175 170 byte

Devi sprecare un bel po 'di personaggi per produrre un risultato carino !

base64 -d<<<H4sICKaT9FICAzAxAK2RQQ7AIAgE776CZP7/x1ZjERebcJAL0QybhcV6YdWizAPNaUatQQLFpj6h+c/XA05WF9Wtk9WJcxz4oe6e1YPQa7Wiut2wfjJ16STY30lSnNIlzvdpHhd6MiTOB65NYc+LAgAA|zcat

Produzione:

#     #                                         #     #                                   ###
#     #  ######  #       #        ####          #  #  #   ####   #####   #       #####    ###
#     #  #       #       #       #    #         #  #  #  #    #  #    #  #       #    #   ###
#######  #####   #       #       #    #  #####  #  #  #  #    #  #    #  #       #    #    #
#     #  #       #       #       #    #         #  #  #  #    #  #####   #       #    #
#     #  #       #       #       #    #         #  #  #  #    #  #   #   #       #    #   ###
#     #  ######  ######  ######   ####           ## ##    ####   #    #  ######  #####    ###
— devnull
fonte
Puoi ridurlo con lzma / unlzma
— Emmanuel,
0

F # - 204 caratteri

for s in(Seq.map(Seq.unfold(function|0L->None|i->Some(" #".[int(i%2L)],i/2L)))[173948798213L;174770890021L;191304848727L;182715110773L;45277009173L;191279670629L])do printfn"%s"(new string(Seq.toArray s))

Produzione:

# #     # #        # #         #   # #
# #  #  # #  #     # #  #   ## #   # #
### # # # # # #    # # # # #   #  ## #
# # ### # # # # ## # # # # #   # # # #
# # #   # # # #    ### # # #   # # #  
# #  ## # #  #     # #  #  #   #  ## #
— mattnewport
fonte
0

Python + pyfiglet - 87 caratteri

from pyfiglet import figlet_format     
print(figlet_format('Hello-World!', font='banner'))

Produzione

#     #                                   #     #                             ### 
#     # ###### #      #       ####        #  #  #  ####  #####  #      #####  ### 
#     # #      #      #      #    #       #  #  # #    # #    # #      #    # ### 
####### #####  #      #      #    # ##### #  #  # #    # #    # #      #    #  #  
#     # #      #      #      #    #       #  #  # #    # #####  #      #    #     
#     # #      #      #      #    #       #  #  # #    # #   #  #      #    # ### 
#     # ###### ###### ######  ####         ## ##   ####  #    # ###### #####  ###

Per installare pyfiglet, eseguire:

$ pip install pyfiglet
— jfs
fonte
0

Python con pyfiglet: 66 usando argv, 69 senza

66:

from pyfiglet import*
print(figlet_format(sys.argv[1],font='3x5'))

69:

from pyfiglet import*
print(figlet_format('Hello-World!',font='3x5'))

gli abeti devono essere chiamati come, ad esempio:

python asciiart.py 'Hello-World!'

secondo:

python asciiart.py.

Produzione:

    # #      #   #          # #          #    #  #  
    # # ###  #   #  ###     # # ### ###  #  ###  #  
    ### ##   #   #  # # ### ### # # #    #  # #  #  
    # # ###  ##  ## ###     ### ### #    ## ###     
    # #                     # #                  #

(Beh, sembra un po 'schifoso con questo carattere. Tuttavia :))

[modifica] rimosso trattino obsoleto dall'argomento.

— Taku
fonte
Perché il trattino extra davanti all'output?
— Ilmari Karonen,
Il mio errore, è l'output di quello che usa argv, dove ho usato un trattino prima dell'argomento (questione di abitudine, mentre uso sempre bash). Lo modificherò, grazie.
— Taku,
0

Javascript 137 (134)

Utilizza i bit di numeri interi per rappresentare taglienti e spazi bianchi. Testato con Firefox 27.

137 caratteri

s="";[0xadb73eead9,g=0xa9252aaa94,0xed252aac95,g+1,0xad272aee99].map(n=>{for(;n>0;n/=2)n%2?[s="#"+s,n--]:s=" "+s;s="\n"+s});console.log(s)

# # ## #  #  ###  # # # ### ### #  ##  #
# # #  #  #  # #  # # # # # # # #  # # #
### ## #  #  # #  # # # # # ##  #  # # #
# # #  #  #  # #  # # # # # # # #  # #  
# # ## ## ## ###  ##### ### # # ## ##  #"

134 caratteri (ruotato di 180 °)

s="";[0xadb73eead9,g=0xa9252aaa94,0xed252aac95,g+1,0xad272aee99].map(n=>{s+="\n";for(;n>0;n/=2)n%2?[s+="#",n--]:s+=" "});console.log(s)

"
#  ## ## # # ### #####  ### ## ## ## # #
  # #  # # # # # # # #  # #  #  #  # # #
# # #  #  ## # # # # #  # #  #  # ## ###
# # #  # # # # # # # #  # #  #  #  # # #
#  ##  # ### ### # # #  ###  #  # ## # #"
— schwer
fonte
0

Python3 (126)

C'è uno spazio aggiuntivo tra i caratteri per renderlo più leggibile. Quindi tecnicamente è una soluzione di 125 caratteri.

print(' '.join(['','\n'][i%40==0]+['#',' '][int('72liw1j4glyc34dum02j2a4ipxa8b7vvp65x511',36)//2**i%2==0]for i in range(200)))

Produzione:

#   #   # #   #     #     # # #     #   #   #   # # #   # # #   #     # #     # 
#   #   #     #     #     #   #     #   #   #   #   #   #   #   #     #   #   # 
# # #   # #   #     #     #   #     #   #   #   #   #   # #     #     #   #   # 
#   #   #     #     #     #   #     #   #   #   #   #   #   #   #     #   #     
#   #   # #   # #   # #   # # #     # # # # #   # # #   #   #   # #   # #     #
— schwer
fonte
0

Bash 37 , 33

toilet<<<"Hello-world"|tr \"m \#

 #    #        ###    ###                                       ###        # 
 #    #  ###     #      #     ###         #     #  ###    # ##    #     #### 
 ###### ##  #    #      #    ## ##        ## # ## ## ##   ##  #   #    ## ## 
 #    # #####    #      #    #   #   ###   #####  #   #   #       #    #   # 
 #    # #####    ###    ###  #####          # #   #####   #       ###  #####

Che è lo stesso di:

echo "Hello-world" | toilet

A partire dal man toilet

TOIlet - mostra un grande personaggio colorato

Con tr "'\"m" "#"tutti i "caratteri vengono sostituiti con #.

— fedorqui
fonte
tri parametri sarebbero più brevi sfuggiti a quelli quotati. Intendo tr \'\"m \#invece di tr "'\"m" "#".
— arte
Oh buono, non ne ero a conoscenza. Grazie @manatwork
— fedorqui,
Aspetta un secondo. L' toiletoutput non ha avuto virgolette singole. Perché lo hai incluso nel trprimo parametro? Basta tr \"m \#è sufficiente.
— arte
@manatwork Penso di aver bisogno di più caffè :)
— fedorqui,
0

Smalltalk, 151

anche se questo gioco di golf è già finito, per riferimento:

i:=((Form extent:115@14)displayString:'Hello world'x:0y:12;asImage).0to:13 do:[:y|i valuesAtY:y from:0to:114 do:[:x :p|({$#.$ }at:p+1)print].Stdout cr]

produzione:

 ***  ***             ***       ***                                                         ***           **       
  *    *                *         *                                                           *            *       
  *    *                *         *                                                           *            *       
  *    *     ***        *         *        ***              ***   ***    ***     *** ***      *        *** *       
  ******    *   *       *         *       *   *              *     *    *   *      **   *     *       *   **       
  *    *   *     *      *         *      *     *             *  *  *   *     *     *          *      *     *       
  *    *   *******      *         *      *     *              * * *    *     *     *          *      *     *       
  *    *   *            *         *      *     *              * * *    *     *     *          *      *     *       
  *    *    *    *      *         *       *   *               ** **     *   *      *          *       *   **       
 ***  ***    ****    *******   *******     ***                *   *      ***     ******    *******     *** **
— blabla999
fonte
Devi usare solo i caratteri '' (spazi) e '#' (anche i caratteri di nuova riga).
— Mukul Kumar
errore mio; l'output proveniva da una corsa precedente; il codice è corretto "{$ #. $} a: p + 1".
— blabla999,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.