Golf ASCII-art

31

Intentemos jugar al golf esta pieza de arte ascii que representa a un hombre de golf:

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

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

Reglas:

  • No se permite entrada
  • No se permiten recursos externos
  • El resultado debe ser exactamente este texto, que se muestra en una fuente monoespaciada (consola del sistema operativo, consola JS, etiqueta HTML <pre>, ...), incluido el salto de línea inicial y final.
  • Se permiten comillas circundantes o comillas dobles (la consola JS agrega comillas dobles cuando genera una cadena, esto está bien)

La mejor respuesta será la que use menos caracteres en cualquier idioma.

¡Que te diviertas!

code-golf  ascii-art  kolmogorov-complexity 
— xem
fuente
2
"exactamente este texto": ¿incluye la línea vacía al principio? incluyendo la línea vacía al final? con una nueva línea al final o sin ella? (Es decir, 0, 1 o 2 líneas nuevas al final?)
— Martin Ender
@ m.buettner, la salida debe tener exactamente un salto de línea inicial y un salto de línea posterior / nueva línea. (y citas si no puedes evitarlas) :)
— xem
1
Ese ASCII se parece más a un tiro de Cricket para mí
— Sr. Alien el
@ Mr.Alien Lo vi en la reciente charla de Martin Kleppe: speakerdeck.com/aemkei/… (video: youtube.com/watch?v=zy-2ruMHdbU )
— xem

Respuestas:

14

CJam, 62 caracteres

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

Pruébalo en línea.

Prueba de funcionamiento

$ 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^^^^^^^`^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
$

Cómo funciona

2G#b convierte la cadena anterior en un número entero al considerarla un número base-65536.

128b:cconvierte ese entero de nuevo en una cadena ( 110 bytes ) al considerarlo un número base-128, que ~luego ejecuta:

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

(notación caret)

2/{)iS*}%

divide la cadena en pares de dos caracteres y hace lo siguiente para cada par: Pop el segundo carácter de la cadena, convertirlo en un entero y repetir la cadena " "tantas veces.

Por ejemplo, se ".("convierte ". ", porque el código de caracteres ASCII de (es 40.

Finalmente,

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

empuja la cadena "jgs", el carácter se ^repite 7 veces, el carácter `, el carácter se ^repite 51 veces y un salto de línea.

— Dennis
fuente
1
Realmente increíble, pero cuando tomo la versión 62char del pastebin y la "pruebo en línea", falta un salto de línea antes de la última línea "jgs ..."
— xem
@xem: ¿Copió de la sección RAW Paste Data ? Si copio el código formateado, obtengo el mismo resultado.
— Dennis
15

Ruby, 107

Pensé que realmente trataría de "generar" la imagen en código (en lugar de usar alguna función de compresión existente):

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

Hay algunos caracteres no imprimibles en esa matriz literal.

Aquí está la vista hexadecimal del archivo, para mostrar también los caracteres no imprimibles:

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

¡Gracias a Ventero por algunas mejoras importantes! (Básicamente redujo el código en un 50%).

— Martin Ender
fuente
Buen esfuerzo! Esperaba respuestas como esa, que no solo comprimen el ASCII;)
— xem
1
La segunda línea podría ser 6.times{|i|S[i+1]=' '*55+?|}guardar 2 caracteres.
— afuous
@voidpigeon Ah, gracias. En realidad comencé con eso, pero inicialmente pensé que necesitaría imás de una vez. ¡Buena atrapada!
— Martin Ender
2
¡Espero que no te importe si menciono algunas formas más de acortar esto! Usando S.fill{' '*55+?|}vez ahorra unos cuantos más caracteres (que tendrán que definir Scomo ['']*7, cambiar el putsa puts p,S,py restar 1 a todas sus coordenadas y, aunque). Luego, usando varargs en f ( def f(*p,c)), puede guardar el []en las llamadas a funciones. Ah, y puedes dejarlo ()todo y,x.
— Ventero
1
Si crea S unidimensional, puede guardar otros 55 caracteres;) Aquí está el código si no desea hacerlo usted mismo.
— Ventero
13

código de máquina bash + iconv + DosBox / x86 (104 97 96 95 caracteres)

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

Sugiero poner esto en un script en un directorio vacío, es casi seguro que copiarlo y pegarlo en un terminal lo romperá todo; aún mejor, puedes obtener el script aquí ya hecho.

Rendimiento esperado: Rendimiento esperado

Cómo funciona

La parte bash es solo un lanzador que se usa iconvpara "descomprimir" un .comarchivo de los caracteres UTF-8 del script y lo lanza con DosBox.

Tenga en cuenta que esto plantea una limitación en el contenido, ya que no todas las secuencias de entrada pueden interpretarse como UCS-2 iconvsin quejarse; por ejemplo, por alguna razón, muchas operaciones relacionadas con el bxregistro causaron estragos dependiendo del lugar donde las usé, así que tuve que solucionar este problema varias veces.

Ahora, lo de Unicode es aprovechar las reglas de "recuento de caracteres"; El tamaño real (en bytes) del script es mucho mayor que el .COMarchivo original .

El .comarchivo extraído es

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

y tiene 108 bytes de longitud. La fuente NASM para ello es:

    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

Todo esto es solo un descompresor compressed.datcuyo formato es el siguiente:

  • si el bit alto no está configurado, imprima el carácter tal cual;
  • de lo contrario, los 6 bits bajos son el recuento de repeticiones, y el segundo bit más alto especifica si tiene que imprimir un espacio (bit no establecido) o un cursor (conjunto de bits).

compressed.data su vez se genera usando un script Python del texto original.

Todo se puede encontrar aquí .

— Matteo Italia
fuente
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

Esto utiliza el formato de cadena con espacio para una compresión básica.

— grc
fuente
7

PHP, 147

Esto se ejecuta en la línea de comando y sale directamente a la consola:

php -r 'echo gzinflate(base64_decode("41IAA/UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA"));'
— ossifrage aprensivo
fuente
6

Perl - 127 129 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

Gracias a Ventero y m.buettner por su ayuda en mi optimización RegEx.

— core1024
fuente
Puedes guardar un personaje cons/\d+(?!8?>)/%$&s/rg
— Ventero
@Ventero gracias por la sugerencia.
— core1024
2
Puede guardar otro usando un cuantificador posesivo :/\d++(?!>)/
— Martin Ender
@ m.buettner No lo sabía. Aprender cosas nuevas todos los días :)
— core1024
4

GCC C - 203 bytes

Pensé que me divertiría con este. Esto compila en mi versión de MinGW y genera el texto esperado.

Espacio en blanco agregado para mayor claridad.

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++));
    }
}

Ninguno de los sitios de pegado de código en línea permite el uso de caracteres de un solo byte fuera del rango ASCII, por lo que tuve que escapar de ellos para obtener un ejemplo cargado. Sin embargo, es idéntico. http://codepad.org/nQrxTBlX

Siempre puede verificarlo también con su propio compilador.

— Kaslai
fuente
4

LOLCODE, 590 caracteres.

Porque LOLCODE es lenguaje perfik 4 golfin: es fácil 2 comprimir y ofuscar y no es detallado en absoluto.

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

Estoy bastante seguro de que no lo hago, pero tengo un intérprete de LOLCODE y http://repl.it parece que no es 2 funkshuns liek.

(Tranzlashun generosamente proporcionado por los robots de http://speaklolcat.com porque yo hago un lolcat de Speek)

Versión con sangría, espaciada y comentada del código (los comentarios de LOLCODE comienzan con 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
— nosotros C
fuente
jaja, buena compresión, me gusta: 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 cadena iintercala los caracteres en el arte ascii con sus multiplicitas, representadas como caracteres, todo en orden inverso. Además, ahorro un poco de espacio usando '!' en lugar de 'G' iy luego simplemente reemplazarlo.

— Alex L
fuente
3

Pitón (145)

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

No muy original, lo sé.

— ɐɔıʇǝɥʇuʎs
fuente
2

Javascript ( ES6 ) 193 175 bytes

Editar: ModPack modificado v3 para mantener nuevas líneas, usar un for inbucle para guardar 3 bytes y eliminar eval para la salida implícita de la consola.

_="\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())

Usando la compresión unicode de xem: 133 caracteres

eval(unescape(escape('𧰽𘡜𫡸𙱜𧁷𮰮𘁺嵃🠱𞀾🡜𫡾𧁜屮𛡾𘀧𮡻𮑸𘁏🠾岍𘀧𫱷𮑾𧁜𮁺𭱸𮑾𛱜𧁻𮡷峀𮀠𛰠𛰠𘀮𙱷𭱾𘁹𘁪𩱳𯑠𯑽𯑽𯑽𯑞𧡜𫡾𮀠𘁽𧡞𧡞𧡞𧡻𘀠𘁺𘀮𭱹𯁜𫡸𮱻𭱾割𞱦𫱲𚁩𘁯𩠠𘡷𮁹𮡻𯑾𘠩𭱩𭁨𚁟𛡳𬁬𪑴𚁩𚐩𧰽𪡯𪑮𚁰𫱰𚀩𚐠').replace(/uD./g,'')))
— nderscore
fuente
¡Excelente! <3 el post-procesamiento de RegPack! psst, puedes hacerlo en 143b: xem.github.io/obfuscatweet
— xem
@xem 143 caracteres, pero muchos más bytes
— nderscore
sí lo siento, 143 caracteres. la pregunta dice que puedes contar los caracteres. de todos modos, el enfoque del regpack es más interesante que la ofuscación unicode;)
— xem
2
FWIW, mothereff.in/byte-counter es una herramienta que cuenta tanto caracteres como bytes (según UTF-8).
— Mathias Bynens
2

ES6, 155 caracteres

Solo intento un enfoque diferente:

Ejecuta esto en la consola JS de Firefox.

Cada carácter unicode tiene la siguiente forma: \ uD8 [ascii charcode] \ uDC [número de repeticiones].

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

(Cadena Unicode hecha con: http://jsfiddle.net/LeaS9/ )

— xem
fuente
-3:.replace(/../g,a=>String.fromCharCode(a[c='charCodeAt']()&255).repeat(a[c](1)&255))
— nderscore
oh genial gracias
— xem
2

PHP

Método 1, más simple (139 bytes):

Usando una cadena previamente desinflada.

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

Método 2, codificación de corridas de espacios en letras del alfabeto (192 bytes):

<?=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
fuente
2

PowerShell, 192 188 119

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

La parte anterior contiene algunos no caracteres. Volcado hexadecimal:

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

El esquema de codificación es RLE con la longitud codificada por encima de los 7 bits inferiores, que son los caracteres a mostrar.

— Joey
fuente
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
fuente
1

JS (190b) / ES6 (146b) / ES6 empaquetado (118 caracteres)

Ejecute esto en la consola 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)

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

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

Gracias a @nderscore!

— xem
fuente
1
ES6 hasta 158: (baja a 124 caracteres con compresión 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, genial, no sabía repetir
— xem
@nderscore no lo siento, es genial :) pero la última línea parece estar rota en mi consola 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 agrega caracteres invisibles de salto de línea después de 41 | \ ‌)
— nderscore
Gracias, actualicé la respuesta y funciona. :) También agregué otra respuesta de 158b, ¡quizás tengas una idea para mejorarla!
— xem
1

ES6, 163b / 127 caracteres

Otro enfoque más, gracias a @nderscore.

Ejecútalo en la consola 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))

Embalado (127c):

eval(unescape(escape('𘡜𫠆𙱜𧀓𛠂𛠘𯀾𜐸🠾𧁮𒁜𧀎𛠉𙰁𛠓𯁜𫠇𣰾🠉𛠑𙱯𔁼𧁮𒁜𧀇𛠦𯁜𫠈𛱜𧀄𛠨𯁜𫠇𛰁𛰂𛠧𚑼𧁮𐑪𩱳🁠𪁜𫠢𛡲𩑰𫁡𨱥𚀯𦱞𙱠𣱧𧁮🡜𧀬𛐸𪠭𯁝𛱧𛁡🐾𘠠𧠢𦱡👡𛡣𪁡𬡃𫱤𩑁𭀨𚐬𨐾𝐳𯀰𧐮𬡥𬁥𨑴𚁡𙐵𜰩𚐠').replace(/uD./g,'')))
— xem
fuente
Estoy seguro de que @nderscore encontrará una mejora :)
— xem
Creo que SE está rompiendo algunos de los personajes de esta solución. Usando un enfoque similar a lo que hice con su otra respuesta, esto se reduce a 163: jsfiddle.net/2Fbxq/3
— nderscore
Bueno, esa es una gran mejora (y un violín muy agradable). Actualizo la respuesta.
— xem
1

Python, 70 caracteres UTF-16

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

Por supuesto, probablemente tendrá que usar la versión hexadecimal:

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

o la versión base64:

I2NvZGluZzpVVEYtMTZCRQoAcAByAGkAbgB0ACd4nONSAAP1GAVMoAdG2EGNnaGFnR0XjIumHaFNHasRNTCN/nZ2WDTBNefj1Ai3EacLcWnUjyFBG5JGfSBU0FMnVh9IY1Z6cRwEJMSRDgCgLkcFACcALgBkAGUAYwBvAGQAZQAoACd6bGliACcAKQA=

La primera "línea" del programa declara la codificación UTF-16. El archivo completo es UTF16, pero el intérprete de Python siempre interpreta la línea de codificación en ASCII (lo es #coding:UTF-16BE). Después de la nueva línea, comienza el texto UTF-16. Simplemente equivale a print'<data>'.decode('zlib')donde el texto es una versión desinflada de la imagen ASCII de destino. Se tuvo cuidado para asegurar que la secuencia no tuviera sustitutos (lo que arruinaría la decodificación).

— nneonneo
fuente
1
Bueno, la primera línea me hizo pensar "oh genial, alguien hizo python unicode"
— verqu
¡increíble! ¿Puedes hacer lo mismo en ~ 35b con UTF-32? :)
— xem
zipen lugar de zlibpuede guardar un personaje.
— Cees Timmerman
@xem: la mayoría de los caracteres dejan de ser válidos UTF-32 (los caracteres deben ser <= 0x10ffff).
— nneonneo
1
@CeesTimmerman: en realidad, la elección de zlibalgo zipes muy útil zlibes un número par de caracteres
— nneonneo
1

C # - 354 332

utilizando el sistema;
usando System.IO;
usando System.IO.Compression;
clase X
{
    vacío estático Main (string [] args)
    {
        var x = Convert.FromBase64String ("41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOO;
        Console.WriteLine (nuevo StreamReader (nuevo DeflateStream (nuevo MemoryStream (x), CompressionMode.Decompress)). ReadToEnd ());
    }
}

Un poco de golf:

using System; usando System.IO; usando System.IO.Compression; clase X {static void Main () {var x = Convert.FromBase64String ( "41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA"); Console.WriteLine (nuevo StreamReader (nuevo DeflateStream (nuevo MemoryStream (x), (CompressionMode) 0)). ReadToEnd ());}}
— Erez Robinson
fuente
Eso no es realmente divertido si todavía tienes nombres de variables más largos que un personaje allí. O cosas innecesarias como string[] args.
— Joey
No sé las reglas, pero no hay otra manera en C #, y el código necesita compilarse, así que este es el más corto posible.
— Erez Robinson
1
Mainno necesita tener ningún argumento, aún se compilará (en contraste con Java). Quitando eso y alineandox trae esto a 333 ya. Puede guardar otro byte eliminando el espacio entre los argumentos en el DeflateStreamctor. Puede usar un reparto para el miembro de enumeración: lo (CompressionMode)0que nos lleva a 324. Entonces diría que aún no es lo más corto posible ;-)
— Joey
Tienes razón ..
— Erez Robinson
1

bzip2, 116

Después de ver la respuesta de CJAM, pensé que esta también debería calificar.

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

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

$

Dudo que se requiera alguna explicación adicional. :)

— Alex Mooney
fuente
1
El uso de Bubblegum con DEFLATE lo reduce a 77 bytes. Pruébalo en línea!
— Miles del
0

C (gcc) , 190 bytes

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

Pruébalo en línea!

— gastropner
fuente
0

Vim, 99 pulsaciones de teclas

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

probablemente golfable

Explicación:

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
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.