L'art ASCII “Hello-World!” [Fermé]

39

Votre objectif est d’écrire le programme le plus court contenant "Hello-World!" comme ASCII art.

Règles :

  • Il doit être lisible par l'homme, peu importe sa taille (colonnes / lignes)
  • La sortie doit contenir uniquement des espaces (""), des objets tranchants ("#") et des nouvelles lignes.
  • La sortie doit fonctionner avec une police monospace (mais les lettres n'utilisent pas nécessairement une police monospace)
  • Au final, chaque caractère doit être séparé par au moins un espace.

Veuillez ajouter un titre avec la langue et le nombre d'octets dans votre code.

code-golf  ascii-art  hello-world 
— sebcap26
source
5
bash: 33 caractères - pastebin.com/HZ1w8z8g Est-ce acceptable?
— manatwork
4
Pourquoi ce trait d'union? ...
— Timwi
1
Je suppose que rendre impossible ou impossible l'utilisation de quelque chose prédéfini comme HQ9 +.
— Manatwork
1
@PeterTaylor: la sortie composée d'espaces et de hachages doit fonctionner avec une police à espacement fixe, mais les lettres représentées par la pléthore de hachages n'ont pas besoin d'avoir toutes la même largeur.
— Timwi
1
En relation, mais différent: Dites «bonjour» au monde dans l'art ASCII
— Ilmari Karonen

Réponses:

18

J'ai vraiment apprécié celui-ci

Perl, 126 116 114 102 98   87 (69) caractères (ascii uniquement et pas de polices externes)

À ce jour, la solution ASCII la plus courte qui n’utilise aucune police externe.

Eh bien, je voulais présenter une solution élégante mais @Ilmari Karonen m'a mis au défi avec unpack... n'aurais pas dû le faire :-)

Eh bien, ce code de 92 88 69 caractères génère une sortie illisible en anglais identique à celle de @Ilmari Karonen:

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

Variante plus élégante sans décompresser (88 caractères):

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

Mais je pense que tel |. | E || .- |||., D! rien ne ressemble à Hello-World! et ne devrait pas être autorisé, donc la solution réelle va ici - variante de décompression, 87 caractères :

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

Sortie:

enter image description here

Variante plus élégante à 98 caractères:

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

Sortie:

enter image description here

Ancienne solution (114 caractères), type de codage différent:

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

Sortie:

enter image description here

— Tomas
source
Oublié l'exclamation à la fin, c'est-à-dire Hello-World! Aussi, devrait être en minuscules e, mais je sais que vous avez fait des majuscules pour le rendre lisible avec une police de cinq pixels de haut ...
47

JavaScript, 178 octets

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"}

Cela fonctionne dans Firefox 27 Scratchpad.

#   #        #  #          #   #   #          #     #  #
#   #        #  #          #  # #  #          #     #  #
#   #   ##   #  #   ##      # # # #   ##   ## #   ###  #
#####  #  #  #  #  #  #     # # # #  #  #  #  #  #  #  #
#   #  ####  #  #  #  # ##  # # # #  #  #  #  #  #  #  #
#   #  #     #  #  #  #     # # # #  #  #  #  #  #  #   
#   #   ###  #  #   ##       #   #    ##   #  #   ###  #
— sebcap26
source
Je reconnais Arial :-D
— Timwi
4
C'est mon préféré. Vous avez utilisé une méthode intéressante pour arriver à la solution. Magnifique!
— Dark Egregious
2
Ingénieux, je pense que vous venez de créer Figlet pour JavaScript;)
— WallyWest
Dagnammit, c'était aussi ma première pensée! Voici un vote positif à la place. :)
— Jordan Grey
37

Mathematica 101 99 98

Cela pixellise l'expression, obtient les données d'image binaire, convertit chaque 1 en "#", chaque 0 en "" (espace vide) et affiche la sortie dans une grille de 12 sur 130 caractères.

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

hello

Un personnage économisé grâce à Jonathan Van Matre.

— DavidC
source
1
Pourquoi l'épaisseur varie-t-elle entre les l?
— MrZander
J'ai rastérisé l'expression en une seule image. Si je l'avais fait lettre par lettre, les l auraient été identiques. De plus, en augmentant la taille de la grille de rastérisation, la sortie tend à se rapprocher de la qualité des caractères imprimés. Mais une grille plus grande donne un "#" relativement plus petit, au point qu'ils semblent être de simples pixels. La question demeure: pourquoi les 2 dans une image reçoivent-ils des poids différents?
— DavidC
3
@MrZander, c'est la raison même pour laquelle les polices ont des allusions: lorsque vous essayez d'ajuster les polices dans une grille de pixels à faible résolution, comme dans les dessins ASCII ou sur la largeur de la tige d'écran, la largeur de la police n'est jamais uniforme car la police ne peut pas comporter de tiges de pixels intégraux de toutes tailles . Voici une belle explication avec des images.
— Joey
1
probablement le meilleur
— Ronan Dejhero
1
Jonathan Van Matre, merci. Le premier paramètre pourrait être réduit à 99 mais je ne voudrais pas réduire le second en raison de la qualité de la sortie. (Je réalise qu'il s'agit d'un défi de code-golf, mais j'ai ma fierté.)
— DavidC
25

Delphi 85 octets

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

Je sais que ce n’est pas la solution la plus jolie, mais il n’y avait pas de règle qui interdisait l’utilisation de ressources externes.
Résultat: Result

— Teun Pronk
source
12
+1 pour la créativité d'utiliser # en arrière-plan plutôt qu'en avant-plan.
— gerrit
1
Vous pouvez déclarer s comme à la TStringsplace. (Mais gardez l'instanciation avec TStringList.)
— manatwork
Le fichier que vous chargez provient-il de quelque chose qui est livré avec Delphi, ou l'avez-vous écrit vous-même? Si ce dernier point, je pense que vous auriez besoin de compter sa longueur dans votre score.
— Ilmari Karonen
@Ilmari, je suis sûr que Delphi n'est pas livré avec un fichier avec l'art ASCII "Hello-World" :) En outre, il est décrit dans la réponse qu'il utilise des ressources externes.
— TLama
3
@TLama: Je pensais que j'essayais aussi de le formuler poliment. Mon point est que, même si des ressources externes étaient autorisées, ce programme échouerait quand même sur l'ordinateur de quiconque, à l'exception de celui de son auteur (et, en fait, nous n'avons aucune preuve qu'il fonctionne même sur son ordinateur). De plus, je peux battre son score avec le script Perl suivant: do X. Le contenu de la "ressource externe" Xn'est pas spécifié (cela fonctionne pour moi, n'est-ce pas suffisant?), Mais j'ai fourni quelques suggestions possibles ci-dessous ...
— Ilmari Karonen Le
15

Perl 5, 54 octets / 71 caractères ASCII imprimables

Remarque: Ceci est la deuxième version de cette réponse. Pour la version originale à 64 octets / 95 caractères utilisant PHP et gzinflate (), voir l'historique de cette réponse .

Voici la version ASCII imprimable à 71 caractères:

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

La version à 54 octets contient des caractères non imprimables, je la fournis donc sous forme de vidage hexadécimal. Sur les systèmes Unixish, vous pouvez utiliser xxd -rpour reconvertir le vidage hexadécimal en script Perl exécutable:

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                           ...$.'

Les deux doivent être exécutés avec perl -M5.010pour activer la fonctionnalité Perl 5.10+ say. Ils produiront la sortie suivante:

Screenshot of "Hello-World!" ASCII art

(Illustré en tant que capture d'écran, car l'énorme hauteur de ligne sur SE rend l'art ASCII moche et difficile à lire. La minuscule "e" est un peu gênante, mais je crois que cela est lisible, à peine si.)

Ps. Si le résultat de la solution ci-dessus vous semble trop minimaliste, voici une variante à 92 caractères produisant un résultat similaire à la solution de Tomas :

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

Voici une capture d'écran:

Screenshot of "Hello-World!" ASCII art

Pps. Je suis presque sûr que ceci ( GolfScript, 51 caractères ) est la solution imprimable au format ASCII la plus courte, si vous ne comptez pas ceux qui appellent simplement banner / FIGLet ou qui trichent d'une autre manière:

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

Le résultat est le même que pour ma solution Perl à 71 caractères ci-dessus.

— Ilmari Karonen
source
Je dirais que vous venez de franchir la frontière de la lisibilité :-)
— Tomas
1
C'est beaucoup plus lisible dans mon terminal que chez SE, à cause de l'énorme espacement des lignes ici.
— Ilmari Karonen
Je veux dire, c'est illisible de toute façon. BTW je peux produire votre sortie en 92 caractères , sans algorithme de compression externe :-)
— Tomas
@ Tomas: Vous avez raison, la fermeture éclair ne semble pas être la réponse gagnante ici. Je vous donnerais un +1 pour cela si je ne l'avais pas déjà fait. BTW, je peux le faire en 71 caractères; voir au dessus. :-)
— Ilmari Karonen
1
Ilmari, vous n'auriez pas dû me mettre au défi avec unpack:-) Nous avons trouvé une solution de 69 caractères (87 avec la belle sortie de la mienne).
— Tomas
8

Coquille + Figlet (35)

$ figlet -w 90 -f banner Hello-World!
#     #                                   #     #                             ### 
#     # ###### #      #       ####        #  #  #  ####  #####  #      #####  ### 
#     # #      #      #      #    #       #  #  # #    # #    # #      #    # ### 
####### #####  #      #      #    # ##### #  #  # #    # #    # #      #    #  #  
#     # #      #      #      #    #       #  #  # #    # #####  #      #    #     
#     # #      #      #      #    #       #  #  # #    # #   #  #      #    # ### 
#     # ###### ###### ######  ####         ## ##   ####  #    # ###### #####  ###
— sinistre
source
Quel genre de police est-ce? Celles-ci ressemblent à des majuscules.
— Cruncher
sa bannière -f bannerC'est la première police que j'ai trouvée qui utilisait # au lieu de * ou | et _.
— sinistre
— jfs
Si vous modifiez "90" en "9", vous obtiendrez un monde grandiose et étroit, mais comme le PO ne se soucie pas des colonnes ou des rangées, il devrait être acceptable.
— alexyorke
Parfois, les électeurs me déconcertent. Comment se fait-il que cela donne un score net de +8, alors que l’autre réponse donne un score net de -3?
— Digital Trauma
8

Python 260 215 186 152

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

Python 196 183 130 114 (mais laide)

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

J'ai utilisé des données compressées en encodage base64. et le code le décode à partir de l’encodage base64, puis le décompresse.

— Elisée
source
Wow, c'est vraiment une lisibilité qui s'étend!
7

PHP - 183 octets

En utilisant l'art ASCII de sebcap26 comme source ...

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 octets

(Je sais. Mais pour être complet, il doit y avoir un brainfuck ^^ Cela ne va pas être beaucoup plus court, car il y a peu de répétitions. La première et la deuxième boucle sont déjà en boucle ...)

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

Interprète ici: http://koti.mbnet.fi/villes/php/bf.php

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

En combinant le générateur de nombres et l'image de @ ASKASK avec mes boucles et quelques réglages supplémentaires, nous obtenons:

Brainfuck, 343 339 336 334 octets

Ça a l'air plus laid que ma version originale.

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

(image voir la réponse de @ ASKASK)

— Johannes H.
source
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')

Sortie:

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

Explication:

Le texte ASCII est compacté en une chaîne où chaque bit représente un pixel :

  • 0 pour SPACE
  • 1 pour #

Un décalage de 33 est appliqué afin d'obtenir uniquement des caractères imprimables.

— Florent
source
Les crochets et les returninstructions de la première grosse flèche ne sont pas nécessaires.
— manatwork
@manatwork J'ai essayé de l'enlever mais ce n'était plus la compilation. Êtes-vous sûr de cela?
— Florent
1
— manatwork
@manatwork Merci!
— Florent
charCodeAt(0)peut être réduit à charCodeAt().
— Chiru
4

Sclipting , 38 caractères (76 octets)

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

Sortie:

# # ## #  #   #     #   #  #  ##  #  ##  #
# # #  #  #  # #    #   # # # # # #  # # #
### ## #  #  # # ## # # # # # ##  #  # # #
# # #  #  #  # #    # # # # # # # #  # #  
# # ## ## ##  #      # #   #  # # ## ##  #
— Timwi
source
4
La page d'informations code-golf indique "Si vous utilisez Unicode, le nombre d'octets doit utiliser UTF-8." Si je ne me trompe pas, cela fait 114 octets de longueur de programme . (Les 76 octets que vous mentionnez seraient pour UTF-16 sans nomenclature.)
— res
@res: J'ai changé cela, car cela n'a aucun sens d'exiger cela. Mon interprète Sclipting comprend très bien UTF-16; il s'agit donc d'un programme valide codé au format UTF-16.
— Timwi
1
Timwi, l'affaire est importante
— Tomas le
3
@ user689 - en fait "Hello-World!" avec un point d'exclamation à la fin ...
1
Je suppose que "accepté par la communauté" signifie "accepté, sans discussion de la communauté , par un petit nombre de personnes ayant le pouvoir de le faire".
— res
3

Brainfuck, 362 octets

Désolé @ johannes-h, j'ai vu le vôtre et j'ai été inspiré pour créer le mien. Il utilise une combinaison de génération de chiffres plus rapide au début et d'une image plus simple pour générer le résultat en moins d'octets. Cependant, il n'utilise pas de boucles ailleurs, il est donc temps d'optimiser.

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

qui génère:

pic

— ASKASK
source
Hm. Combien de temps est la génération de nombre? Parce que changer l'image ressemble à de la triche pour moi (du moins en comparant directement nos solutions - parfaitement valable dans ce concours bien sûr) ^^ Mais je vais regarder la tienne plus tard :) Tu peux prendre ma boucle pour la première fois deux lignes cependant. C'est beaucoup plus court (environ 10 à 20 octets si je me souviens bien)
— Johannes H.
votre version est passée à 343 octets, voir ma réponse
— Johannes H.
et même plus courte, remplaçant plus de répétitions par des boucles. 339 maintenant.
— Johannes H.
Je n'ai pas la réputation de commenter la vôtre, mais si vous regardez de près votre nouvelle version, vous trouverez un "> <" qui peut être supprimé pour supprimer deux octets :)
— ASKASK
3

ImageMagick + sed, 71 octets

Je ne vois aucune autre entrée dans ImageMagick, alors voici ma mise tardive dans le sol:

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

Je pense que la sedpartie peut probablement être jouée au golf un peu plus.

Essayez-le en ligne .

Sortie:

  # # # # # # # # # #     
  # # # # # ## ## # #     
  # # # # # ### # # # #     
  # # #### # # #### # # # # # #### # # # ### # #     
  ###### # # # # ## ## ## # # # ## ## ## # ## ## #     
  # # ###### # # # # # ### # # # # # # # # # #     
  # # # # # # # ## ## # # # # # # #     
  # # ## ## # # ## ## ## ## ## ## ## # ## ##        
  # # #### # # #### ## ## #### # # ### # #
— Trauma numérique
source
2

Postscript, 154 133

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

c'est à dire 

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

La source de ASCII était l'inspiration pour ASCII-art, telle était la réponse de Johannes H. :-)

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

(plus lisible en terminal)

Perl, 102

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

Même résultat que ci-dessus. Je sais que j'ai perdu aux deux réponses Perl ci-dessus, mais je la publie quand même. Au moins, j'ai essayé et j'allais dans la bonne direction (et je n'avais pas vu la réponse la plus courte) :-).

— utilisateur2846289
source
2

Pure Bash, aucun utilitaire externe - 133 caractères:

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

Utilise shift droit (divise et multiplie par 2) et xor pour trouver les 1 bits.

Données de police volées à Blender / Ilmari Karonen.

Testé dans Bash 3.2 et 4.2

Au fait, ce ne sont que 166 caractères:

echo "# #  #  # #        #   #        #   # #
# # # # # #  #     # # #  #   # #  ## #
### #   # # # # ## # # # # # #  # # #  
# #  ## # #  #      # #   #  #  #  ## #"
— En pause jusqu'à nouvel ordre.
source
1

Python 3, 114

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

Sortie (4 caractères de hauteur e et W volés à @Ilmari Karonen ):

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

Et un plus court (107):

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

Sortie:

# # ### #   #   ###   # # ### ##  #   ##   #
### ### #   #   # #   # # # # ### #   # #  #
# # ### ### ### ###   ### ### # # ### ##   #
— Mixeur
source
C'est surtout illisible. Votre monde à partir de la 2ème sortie est en réalité Uorld.
— Silviu Burcea
@ SilviuBurcea: Il a l'air mieux sur un émulateur de terminal réel. En outre, "lisible par l'homme" vous donne un peu de marge de manœuvre. Je suis sûr que vous pouvez deviner ce que "HELLO ⊔ORLD!" veux dire.
— Blender
Use hex constants and shave a few characters off
— Floris
@Floris: I tried that. The two-character prefix makes them just as long up until around 20 digits.
— Blender
1

Python 154 Characters, (Char 5X7 in size)

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

Output

#   #      # #         #   #   #         #     # #
#   #      # #         #  # #  #         #     # #
#   #  ##  # #  ##      # # # #   ##  ## #   ### #
##### #  # # # #  #     # # # #  #  # #  #  #  # #
#   # #### # # #  # ##  # # # #  #  # #  #  #  # #
#   # #    # # #  #     # # # #  #  # #  #  #  #  
#   #  ### # #  ##       #   #    ##  #  #   ### #
— Abhijit
source
1

Bash:

(103 89 Bytes)

Code:

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

Output:

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

Smaller, but less readable (Based on http://mckgyver.pbworks.com/f/1240440791/3PixelFont.jpg):

Code:

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

Output:

 # # ### #  #  ###    #   # ### ##  #  ##  #
 ### ##  #  #  # # ## # # # # # ##  #  # # #
 # # ### ## ## ###     # #  ### # # ## ##  #
— christofsteel
source
1

Javascript / ES6 (108 bytes)

Copy into console:

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

Output:

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

(Needs ECMAScript6 compatible browser ie. Firefox 22+)

Inspired by @maximeeuziere, @p01, @aemkei

— Musterknabe
source
.join('\n') can be reduced to .join(` `) where the space is an actual new line character.
— Chiru
1

Authors: xem, aemkei, p01, jonas

Execute this in the JS console.

JavaScript, cross-browser,133 132 126 117 bytes

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

JavaScript, ES6, works on Firefox, 108 bytes

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

Result:

>
# #     # #       # #        #   # #
### ### # # ###   # # ### ## # ### #
# # ##  # # # # # ### # # #  # # #  
# # ### # # ###   # # ### #  # ### #
— xem
source
@p01 made a shorter version (118 bytes) here: twitter.com/p01/status/433230019419471872
— aemkei
1

HTML, 209 characters

<pre># #     # #                      #   # #
# #     # #        # # #         #   # #
###  ## # #  #     # # #  #  ##  #  ## #
# # ##  # # # # ## # # # # # # # # # #
# # ### # #  #      # #   #  #   # ### #</pre>
Expand snippet

Does this count? :)

— Florrie
source
1

Shell, 20 characters:

banner Hello-world\!

For this to work, of course you need the banner program. On Debian, you can get it by installing the bsdmainutils package.

This prints a beautifully rendered version of your message, designed to be printed on one of the old continuous-feed printers, so the output of the above text is 322 lines long by 123 columns wide, and you turn the printout on its side to read the message. You could hang the resulting paper on the wall as a banner, hence the name.

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

EDIT: Looks like Debian also has the sysvbanner package, which installs a banner program that prints the text horizontally for display on a terminal. However, this only prints the first 10 characters of the message, so it is kind of annoying for this code-golf problem!

— steveha
source
1
I believe you meant to write banner hello-world.
— Floris
@Floris, thanks for the heads-up. Fixed.
— steveha
1
Note that banner appeared on Unix v7 in 1979 and is found on virtually every Unix.
— sch
@sch, I agree that banner is available for virtually every UNIX. I just put the Debian package as a convenient proof that I wasn't just making something up, for people who didn't know about it. These days I wouldn't expect to find banner installed by default on a UNIX, any more than I would expect to find a continuous-feed printer in a computer lab anymore. But any code golf on making banner text really ought to have the banner program in it somewhere. It's part of our rich cultural history as computer geeks. :-)
— steveha
1

bash, 175 170 bytes

You need to waste quite a few characters in order to produce a pretty output!

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

Output:

#     #                                         #     #                                   ###
#     #  ######  #       #        ####          #  #  #   ####   #####   #       #####    ###
#     #  #       #       #       #    #         #  #  #  #    #  #    #  #       #    #   ###
#######  #####   #       #       #    #  #####  #  #  #  #    #  #    #  #       #    #    #
#     #  #       #       #       #    #         #  #  #  #    #  #####   #       #    #
#     #  #       #       #       #    #         #  #  #  #    #  #   #   #       #    #   ###
#     #  ######  ######  ######   ####           ## ##    ####   #    #  ######  #####    ###
— devnull
source
You can make it smaller with lzma/unlzma
— Emmanuel
0

F# - 204 characters

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))

Output:

# #     # #        # #         #   # #
# #  #  # #  #     # #  #   ## #   # #
### # # # # # #    # # # # #   #  ## #
# # ### # # # # ## # # # # #   # # # #
# # #   # # # #    ### # # #   # # #  
# #  ## # #  #     # #  #  #   #  ## #
— mattnewport
source
0

Python + pyfiglet -- 87 characters

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

Output

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

To install pyfiglet, run:

$ pip install pyfiglet
— jfs
source
0

Python with pyfiglet: 66 using argv, 69 without

66:

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

69:

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

firs must be called as, for example:

python asciiart.py 'Hello-World!'

second:

python asciiart.py.

Output:

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

(Well, it looks kinda crappy with this font. Nevertheless :) )

[edit] removed obsolete dash from the argument.

— Taku
source
Why the extra dash in front of the output?
— Ilmari Karonen
My mistake, that's the output from the one using argv, where I used a dash before the argument (matter of habit, as I use bash all the time). I'll edit it, thank you.
— Taku
0

Javascript 137 (134)

Uses the bits of integers to represent sharps an white spaces. Tested with Firefox 27.

137 character

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 character (rotated 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
source
0

Python3 (126)

There's an additional space between the chars to make it better readable. So technically it's a 125 character solution.

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

Output:

#   #   # #   #     #     # # #     #   #   #   # # #   # # #   #     # #     # 
#   #   #     #     #     #   #     #   #   #   #   #   #   #   #     #   #   # 
# # #   # #   #     #     #   #     #   #   #   #   #   # #     #     #   #   # 
#   #   #     #     #     #   #     #   #   #   #   #   #   #   #     #   #     
#   #   # #   # #   # #   # # #     # # # # #   # # #   #   #   # #   # #     #
— schwer
source
0

Bash 37, 33

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

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

Which is the same as:

echo "Hello-world" | toilet

From man toilet

TOIlet - display large colourful character

With tr "'\"m" "#" all " chars are replaced with #.

— fedorqui
source
tr's parameters would be shorter escaped than quoted. I mean tr \'\"m \# instead of tr "'\"m" "#".
— manatwork
Oh good one, I wasn't aware of that. Thanks @manatwork
— fedorqui
Wait a second. The toilet output had no single quote. Why you included it in tr's 1st parameter? Just tr \"m \# is enough.
— manatwork
@manatwork I think I need more coffee :)
— fedorqui
0

Smalltalk, 151

although this golf game is already over, for the reference:

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]

output:

 ***  ***             ***       ***                                                         ***           **       
  *    *                *         *                                                           *            *       
  *    *                *         *                                                           *            *       
  *    *     ***        *         *        ***              ***   ***    ***     *** ***      *        *** *       
  ******    *   *       *         *       *   *              *     *    *   *      **   *     *       *   **       
  *    *   *     *      *         *      *     *             *  *  *   *     *     *          *      *     *       
  *    *   *******      *         *      *     *              * * *    *     *     *          *      *     *       
  *    *   *            *         *      *     *              * * *    *     *     *          *      *     *       
  *    *    *    *      *         *       *   *               ** **     *   *      *          *       *   **       
 ***  ***    ****    *******   *******     ***                *   *      ***     ******    *******     *** **
— blabla999
source
You have to only use ' '(spaces) and '#' characters(also newline characters).
— Mukul Kumar
my mistake; the output was from a previous run; the code is correct "{$#.$ }at:p+1".
— blabla999
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.