Gra w golfa ASCII-art

31

Spróbujmy zagrać w golfa w ten ascii-art przedstawiający golfistę:

      „\. . |> 18 >>
        \. „. |
       O >>. „o |
        \. |
        / \. |
       / /. ” |
 jgs ^^^^^^^ `^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^

Źródło: JGS - http://www.retrojunkie.com/asciiart/sports/golf.htm

Zasady:

  • Brak danych wejściowych
  • Niedozwolone zasoby zewnętrzne
  • Dane wyjściowe muszą być dokładnie tym tekstem, wyświetlanym czcionką monospace (konsola systemu operacyjnego, konsola JS, znacznik HTML <pre>, ...), w tym wiodący i końcowy podział wiersza.
  • Dozwolone są otaczające cudzysłowy lub podwójne cudzysłowy (konsola JS dodaje podwójne cudzysłowy, gdy wypisujesz ciąg znaków, to jest w porządku)

Najlepszą odpowiedzią będzie ta, która używa mniej znaków w dowolnym języku.

Baw się dobrze!

Xem
źródło
2
„dokładnie ten tekst”: w tym pusty wiersz na początku? w tym pustą linię na końcu? z końcową nową linią czy bez? (Czyli 0, 1 lub 2 nowe linie na końcu?)
Martin Ender
@ m.buettner wyjście powinno mieć dokładnie jeden podział linii wiodącej i jeden podział linii końcowej / nową linię. (i cytuje, jeśli nie można ich uniknąć) :)
xem.
1
To ASCII wygląda mi bardziej na strzał w krykieta
Mr. Alien
@ Mr.Alien Widziałem to w ostatnim przemówieniu Martina Kleppe'a : speakerdeck.com/aemkei/… (wideo: youtube.com/watch?v=zy-2ruMHdbU )
xem. 5'14

Odpowiedzi:

14

CJam, 62 znaki

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

Wypróbuj online.

Testowe uruchomienie

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

Jak to działa

2G#b konwertuje poprzedni ciąg na liczbę całkowitą, uznając go za liczbę podstawową 65536.

128b:ckonwertuje tę liczbę całkowitą z powrotem na ciąg ( 110 bajtów ), uznając ją za liczbę podstawową 128, która ~następnie wykonuje:

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

(notacja karetki)

2/{)iS*}%

dzieli ciąg na pary dwóch znaków i wykonuje następujące czynności dla każdej pary: Pop drugi znak ciągu, przekonwertuj go na liczbę całkowitą i powtórz ciąg " "wiele razy.

Na przykład ".("staje się ". ", ponieważ kod znaku ASCII (to 40.

Wreszcie,

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

popycha ciąg znaków "jgs", znak ^powtarza się 7 razy, znak `, znak ^powtarza się 51 razy i przesuwa wiersz.

Dennis
źródło
1
Naprawdę niesamowite, ale kiedy biorę wersję 62char z pastebin i „wypróbuj online”, brakuje przerwy w linii przed ostatnią linią „jgs ...”
xem. 7'14
@xem: Czy skopiowałeś z sekcji RAW Paste Data ? Jeśli skopiuję sformatowany kod, otrzymam ten sam wynik.
Dennis
15

Ruby, 107

Myślałem, że faktycznie spróbuję „wygenerować” obraz w kodzie (zamiast korzystać z istniejącej funkcji kompresji):

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

W tym dosłownym tablicy jest kilka znaków niedrukowalnych.

Oto widok szesnastkowy pliku, aby pokazać także znaki niedrukowalne:

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

Dzięki Ventero za kilka istotnych ulepszeń! (Zasadniczo zmniejszył kod o 50%).

Martin Ender
źródło
Niezły wysiłek! Miałem nadzieję na takie odpowiedzi, które nie tylko
gzipują
1
Druga linia może polegać 6.times{|i|S[i+1]=' '*55+?|}na zapisaniu 2 znaków.
obrzydliwy
@ Unikaj gołębi Ah dzięki. Zacząłem od tego, ale początkowo myślałem, że będę potrzebował iwięcej niż raz. Dobry chwyt!
Martin Ender
2
Mam nadzieję, że nie masz nic przeciwko, jeśli wspomnę o kilku innych sposobach skrócenia tego! Korzystanie S.fill{' '*55+?|}zamiast zaoszczędzić kilka więcej znaków (będziesz musiał zdefiniować Sjako ['']*7, zmień putssię puts p,S,pi odjąć 1 od wszystkich współrzędnych y chociaż). Następnie, używając varargs w f ( def f(*p,c)), możesz zapisać []wywołania funkcji. Och, i możesz rzucić ()wokół y,x.
Ventero
1
Jeśli wykonasz S jednowymiarowy, możesz zapisać kolejne 55 znaków;) Oto kod, jeśli nie chcesz tego zrobić sam.
Ventero
13

bash + iconv + kod maszynowy DosBox / x86 (104 97 96 95 znaków)

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

Sugeruję, aby umieścić to w skrypcie w pustym katalogu, jest prawie pewne, że wklejenie go w terminalu zniszczy wszystko; nawet lepiej, możesz pobrać skrypt tutaj gotowy.

Oczekiwany wynik: expected output

Jak to działa

Część bash to tylko program uruchamiający, który używa iconvdo „dekompresji” .compliku ze znaków UTF-8 skryptu i uruchamia go za pomocą DosBox.

Zauważ, że stanowi to pewne ograniczenie treści, ponieważ nie wszystkie sekwencje wejściowe można interpretować jako UCS-2 iconvbez narzekania; na przykład z jakiegoś powodu wiele operacji związanych z bxrejestrem spowodowało spustoszenie w zależności od miejsca, w którym ich użyłem, więc musiałem kilka razy obejść ten problem.

Teraz rzeczą Unicode jest po prostu skorzystanie z zasad „liczby znaków”; rzeczywisty rozmiar (w bajtach) skryptu jest znacznie większy niż oryginalny .COMplik.

Wyodrębniony .complik to

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

i ma długość 108 bajtów. Źródłem NASM jest:

    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

Wszystko to jest po prostu dekompresorem, compressed.datktórego format jest następujący:

  • jeśli bit wysoki nie jest ustawiony, wypisz znak takim, jaki jest;
  • w przeciwnym razie 6 niskich bitów to liczba powtórzeń, a drugi najwyższy bit określa, czy musi wydrukować spację (bit nie ustawiony) czy daszek (zestaw bitów).

compressed.datz kolei jest generowany przy użyciu skryptu Python z oryginalnego tekstu.

Całość można znaleźć tutaj .

Matteo Italia
źródło
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

Wykorzystuje formatowanie ciągów z odstępami do podstawowej kompresji.

grc
źródło
7

PHP, 147

Działa to w wierszu poleceń i wyprowadza bezpośrednio do konsoli:

php -r 'echo gzinflate(base64_decode("41IAA/UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA"));'
piskliwy kostuch
źródło
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

Podziękowania dla Ventero i m.buettner za pomoc w mojej optymalizacji RegEx.

rdzeń 1024
źródło
Możesz uratować jedną postać za pomocąs/\d+(?!8?>)/%$&s/rg
Ventero
@ Ventero dziękuję za sugestię.
core1024
2
Możesz uratować kolejny, używając kwantyfikatora dzierżawczego :/\d++(?!>)/
Martin Ender
@ m.buettner Nie wiedziałem o tym. Uczenie się nowych rzeczy każdego dnia :)
core1024
4

GCC C - 203 bajty

Pomyślałem, że będę się z tym dobrze bawić. To kompiluje się w mojej wersji MinGW i wyświetla oczekiwany tekst.

Dodano spację dla przejrzystości.

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

Żadna z witryn do wklejania kodu online nie zezwala na stosowanie znaków jednobajtowych spoza zakresu ASCII, więc musiałem uciec przed nimi, aby przesłać przykład. Ale poza tym jest identyczny. http://codepad.org/nQrxTBlX

Zawsze możesz to zweryfikować za pomocą własnego kompilatora.

Kaslai
źródło
4

LOLCODE, 590 znaków

Bo LOLCODE iz perfik language 4 golfin: iz easy 2 obejmuje zaciemnienie i wcale nie jest pełne.

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, ale Ian ma interpretr LOLCODE http://repl.it wydaje się, że 2 nie jest funcshuns.

(Tranzlashun hojnie dostarczone przez roboty http://speaklolcat.com , bo I doan speakek lolcat)


Wersja kodu z wcięciem, odstępami i komentarzami (komentarze LOLCODE zaczynają się od 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
źródło
haha, niezła kompresja, podoba się: 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

Ciąg iprzeplata znaki w sztuce ascii z ich multiplikatami, reprezentowanymi jako znaki, wszystkie w odwrotnej kolejności. Ponadto oszczędzam trochę miejsca, używając „!” zamiast „G” w, ia następnie po prostu go zastępując.

Alex L.
źródło
3

Python (145)

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

Nie bardzo oryginalne, wiem.

.ıʇǝɥʇuʎs
źródło
2

JavaScript ( ES6 ) 193 175 bajtów

Edycja: Zmodyfikowano RegPack v3, aby zachować nowe wiersze, użyj for inpętli, aby zapisać 3 bajty, i usunięto eval dla niejawnego wyjścia konsoli.

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

Korzystanie z kompresji Unicode xem: 133 znaków

eval(unescape(escape('𧰽𘡜𫡸𙱜𧁷𮰮𘁺嵃🠱𞀾🡜𫡾𧁜屮𛡾𘀧𮡻𮑸𘁏🠾岍𘀧𫱷𮑾𧁜𮁺𭱸𮑾𛱜𧁻𮡷峀𮀠𛰠𛰠𘀮𙱷𭱾𘁹𘁪𩱳𯑠𯑽𯑽𯑽𯑞𧡜𫡾𮀠𘁽𧡞𧡞𧡞𧡻𘀠𘁺𘀮𭱹𯁜𫡸𮱻𭱾割𞱦𫱲𚁩𘁯𩠠𘡷𮁹𮡻𯑾𘠩𭱩𭁨𚁟𛡳𬁬𪑴𚁩𚐩𧰽𪡯𪑮𚁰𫱰𚀩𚐠').replace(/uD./g,'')))
nderscore
źródło
świetny! <3 przetwarzanie końcowe RegPack! psst, możesz to zrobić w 143b: xem.github.io/obfuscatweet
xem
@ xem 143 znaków, ale o wiele więcej bajtów
nderscore
tak przepraszam, 143 znaki. pytanie mówi, że możesz liczyć znaki. zresztą podejście regpack jest ciekawsze niż zaciemnianie Unicode;)
xem.
2
FWIW, mothereff.in/byte-counter to narzędzie, które liczy zarówno znaki, jak i bajty (zgodnie z UTF-8).
Mathias Bynens
2

ES6, 155 znaków

Po prostu próbuję podejść anorher:

Uruchom to w konsoli JS Firefoksa.

Każdy znak Unicode ma następującą postać: \ uD8 [kod ascii] \ uDC [liczba powtórzeń].

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

(Ciąg znaków Unicode wykonany za pomocą: http://jsfiddle.net/LeaS9/ )

Xem
źródło
-3:.replace(/../g,a=>String.fromCharCode(a[c='charCodeAt']()&255).repeat(a[c](1)&255))
nderscore
och, świetnie, dzięki!
xem.
2

PHP

Metoda 1, prostsza (139 bajtów):

Używanie wstępnie deflowanego ciągu.

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

Metoda 2: kodowanie przebiegów spacji do liter alfabetu (192 bajty):

<?=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
źródło
2

PowerShell, 192 188 119

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

Część powyżej zawiera kilka znaków innych niż znaki. Zrzut szesnastkowy:

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

Schemat kodowania to RLE z długością zakodowaną powyżej dolnego 7 bitów, które są znakami do wyświetlenia.

Joey
źródło
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
źródło
1

Pakowane JS (190b) / ES6 (146b) / ES6 (118 znaków)

Uruchom to w konsoli 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)

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

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

Dzięki @nderscore!

Xem
źródło
1
ES6 do 158: (spada do 124 znaków z kompresją 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
och, świetnie, nie wiedziałem, że się powtarzam
xem.
@nderscore nie będzie przykro, że to świetny :) ale ostatnia linia wydaje się uszkodzony w moim Firefox konsoli
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
Dzięki, zaktualizowałem odpowiedź i działa. :) Dodałem także kolejną odpowiedź 158b, może będziesz miał pomysł, aby to poprawić!
xem.
1

ES6, 163b / 127 znaków

Jeszcze inne podejście, dzięki @nderscore.

Uruchom go w konsoli 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))

Zapakowane (127c):

eval(unescape(escape('𘡜𫠆𙱜𧀓𛠂𛠘𯀾𜐸🠾𧁮𒁜𧀎𛠉𙰁𛠓𯁜𫠇𣰾🠉𛠑𙱯𔁼𧁮𒁜𧀇𛠦𯁜𫠈𛱜𧀄𛠨𯁜𫠇𛰁𛰂𛠧𚑼𧁮𐑪𩱳🁠𪁜𫠢𛡲𩑰𫁡𨱥𚀯𦱞𙱠𣱧𧁮🡜𧀬𛐸𪠭𯁝𛱧𛁡🐾𘠠𧠢𦱡👡𛡣𪁡𬡃𫱤𩑁𭀨𚐬𨐾𝐳𯀰𧐮𬡥𬁥𨑴𚁡𙐵𜰩𚐠').replace(/uD./g,'')))
Xem
źródło
Jestem pewien, że @nderscore znajdzie ulepszenie :)
xem. 5'14
Myślę, że SE łamie niektóre postacie w tym rozwiązaniu. Stosując podobne podejście do tego, co zrobiłem z twoją inną odpowiedzią, sprowadza się to do 163: jsfiddle.net/2Fbxq/3
nderscore
To wspaniałe ulepszenie (i bardzo miłe skrzypce). Aktualizuję odpowiedź.
xem.
1

Python, 70 znaków UTF-16

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

Oczywiście prawdopodobnie będziesz musiał użyć wersji szesnastkowej:

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

lub wersja base64:

I2NvZGluZzpVVEYtMTZCRQoAcAByAGkAbgB0ACd4nONSAAP1GAVMoAdG2EGNnaGFnR0XjIumHaFNHasRNTCN/nZ2WDTBNefj1Ai3EacLcWnUjyFBG5JGfSBU0FMnVh9IY1Z6cRwEJMSRDgCgLkcFACcALgBkAGUAYwBvAGQAZQAoACd6bGliACcAKQA=

Pierwsza „linia” programu deklaruje kodowanie UTF-16. Cały plik to UTF16, ale interpreter Pythona zawsze interpretuje linię kodującą w ASCII (jest to#coding:UTF-16BE ). Po nowej linii zaczyna się tekst UTF-16. To po prostu sprowadza się do tego, print'<data>'.decode('zlib')gdzie tekst jest deflowaną wersją docelowego obrazu ASCII. Dołożono wszelkich starań, aby strumień nie zawierał surogatów (co zniszczyłoby dekodowanie).

nneonneo
źródło
1
Cóż, pierwsza linijka sprawiła, że ​​pomyślałem „o świetnie, ktoś stworzył Pythona w Unicode”
patrz
niesamowite! Czy możesz zrobić to samo w ~ 35b z UTF-32? :)
xem.
zipzamiast zlibmoże zapisać jeden znak.
Cees Timmerman,
@xem: większość znaków przestaje być poprawna UTF-32 (znaki muszą mieć <= 0x10ffff).
nneonneo
1
@CeesTimmerman: w rzeczywistości wybór zlibraczej niż zipjest bardzo celowy. zlibto parzysta liczba znaków.
nneonneo
1

C # - 354 332

using System;
using System.IO;
using System.IO.Compression;
klasa X
{
    static void Main (string [] args)
    {
        var x = Convert.FromBase64String ("41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBAm;)
        Console.WriteLine (new StreamReader (new DeflateStream (new MemoryStream (x), CompressionMode.Decompress)). ReadToEnd ());
    }
}

Trochę golfa:

za pomocą systemu, za pomocą System.IO, stosując System.IO.Compression; klasy X {void główna () {var X = Convert.FromBase64String ( "41IAA / UYBUygB0bYQY2doYWdHReMG4OhEwrUsRpRA9Pob2eHRRNccz5OjXAbcboQl0b9GBK0IWnUB0IFPXUFEjRmpRfHQUBCHOmAiwsA") Console.WriteLine (New StreamReader (New DeflateStream (New MemoryStream (x), (CompressionMode) 0)). ReadToEnd ());}}
Erez Robinson
źródło
To nie jest tak naprawdę gra w golfa, jeśli nadal masz zmienne nazwy dłuższe niż postać. Lub niepotrzebne rzeczy, takie jak string[] args.
Joey,
Nie znają reguł, ale nie ma innej drogi w języku C #, a kod musi się skompilować, więc jest to najkrótszy możliwy.
Erez Robinson
1
Mainnie musi mieć żadnych argumentów, nadal będzie się kompilował (w przeciwieństwie do Javy). Usunięcie tego i xwprowadzenie powoduje już 333. Możesz zapisać kolejny bajt, usuwając spację między argumentami w DeflateStreamctor. Możesz użyć obsady dla członka enum:, (CompressionMode)0co sprowadza nas do 324. Więc twierdzę, że nie jest to jeszcze najkrótsza możliwa ;-)
Joey
Masz rację ...
Erez Robinson
1

bzip2, 116

Po obejrzeniu odpowiedzi CJAM, pomyślałem, że ta też powinna się zakwalifikować.

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

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

$

Wątpię, aby wymagane było jakiekolwiek dalsze wyjaśnienie. :)

Alex Mooney
źródło
1
Korzystanie Bubblegum z spuścić powietrze dostaje go w dół do 77 bajtów. Wypróbuj online!
Miles
0

C (gcc) , 190 bajtów

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

Wypróbuj online!

gastropner
źródło
0

Vim, 99 klawiszy

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

prawdopodobnie golfa

Wyjaśnienie:

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
źródło