Golf ASCII-art

31

Essayons de jouer au golf cette œuvre d'art ascii représentant un golfeur:

      '\. . |> 18 >>
        \. '. |
       O >>. «o |
        \. |
        / \. |
       / /. » |
 jgs ^^^^^^^ `^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^

Source: JGS - http://www.retrojunkie.com/asciiart/sports/golf.htm

Règles:

  • Aucune entrée autorisée
  • Aucune ressource externe autorisée
  • La sortie doit être exactement ce texte, affiché dans une police à espacement fixe (console OS, console JS, balise HTML <pre>, ...), y compris le saut de ligne de début et de fin.
  • Les guillemets environnants ou les guillemets doubles sont autorisés (la console JS ajoute des guillemets doubles lorsque vous affichez une chaîne, c'est correct)

La meilleure réponse sera celle qui utilise le moins de caractères dans n'importe quelle langue.

S'amuser!

code-golf ascii-art kolmogorov-complexity xem
la source
2
"exactement ce texte": y compris la ligne vide au début? y compris la ligne vide à la fin? avec une nouvelle ligne de fuite ou sans? (Autrement dit, 0, 1 ou 2 nouvelles lignes à la fin?)
Martin Ender
@ m.buettner, la sortie doit avoir exactement un saut de ligne de tête et un saut de ligne de fin / nouvelle ligne. (et citations si vous ne pouvez pas les éviter) :)
xem
1
Cet ASCII ressemble plus à un tir de cricket pour moi
M. Alien
@ Mr.Alien Je l'ai vu dans la récente conférence de Martin Kleppe: speakerdeck.com/aemkei/… (vidéo: youtube.com/watch?v=zy-2ruMHdbU )
xem

Réponses:

14

CJam, 62 caractères

"Ⴀ지尦렒>Ä΀ྀ㸀⡅쇋蒧ʸ鿀ʃ케袧Ƽ蟀ʄ導뤷쀂萯Ű⋥ἀ਎밊耧台 ⢙⿶ꝍ㕟劢햟騤꩏脽啎"2G#b128b:c~

Essayez-le en ligne.

Essai

$ base64 -d > golf.cjam <<< IgHhgqDsp4DlsKbroJLujJ8+w4TOgOC+gOO4gOKhheyHi+iSp8q46b+AyoPsvIDvoIPuhKvooqfGvOifgMqE5bCO66S37ICC6JCvxbDii6XhvIDgqI7rsIrvgYvogKflj7DCoOKimeK/tuqdjeOVn+WKou2Wn+mopO+em+qpj+iEve6arOWVjiIyRyNiMTI4Yjpjfg==
$ wc -m golf.cjam
62 golf.cjam
$ cjam golf.cjam

      '\                   .  .                        |>18>>
        \              .         ' .                   |
       O>>         .                 'o                |
        \       .                                      |
        /\    .                                        |
       / /  .'                                         |
 jgs^^^^^^^`^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
$

Comment ça marche

2G#b convertit la chaîne précédente en entier en la considérant comme un nombre de base-65536.

128b:creconvertit cet entier en une chaîne ( 110 octets ) en le considérant comme un nombre en base 128, qui ~exécute ensuite:

"
^F'^@\^S.^B.^X|^@>^@1^@8^@>^@>^@
^H\^N.^I'^A.^S|^@
^GO^@>^@>^I.^Q'^@o^P|^@
^H\^G.&|^@
^H/^@\^D.(|^@
^G/^A/^B.^@')|^@
^A"2/{)iS*}%"jgs"'^7*'`'^51*N

(notation caret)

2/{)iS*}%

divise la chaîne en paires de deux caractères et effectue les opérations suivantes pour chaque paire: Pop le deuxième caractère de la chaîne, convertissez-le en entier et répétez la chaîne " "autant de fois.

Par exemple, ".("devient ". ", car le code de caractère ASCII de (est 40.

Finalement,

"jgs"'^7*'`'^51*N

pousse la chaîne "jgs", le caractère ^répété 7 fois, le caractère `, le caractère ^répété 51 fois et un saut de ligne.

Dennis
la source
1
Vraiment génial, mais quand je prends la version 62char dans le pastebin et "l'essaye en ligne", un saut de ligne manque avant la dernière ligne "jgs ..."
xem
@xem: Avez-vous copié à partir de la section RAW Paste Data ? Si je copie le code formaté, j'obtiens le même résultat.
Dennis
15

Rubis, 107

Je pensais que j'essaierais réellement de "générer" l'image en code (au lieu d'utiliser une fonction de compression existante):

S=?\s*351+?^*60
"⠀鰇𗀈렜렟🀸쐺⠾𗁇롖鱠롢🁶⡷𓱿뢋鲝𛲞🂯⢰𗂹룁🃨⣩볲𗃳룸🄡⤢봪봬뤯鴰🅚⥛𚥝𙵞𜵟𘅧".chars{|q|S[511&r=q.ord]=(r>>10).chr}
puts S

Il y a des caractères non imprimables dans ce littéral de tableau.

Voici la vue hexadécimale du fichier, pour montrer également les caractères non imprimables:

0000000: 533d 3f5c 732a 3335 312b 3f5e 2a36 300a  S=?\s*351+?^*60.
0000010: 22e2 a080 e9b0 87f0 9780 88eb a09c eba0  "...............
0000020: 9ff0 9f80 b8ef a0b9 ec90 baee 80bb efa0  ................
0000030: bcef a0bd e2a0 bef0 9781 87eb a196 e9b1  ................
0000040: a0eb a1a2 f09f 81b6 e2a1 b7f0 93b1 bfef  ................
0000050: a280 efa2 81eb a28b e9b2 9df0 9bb2 9ef0  ................
0000060: 9f82 afe2 a2b0 f097 82b9 eba3 81f0 9f83  ................
0000070: a8e2 a3a9 ebb3 b2f0 9783 b3eb a3b8 f09f  ................
0000080: 84a1 e2a4 a2eb b4aa ebb4 aceb a4af e9b4  ................
0000090: b0f0 9f85 9ae2 a59b f09a a59d f099 b59e  ................
00000a0: f09c b59f f098 85a7 222e 6368 6172 737b  ........".chars{
00000b0: 7c71 7c53 5b35 3131 2672 3d71 2e6f 7264  |q|S[511&r=q.ord
00000c0: 5d3d 2872 3e3e 3130 292e 6368 727d 0a70  ]=(r>>10).chr}.p
00000d0: 7574 7320 53                             uts S

Merci à Ventero pour quelques améliorations majeures! (Il a essentiellement réduit le code de 50%.)

Martin Ender
la source
Bel effort! J'espérais des réponses comme ça, qui ne font pas que gzip l'ASCII;)
xem
1
La deuxième ligne pourrait consister 6.times{|i|S[i+1]=' '*55+?|}à enregistrer 2 caractères.
afuous
@voidpigeon Ah merci. En fait, j'ai commencé avec ça, mais j'ai d'abord pensé que j'aurais besoin de iplus d'une fois. Bonne prise!
Martin Ender
2
J'espère que cela ne vous dérange pas si je mentionne quelques autres façons de raccourcir cela! L' utilisation S.fill{' '*55+?|}permet d' économiser à la place quelques caractères (vous devrez définir Scomme ['']*7, changer putspour puts p,S,pet soustraire 1 de toutes vos coordonnées y cependant). Ensuite, en utilisant varargs dans f ( def f(*p,c)), vous pouvez enregistrer le []dans les appels de fonction. Oh, et vous pouvez laisser tomber le ()autour y,x.
Ventero
1
Si vous faites S unidimensionnel, vous pouvez enregistrer 55 autres caractères;) Voici le code si vous ne voulez pas le faire vous-même.
Ventero
13

bash + iconv + code machine DosBox / x86 (104 97 96 95 caractères)

echo ↾각슈삨੽₲ɻ庲錿ʴ⇍罋곹삄ૃ蘊尧⺓⺂粘ㄾ㸸ਾ岈⺎➉⸠粓蜊㹏褾鄮漧粐蠊蝜꘮੼⾈葜꠮੼⾇⼠⺂ꤧ੼樠獧惇૳|iconv -futf8 -tucs2>o.com;dosbox o*

Je suggère de mettre cela dans un script dans un répertoire vide, il est presque garanti que le copier-coller dans un terminal va tout casser; encore mieux, vous pouvez récupérer le script ici tout prêt.

Production attendue: production attendue

Comment ça marche

La partie bash est juste un lanceur qui utilise iconvpour "décompresser" un .comfichier à partir des caractères UTF-8 du script et le lance avec DosBox.

Notez que cela pose une certaine limitation sur le contenu, car toutes les séquences d'entrée ne peuvent pas être interprétées comme UCS-2 sans iconvse plaindre; par exemple, pour une raison quelconque, de nombreuses opérations impliquant le bxregistre ont fait des ravages en fonction de l'endroit où je les ai utilisées, j'ai donc dû contourner ce problème plusieurs fois.

Maintenant, la chose Unicode est juste de profiter des règles de "nombre de caractères"; la taille réelle (en octets) du script est bien plus grande que le .COMfichier d' origine .

Le .comfichier extrait est

00000000  be 21 01 ac 88 c2 a8 c0  7d 0a b2 20 7b 02 b2 5e  |.!......}.. {..^|
00000010  83 e0 3f 93 b4 02 cd 21  4b 7f f9 ac 84 c0 75 e4  |..?....!K.....u.|
00000020  c3 0a 0a 86 27 5c 93 2e  82 2e 98 7c 3e 31 38 3e  |....'\.....|>18>|
00000030  3e 0a 88 5c 8e 2e 89 27  20 2e 93 7c 0a 87 4f 3e  |>..\...' ..|..O>|
00000040  3e 89 2e 91 27 6f 90 7c  0a 88 5c 87 2e a6 7c 0a  |>...'o.|..\...|.|
00000050  88 2f 5c 84 2e a8 7c 0a  87 2f 20 2f 82 2e 27 a9  |./\...|../ /..'.|
00000060  7c 0a 20 6a 67 73 c7 60  f3 0a 0a 00              ||. jgs.`....|
0000006c

et est de 108 octets de long. La source NASM pour cela est:

    org 100h

start:
    ; si: pointer to current position in data
    mov si,data
    ; load the character in al
    lodsb
mainloop:
    ; bx: repetition count
    ; - zero at startup
    ; - -1 after each RLE run
    ; - one less than each iteration after each "literal" run
    ; the constant decrement is not really a problem, as print
    ; always does at least one print, and there aren't enough
    ; consecutive literal values to have wraparound

    ; if the high bit is not set, we have a "literal" byte;
    ; we prepare it in dl just in case
    mov dl,al
    ; then check if it's not set and branch straight to print
    ; notice that bx=0 is fine, as print prints always at least one character
    ; test the top two bits (we need the 6th bit below)
    test al,0xc0
    ; to see if the top bit was set, we interpret it as the sign bit,
    ; and branch if the number is positive or zero (top bit not set)
    jge print
rle:
    ; it wasn't a literal, but a caret/space with a repetition count
    ; space if 6th bit not set, caret otherwise
    mov dl,' '
    ; exploit the parity bit to see if the 6th bit was set
    jnp nocaret
    mov dl,'^'
nocaret:
    ; lower 6 bits: repetition count
    ; and away the top bits and move in bx
    ; we and ax and not al because we have to get rid of the 02h in ah
    and ax,3fh
    xchg ax,bx
print:
    ; print bx times
    mov ah,2
    int 21h
    dec bx
    jg print
    ; read next character
    lodsb
    test al,al
    ; rinse & repeat unless we got a zero
    jnz mainloop
end:
    ret
data:
    ; here be data
    incbin "compressed.dat"
    ; NUL terminator
    db 0

Tout cela n'est qu'un décompresseur compressed.datdont le format est le suivant:

  • si le bit haut n'est pas défini, imprimez le caractère tel quel;
  • sinon, les 6 bits les plus faibles représentent le nombre de répétitions et le deuxième bit le plus élevé spécifie s'il doit imprimer un espace (bit non défini) ou un caret (bit défini).

compressed.datà son tour est généré à l'aide d'un script Python à partir du texte d'origine.

Le tout se trouve ici .

Matteo Italia
la source
10

Python, 156

print'''
%6s'\%19s.  .%24s|>18>>
%8s\%14s.%9s' .%19s|
%7sO>>%9s.%17s'o%16s|
%8s\%7s.%38s|
%8s/\%4s.%40s|
%7s/ /  .'%41s|
 jgs'''%(('',)*19)+'^'*7+'`'+'^'*51

Cela utilise un formatage de chaîne avec un espace pour une compression de base.

grc
la source
7

PHP, 147

Cela s'exécute sur la ligne de commande et sort directement sur la console:

php -r 'echo gzinflate(base64_decode("41IAA/UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA"));'
ossifrage délirant
la source
6

Perl - 127 129 130 132 135 137 145

print q(
6'\19.2.24|>18>>
8\14.9'1.19|
7O>>9.17'o16|
8\7.38|
8/\4.40|
7/1/2.'41|
1jgs^^^^^^^`0
)=~s/\d++(?!>)/$"x$&||'^'x51/reg

Merci à Ventero et m.buettner pour leur aide dans mon optimisation RegEx.

core1024
la source
Vous pouvez enregistrer un personnage avecs/\d+(?!8?>)/%$&s/rg
Ventero
@Ventero merci pour la suggestion.
core1024
2
Vous pouvez en enregistrer un autre en utilisant un quantificateur possessif :/\d++(?!>)/
Martin Ender
@ m.buettner Je ne le savais pas. Apprendre de nouvelles choses tous les jours :)
core1024
4

GCC C - 203 octets

J'ai pensé que je m'amuserais avec celui-ci. Cela compile sur ma version de MinGW et génère le texte attendu.

Espace ajouté pour plus de clarté.

char*v="\n ú'\\ í.  . è|>18>>\n ø\\ ò. ÷' . í|\n ùO>> ÷. ï'o ð|\n ø\\ ù. Ú|\n ø/\\ ü. Ø|\n ù/ /  .' ×|\n jgs^ù`^Í\n";
main(g,o,l){
    for(;*v;
        g=!g&*v<0&l?-*v++:g){
        v+=!(l=*v-35);
        putchar((g-=g>0)?o:(o=*v++));
    }
}

Aucun des sites de collage de code en ligne ne permet l'utilisation de caractères à un octet en dehors de la plage ASCII, j'ai donc dû les échapper pour un exemple téléchargé. C'est par ailleurs identique cependant. http://codepad.org/nQrxTBlX

Vous pouvez également le vérifier avec votre propre compilateur.

Kaslai
la source
4

LOLCODE, 590 caractères

Cuz LOLCODE iz perfik language 4 golfin: iz easy 2 compres un obfuscate an it isnt verbose du tout.

HAI
HOW DUZ I D C T
I HAZ A O
I HAZ A N ITZ 0
IM IN YR LOOP UPPIN YR N TIL BOTH SAEM N AN T
O R SMOOSH O AN C MKAY
IM OUTTA YR LOOP
FOUND YR O
IF U SAY SO
VISIBLE ""
VISIBLE SMOOSH "  '\" AN D " " 19 AN ".  ." AN D " " 24 AN "|>18>>" MKAY
VISIBLE "    \              .         ' .                   |"
VISIBLE "   O>>         .                 'o                |"
VISIBLE SMOOSH "    \       ." AN D " " 38 AN "|" MKAY
VISIBLE SMOOSH "    /\    ." AN  D " " 40 AN "|" MKAY
VISIBLE SMOOSH "   / /  .'" AN D " " 41 AN "|" MKAY
VISIBLE SMOOSH "jgs^^^^^^^`" AN D "^" 51 MKAY
VISIBLE ""
KTHXBYE

Im pritee sure dis werkz, mais je doan a un interpréteur LOLCODE et http://repl.it ne semble pas 2 funcshuns liek.

(Tranzlashun généreusement fourni par les robots de http://speaklolcat.com cuz I doan speek lolcat)

Version en retrait, espacée et commentée du code (les commentaires LOLCODE commencent par BTW):

HAI BTW All LOLCODE programs start with HAI
    HOW DUZ I D C T BTW Function declarations follow the form "HOW DUZ I <func-name>[ <func-arg1>[ <func arg2>[ ...]]]". In this case, D is a function that repeats a YARN C (YARN is the equivalent of string in LOLCODE) NUMBR T (NUMBR = int) times.
        I HAZ A O BTW Variable declarations follow the form "I HAZ A <var-name>"

        I HAZ A N ITZ 0 BTW Variables can be intialised when declared by appending " ITZ <init-value>" to the declaration 
        IM IN YR LOOP UPPIN YR N TIL BOTH SAEM N AN T BTW Loops follow the form "IM IN YR LOOP <action> TIL <condition>" where action and condition are "UPPIN YR N" and "BOTH SAEM N AN T", respectively, in this case
            O R SMOOSH O AN C MKAY BTW "R" assigns a new value to a variable. YARN (string) concatenation follows the form "SMOOSH <str-1> AN <str-2>[ AN <str-3>[...]] MKAY"
        IM OUTTA YR LOOP BTW "IM OUTTA YR LOOP" ends LOLCODE loops

        FOUND YR O BTW "FOUND YR <value>" returns a value
    IF U SAY SO BTW "IF U SAY SO" ends functions

    VISIBLE "" BTW "VISIBLE" prints its argument to stdout
    VISIBLE SMOOSH "  '\" AN D " " 19 AN ".  ." AN D " " 24 AN "|>18>>" MKAY BTW The function I wrote above only "pays off" in terms of characters added/saved when repeating 19 or more characters (the function call itself takes 8 characters, assuming a one-character first argument and a 2-digit second one; you need to factor in the added quotes (2 characters), spaces (4) and ANs (4) for 18 total extra characters; and possible SMOOSH/MKAY)
    VISIBLE "    \              .         ' .                   |"
    VISIBLE "   O>>         .                 'o                |"
    VISIBLE SMOOSH "    \       ." AN D " " 38 AN "|" MKAY
    VISIBLE SMOOSH "    /\    ." AN  D " " 40 AN "|" MKAY
    VISIBLE SMOOSH "   / /  .'" AN D " " 41 AN "|" MKAY
    VISIBLE SMOOSH "jgs^^^^^^^`" AN D "^" 51 MKAY
    VISIBLE ""    
KTHXBYE BTW "KTHXSBYE" ends LOLCODE programs
wec
la source
haha, belle compression, comme ça: D
Joshua
3

Python - 205 203 197

i="""
G^y`G^MsGgGj!G
G|!o'G.!H/!G/!M
G|!n.!J\G/!N
G|!l.!M\!N
G|!VoG'!W.!O>HO!M
G|!Y.!G'!O.!T\!N
G>H8G1G>G|!^.!H.!Y\G'!L
G""".replace('!','G ')
o=''
j=140
while j:j-=2;o+=ord(i[j+1])%70*i[j]
print o

La chaîne ientrelace les personnages de l'art ascii avec leurs multiplicites, représentés comme des personnages, le tout dans l'ordre inverse. De plus, j'économise un peu d'espace en utilisant '!' au lieu de «G» iet ensuite juste le remplacer.

Alex L
la source
3

Python (145)

'eJzjUgAB9RgFTKAHRthBjZ2hhZ0dF5SHphuhSx2rCTVQff52dlj0wPXm49IHtw+n83Do048hQRdCnz4QKuipE6sNqC8rvTgOAhLiSAdcAG/9Ri8='.decode('base64').decode('zip')

Pas très original, je sais.

ıʇǝɥʇuʎs
la source
2

Javascript ( ES6 ) 193 175 octets

Edit: Modified RegPack v3 pour maintenir les sauts de ligne, utilisez une for inboucle pour enregistrer 3 octets et supprimez eval pour la sortie de console implicite.

_="\nx'\\w{. z~|>18>>\n~\\~x.~ 'z{yx O>>~z 'owy~\\xzwxy~/\\{zw~yx / /  .'ww~ y jgs}`}}}}}}}^^\n~x  }^^^^^^^{   z .wy|\nx{{w~~";for(i of "wxyz{}~")with(_.split(i))_=join(pop())

Utilisation de la compression unicode de xem: 133 caractères

eval(unescape(escape('𧰽𘡜𫡸𙱜𧁷𮰮𘁺嵃🠱𞀾🡜𫡾𧁜屮𛡾𘀧𮡻𮑸𘁏🠾岍𘀧𫱷𮑾𧁜𮁺𭱸𮑾𛱜𧁻𮡷峀𮀠𛰠𛰠𘀮𙱷𭱾𘁹𘁪𩱳𯑠𯑽𯑽𯑽𯑞𧡜𫡾𮀠𘁽𧡞𧡞𧡞𧡻𘀠𘁺𘀮𭱹𯁜𫡸𮱻𭱾割𞱦𫱲𚁩𘁯𩠠𘡷𮁹𮡻𯑾𘠩𭱩𭁨𚁟𛡳𬁬𪑴𚁩𚐩𧰽𪡯𪑮𚁰𫱰𚀩𚐠').replace(/uD./g,'')))
Nderscore
la source
génial! <3 le post-traitement du RegPack! psst, vous pouvez le faire en 143b: xem.github.io/obfuscatweet
xem
@xem 143 caractères, mais beaucoup plus d'octets
nderscore
oui désolé, 143 caractères. la question dit que vous pouvez compter les caractères. de toute façon, l'approche du regpack est plus intéressante que l'obscurcissement unicode;)
xem
2
FWIW, mothereff.in/byte-counter est un outil qui compte à la fois des caractères et des octets (selon UTF-8).
Mathias Bynens
2

ES6, 155 caractères

J'essaye juste une autre approche:

Exécutez cela dans la console JS de Firefox.

Chaque caractère unicode a la forme suivante: \ uD8 [ascii charcode] \ uDC [nombre de répétitions].

"𒠁𘀆𙰁𧀁𘀓𛠁𘀂𛠁𘀘𯀁🠁𜐁𞀁🠂𒠁𘀈𧀁𘀎𛠁𘀉𙰁𘀁𛠁𘀓𯀁𒠁𘀇𣰁🠂𘀉𛠁𘀑𙰁𫰁𘀐𯀁𒠁𘀈𧀁𘀇𛠁𘀦𯀁𒠁𘀈𛰁𧀁𘀄𛠁𘀨𯀁𒠁𘀇𛰁𘀁𛰁𘀂𛠁𙰁𘀩𯀁𒠁𘀁𪠁𩰁𬰁𧠇𨀁𧠳𒠁".replace(/../g,a=>String.fromCharCode(a[c='charCodeAt']()&255).repeat(a[c](1)&255))

(Chaîne Unicode faite avec: http://jsfiddle.net/LeaS9/ )

xem
la source
-3:.replace(/../g,a=>String.fromCharCode(a[c='charCodeAt']()&255).repeat(a[c](1)&255))
nderscore
oh, super, merci!
xem
2

PHP

Méthode 1, plus simple (139 octets):

Utilisation d'une chaîne pré-dégonflée.

<?=gzinflate(base64_decode('41IAA/UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmACwA='));?>

Méthode 2, codage des séries d'espaces en lettres de l'alphabet (192 octets):

<?=preg_replace_callback('#[D-NP-Zu]#',function($e){return str_repeat('a'<$e[0]?'^':' ',ord($e[0])-66);},"
H'\U.D.Z|>18>>
J\P.K' .U|
IO>>K.S'oR|
J\I.WS|
J/\F.ZR|
I/ /D.'ZS|
 jgs^^^^^^^`u
")?>
LSerni
la source
2

PowerShell, 192 188 119

 -join('̠§Üঠ®Ġ®ఠü¾±¸ľРÜܠ®Ҡ§ ®ঠüΠÏľҠ®ࢠ§ïࠠüРÜΠ®ጠüР¯ÜȠ®ᐠüΠ¯ ¯Ġ®§ᒠü êçóϞà᧞'[0..70]|%{"$([char]($_%128))"*(+$_-shr7)})

La partie ci-dessus contient quelques non-caractères. Vidage hexadécimal:

00: 002D 006A 006F 0069 │ 006E 0028 0027 008A  -join('
10: 0320 00A7 00DC 09A0 │ 00AE 0120 00AE 0C20  ̠§Üঠ®Ġ®ఠ
20: 00FC 00BE 00B1 00B8 │ 013E 008A 0420 00DC  ü¾±¸ľРÜ
30: 0720 00AE 04A0 00A7 │ 00A0 00AE 09A0 00FC  ܠ®Ҡ§ ®ঠü
40: 008A 03A0 00CF 013E │ 04A0 00AE 08A0 00A7  ΠÏľҠ®ࢠ§
50: 00EF 0820 00FC 008A │ 0420 00DC 03A0 00AE  ïࠠüРÜΠ®
60: 1320 00FC 008A 0420 │ 00AF 00DC 0220 00AE  ጠüР¯ÜȠ®
70: 1420 00FC 008A 03A0 │ 00AF 00A0 00AF 0120  ᐠüΠ¯ ¯Ġ
80: 00AE 00A7 14A0 00FC │ 008A 00A0 00EA 00E7  ®§ᒠü êç
90: 00F3 03DE 00E0 19DE │ 0027 005B 0030 002E  óϞà᧞'[0.
A0: 002E 0037 0030 005D │ 007C 0025 007B 0022  .70]|%{"
B0: 0024 0028 005B 0063 │ 0068 0061 0072 005D  $([char]
C0: 0028 0024 005F 0025 │ 0031 0032 0038 0029  ($_%128)
D0: 0029 0022 002A 0028 │ 002B 0024 005F 002D  )"*(+$_-
E0: 0073 0068 0072 0037 │ 0029 007D 0029       shr7)})

Le schéma de codage est RLE avec la longueur codée au-dessus du 7 bit inférieur, qui est le caractère à afficher.

Joey
la source
1

Python - 236

s=' ';print('\n'+6*s+"'\\"+19*s+'.  .'+24*s+"|>18>>\n"+8*s+'\\'+14*s+'.'+9*s+"' ."+19*s+"|\n       O>>"+9*s+'.'+17*s+"'o"+16*s+'|\n'+8*s+"\\       ."+38*s+'|\n'+8*s+"/\\    ."+40*s+"|\n       / /  ."+42*s+"|\n jgs^^^^^^^`"+51*'^'+'\n')
Ian D. Scott
la source
1

JS (190b) / ES6 (146b) / ES6 emballé (118 chars)

Exécutez ceci dans la console JS:

JS:

"\n7'\\20.3.25|>18>>\n9\\15.10'2.20|\n8O>>10.9 9'o17|\n9\\8.39|\n9/\\5.41|\n8/2/3.'42|\n2jgs^^^^^^^`".replace(/\d+/g,function(a){return 18==a?a:Array(+a).join(' ')})+Array(51).join("^")+"\n"

ES6:

"\n6'\\19.2.24|>0>>\n8\\14.9'1.19|\n7O>>9.17'o16|\n8\\7.38|\n8/\\4.40|\n7/1/2.'41|\n1jgs58`101\n".replace(/\d+/g,a=>' ^'[a>51|0].repeat(a%51)||18)

Pack ES6: ( http://xem.github.io/obfuscatweet/ )

eval(unescape(escape('𘡜𫠶𙱜𧀱𞐮𜠮𜠴𯀾𜀾🡜𫠸𧁜𜐴𛠹𙰱𛠱𞑼𧁮𝱏🠾𞐮𜐷𙱯𜐶𯁜𫠸𧁜𝰮𜰸𯁜𫠸𛱜𧀴𛠴𜁼𧁮𝰯𜐯𜠮𙰴𜑼𧁮𜑪𩱳𝐸𨀱𜀱𧁮𘠮𬡥𬁬𨑣𩐨𛱜𩀫𛱧𛁡🐾𙰠𧠧𦱡🠵𜑼𜁝𛡲𩑰𩑡𭀨𨐥𝐱𚑼𯀱𞀩').replace(/uD./g,'')))

Merci à @nderscore!

xem
la source
1
ES6 jusqu'à 158: (descend à 124 caractères avec compression Unicode)"\n6'\\19.2.24|>18>>\n8\\14.9'1.19|\n7O>>9.17'o16|\n8\\7.38|\n8/\\4.40|\n7/1/2.'41|\n1jgs^^^^^^^`".replace(/\d+/g,a=>18-a?' '.repeat(a):a)+"^".repeat(50)+"\n"
nderscore
oh, super, je ne savais pas répéter
xem
@nderscore ne soyez pas désolé c'est génial :) mais la dernière ligne semble cassée dans ma console Firefox
xem
146: "\n6'\\19.2.24|>0>>\n8\\14.9'1.19|\n7O>>9.17'o16|\n8\\7.38|\n8/\\4.40|\n7/1/2.'41|\n1jgs58`101\n".replace(/\d+/g,a=>' ^'[a>51|0].repeat(a%51)||18)(stackexchange ajoute des caractères de saut de ligne invisibles après 41 | \ ‌)
nderscore
Merci, j'ai mis à jour la réponse et cela fonctionne. :) J'ai également ajouté une autre réponse 158b, vous aurez peut-être une idée pour l'améliorer!
xem
1

ES6, 163b / 127 caractères

Encore une autre approche, grâce à @nderscore.

Exécutez-le dans la console de Firefox

JS (163b):

"\n'\\..|>18>>\n\\. '.|\nO>>    .'o|\n\\.&|\n/\\.(|\n//.')|\njgs<`h\n".replace(/[^'`Og\n>\\,-8j-|]/g,a=>" ^"[a=a.charCodeAt(),a>53|0].repeat(a%53))

Emballé (127c):

eval(unescape(escape('𘡜𫠆𙱜𧀓𛠂𛠘𯀾𜐸🠾𧁮𒁜𧀎𛠉𙰁𛠓𯁜𫠇𣰾🠉𛠑𙱯𔁼𧁮𒁜𧀇𛠦𯁜𫠈𛱜𧀄𛠨𯁜𫠇𛰁𛰂𛠧𚑼𧁮𐑪𩱳🁠𪁜𫠢𛡲𩑰𫁡𨱥𚀯𦱞𙱠𣱧𧁮🡜𧀬𛐸𪠭𯁝𛱧𛁡🐾𘠠𧠢𦱡👡𛡣𪁡𬡃𫱤𩑁𭀨𚐬𨐾𝐳𯀰𧐮𬡥𬁥𨑴𚁡𙐵𜰩𚐠').replace(/uD./g,'')))
xem
la source
Je suis sûr que @nderscore trouvera une amélioration :)
xem
Je pense que SE casse certains des personnages de cette solution. En utilisant une approche similaire à ce que j'ai fait avec votre autre réponse, cela revient à 163: jsfiddle.net/2Fbxq/3
nderscore
Eh bien, c'est une grande amélioration (et un très beau violon). J'ai mis à jour la réponse.
xem
1

Python, 70 caractères UTF-16

挣摯湩㩧呕ⵆ㘱䕂
print砧RԘꁌ䘇䇘鶍薡ᶝ谗ꚋꄝᵍᆫ〵ﺍ癶㑘㗁ࣔᆷ஧楱返䄡鈛絆吠叐嘧䠟噣煺М쐤ຑꀀ䜮'.decode(稧楬b')

Bien sûr, vous devrez probablement utiliser la version hexadécimale:

23 63 6F 64 69 6E 67 3A 55 54 46 2D 31 36 42 45 0A 00 70 00 72 00 69 00 6E 00 74 00 27 78 9C E3 52 00 03 F5 18 05 4C A0 07 46 D8 41 8D 9D A1 85 9D 1D 17 8C 8B A6 1D A1 4D 1D AB 11 35 30 8D FE 76 76 58 34 C1 35 E7 E3 D4 08 B7 11 A7 0B 71 69 D4 8F 21 41 1B 92 46 7D 20 54 D0 53 27 56 1F 48 63 56 7A 71 1C 04 24 C4 91 0E 00 A0 2E 47 05 00 27 00 2E 00 64 00 65 00 63 00 6F 00 64 00 65 00 28 00 27 7A 6C 69 62 00 27 00 29 00

ou la version base64:

I2NvZGluZzpVVEYtMTZCRQoAcAByAGkAbgB0ACd4nONSAAP1GAVMoAdG2EGNnaGFnR0XjIumHaFNHasRNTCN/nZ2WDTBNefj1Ai3EacLcWnUjyFBG5JGfSBU0FMnVh9IY1Z6cRwEJMSRDgCgLkcFACcALgBkAGUAYwBvAGQAZQAoACd6bGliACcAKQA=

La première "ligne" du programme déclare le codage UTF-16. Le fichier entier est UTF16, mais l'interpréteur Python interprète toujours la ligne de codage en ASCII (c'est le cas #coding:UTF-16BE). Après la nouvelle ligne, le texte UTF-16 commence. Cela revient simplement à l' print'<data>'.decode('zlib')endroit où le texte est une version dégonflée de l'image ASCII cible. Un certain soin a été pris pour s'assurer que le flux n'avait pas de substituts (ce qui ruinerait le décodage).

nneonneo
la source
1
Eh bien, la première ligne m'a fait penser "oh super, quelqu'un a fait du python unicode"
seequ
impressionnant! Pouvez-vous faire la même chose en ~ 35b avec UTF-32? :)
xem
zipau lieu de zlibpeut enregistrer un caractère.
Cees Timmerman
@xem: la plupart des caractères cessent d'être des UTF-32 valides (les caractères doivent être <= 0x10ffff).
nneonneo
1
@CeesTimmerman: en fait, le choix de zlibplutôt que zipest très utile. zlibest un nombre pair de caractères.
nneonneo
1

C # - 354 332

using System;
using System.IO;
using System.IO.Compression;
classe X
{
    statique void Main (chaîne [] args)
    {
        var x = Convert.FromBase64String ("41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAs)
        Console.WriteLine (nouveau StreamReader (nouveau DeflateStream (nouveau MemoryStream (x), CompressionMode.Decompress)). ReadToEnd ());
    }
}

Un peu golfé:

using System; using System.IO; utiliser System.IO.Compression; class X {static void main () {var x = Convert.FromBase64String ( "41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA"); Console.WriteLine (nouveau StreamReader (nouveau DeflateStream (nouveau MemoryStream (x), (CompressionMode) 0)). ReadToEnd ());}}
Erez Robinson
la source
Ce n'est pas vraiment du golf si vous avez encore des noms de variables plus longs qu'un caractère. Ou des choses inutiles comme string[] args.
Joey
Ne connaissez pas les règles, mais il n'y a pas d'autre moyen en C #, et le code doit être compilé, c'est le plus court possible.
Erez Robinson
1
Mainn'a pas besoin d'arguments, il compile quand même (contrairement à Java). Le supprimer et le mettre en ligne xporte déjà ce chiffre à 333. Vous pouvez enregistrer un autre octet en supprimant l'espace entre les arguments dans le DeflateStreamctor. Vous pouvez utiliser un casting pour le membre enum:, (CompressionMode)0ce qui nous ramène à 324. Je dirais donc que ce n'est pas encore le plus court possible ;-)
Joey
Vous avez raison ..
Erez Robinson
1

bzip2, 116

Après avoir vu la réponse de CJAM, je me suis dit que celle-ci devrait également être qualifiée.

$ wc -c golf.txt.bz2 
116 golf.txt.bz2
$ bzip2 -dc golf.txt.bz2

  '\                   .  .                        |>18>>
    \              .         ' .                   |
   O>>         .                 'o                |
    \       .                                      |
    /\    .                                        |
   / /  .'                                         |
jgs^^^^^^^`^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

$

Je doute qu'une autre explication soit nécessaire. :)

Alex Mooney
la source
1
L'utilisation de Bubblegum avec DEFLATE le réduit à 77 octets. Essayez-le en ligne!
Miles
0

C (gcc) , 190 octets

r(n,c){while(n--)putchar(c);}f(c){for(char*s="F'\\S.B.X|>18>>\nH\\N.I' .S|\nGO>>I.Q'oP|\nH\\G.ZL|\nH/\\D.ZN|\nG/ /B.'ZN |\n jgs^^^^^^^`";c=*s++;)c>64&&c<91&&c^79?r(c-64,32):r(1,c);r(51,94);}

Essayez-le en ligne!

gastropner
la source
0

Vim, 99 frappes

63i^<Esc>0R jgs<C-O>7l`<Esc>O<Esc>55I <Esc>A|<Esc>Y5PA>18>><Esc>7|R'\<Down>\<Down><Left><Left>O>><Down><Left><Left>\<Down>\<Down><Left><Left><Left>/<Up>/<Down>/<Right><Right>.'<Up>.<Right><Up>.<Right><Right><Up>.<Right><Right><Right><Up>.<Right><Right><Right><Up>.<Right><Right>.<Right><Right><Down>'<Right>.<Down><Right>'o

probablement jouable au golf

Explication:

63i^<Esc>0R jgs<C-O>7l`<Esc>
Bottom line, 63 '^'s, replace the beginning with ' jgs', then move 7 caracters to the right and replace one character with '`'

O<Esc>55I <Esc>A|<Esc>
Above current line, add one line and insert 55 spaces, then a trailing '|'

Y5PA>18>><Esc>
Copy that line and paste it above five times. Cursor ends up in topmost line. Append '>18>>'

7|R'\<Down>\<Down><Left><Left>O>><Down><Left><Left>\<Down>\<Down><Left><Left><Left>/<Up>/<Down>/<Right><Right>.'<Up>.<Right><Up>.<Right><Right><Up>.<Right><Right><Right><Up>.<Right><Right><Right><Up>.<Right><Right>.<Right><Right><Down>'<Right>.<Down><Right>'o
Go to 7th column, enter Replace-mode, and replace spaces with golfer and golf ball trail. Arrow keys are used to move around, since it uses fewer keypresses to use the arrow keys instead of <C-o>+movement for up to three keypresses.
oktupol
la source