Jak niektórzy z was wiedzą, aby nauczyć się języka o cudownej wyprawie Dennisa Try It Online! Witaj, świecie! program jest wymagany. Ostatnio Dennis usprawnił sposób ładowania tych programów ze strony internetowej. Oto tablica JSON znaków używanych w tych programach, według częstotliwości, według stanu na 27 lipca 2017 r.

Niektóre z tych postaci potrzebują trochę miłości, więc Twoim wyzwaniem jest wyjście Witaj, Świecie! (najlepiej w języku zaangażowanym w ten proces), używając tylko znaków określonych poniżej. Te postacie to wszystkie postacie używane między 10i 99(włącznie) razy, wraz z dwiema najczęstszymi postaciami 0i , ponieważ czuję się dobrze.

0 $&*?ABCDEFGIJKLNPQRSTUXYZ\`gjkqwxyz{}÷≤≥=║_

Używanie znaku powinno opierać się na jego wyglądzie w normalnym programie, a nie na podstawie jego kodu lub wartości bajtowej.

Musisz użyć co najmniej jednego znaku z tego zestawu, więc programy o długości 0 są nieprawidłowe.

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

JSFiddle, aby sprawdzić, czy twoja odpowiedź jest poprawna

SOGL V0.12 , 89 75 68 bajtów

z{}xxxx≥x≥x≥xXUqXxq≤qq≤q *R_IIRq  q *R_I0II*IRqxXq≤qxqxq CR_0II÷Rq0*

Wypróbuj tutaj!
Uwaga: ilekroć qtutaj jest mowa o wyjściu lub wyjściu, nie pojawia się on, ponieważ wyskakujące wyjście (którekolwiek oOpP) jest niedostępne lub nie wypisuje poprzedzającego nowego wiersza.

Objaśnienie (nieaktualne, zmieniło się to, że „H” jest drukowane przy użyciu liter alfabetu):

 $             push "$"
  R_           convert to an array of ordinals, then push all the contents to the stack
    0II        push 0+1+1 = 2
       *       multiply by that
        R      convert to character
         q     output
          z    push the lowercase alphabet
           {}  iterate over it, pushing each char, and do nothing. Stack: ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
stack manipulation:
 xxxx ["H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r"]
 ≥    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q"]
 x    ["r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n","o"]
 ≥    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l","m","n"]
 x    ["o","r","H","a","b","c","d","e","f","g","h","i","j","k","l"]
 ≥    ["l","o","r","H","a","b","c","d","e","f","g","h","i","j","k"]
 xxx  ["l","o","r","H","a","b","c","d","e"]
 q    output the "e"
 ≤    ["o","r","H","a","b","c","d","e","l"]
 qq   output the "l" twice
 ≤    ["r","H","a","b","c","d","e","l","o"]
 q    output the "o"

*                       push "*",
 R_                     convert to an array of ordinals, then push all to stack
   II                   increase by 2
     R                  convert back to character
      q                 output
         q              push a space, then output
           *            push "*"
            R_          convert to an array of ordinals, then push all to stack
              I         increase that
               0II      push 0+1+1 = 2
                  *     multiply
                   I    increase
                    Rq  output as character
stack manipulation: (starting stack: ["r","H","a","b","c","d","e","l","o",","," ","W"])
 x  ["r","H","a","b","c","d","e","l","o",","]
 X  ["r","H","a","b","c","d","e","l","o"]
 q  output the "o"
 ≤  ["H","a","b","c","d","e","l","o","r"]
 q  output the "r"
 x  ["H","a","b","c","d","e","l"]
 q  output the "l"
 x  ["H","a","b","c","d"]
 q  output the "d"

C            push "C"
 R_          convert to ordinal as before
   0II÷      floor divide by 2
       Rq    output as character
         0*  multiply by 0 so nothing extra would be outputted

Ciekawostka: wszystkie znaki z dozwolonych znaków znajdują się na stronie kodowej SOGL: D

Perl 5 , 76 bajtów

}{${$_=$`x?B?}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}=$_=\*G

Korzysta z funkcji, która została uznana za przestarzałą, ale działa lokalnie w moim terminalu (jak wspomniano w wersji 5.18.2). W starszych wersjach Perla ?\w?jest synonimem, dla /\w/którego daje mi dostęp do dopasowania wyrażenia regularnego i mam wystarczającą liczbę znaków dla $&(ostatniego dopasowania) i $`(tekstu poprzedzającego ostatnie dopasowanie). Potrzebuję ich, aby móc zdobyć O. Generuję to tworząc globreferencję ( $_=\*Gktóra, jak w przypadku skalara, przypomina coś takiegoGLOB(0x7ffb728028d0) ). Raz, że jest w $_, ?B?będzie dopasować Bi $`będzie zawierać GLO, mogę potem dopasować przeciwko \w$która przechowywać Ow$&który jest wstawiany do ciągów, które uruchamiam ciągiem-ORAZ w celu utworzenia reszty tekstu, treść ciągu jest pisana małymi literami \L.

Wypróbuj online! - używa /\w/zamiast, ?\w?ponieważ wersja Perla na TIO jest zbyt nowa.

Perl 5 , 65 bajtów

Jest to nieco bardziej podstępne, ponieważ zależy od nazwy pliku w TIO (która jest .code.tio), więc nie sądzę, że to konkuruje, ale byłem zadowolony z wyniku!

}{${$_=$0}{?\w$?}{$_=qq{Lg\LLL$&= w$&RLD=}&qq=y}\LLL$&L _$&RLDA=}

Wypróbuj online!

Unary , 7 * 10 ¹⁸² bajtów

Unary to Brainfuck konwertowane na binarne konwertowane na unary za pomocą 0licznika. Zasadniczo kondensuje program Brainfuck w liczbę, a wynikiem jest liczba 0s. Zazwyczaj są to bardzo duże programy.

Nie wkleję tutaj programu, ponieważ nie wiem, na ile pozwala SE tekst, ale założę się, że to mniej niż to. Zamiast tego wkleję dokładną liczbę zer w tej odpowiedzi:

708184005756841022918598670049178934705323143517361395031673227349803938380119378597780037353721967636097362645175347036417214959141923667629285233360306016978751166690464736541968556

Ponieważ jest to dość tania odpowiedź, z pewnością nie jest najkrótsza, a ja po prostu skopiowałem ją, dlatego piszę na wiki.

05AB1E , 137 106 95 bajtów

X00X00DXX00DXX00XX0X0X00D0XXXX0X00X00XXX00XXX0XXXXXX00XXXXX0XXXX00D0X000DD00XXJC000gDD0000g***B

Wypróbuj online!

-31 dzięki @Adnan za wskazanie, że mogę użyć bazy 108.

- ?? dzięki @Riley za wskazanie niektórych rzeczy źle.

Stara wersja (inna metoda):

05AB1E , 211 186 166 bajtów

0g00g000000000gUX000000gXX00000g000g00g000gD0000g0 000g00000gX00000gX00000g0 00000g00000000g0000000g00g00000000gD000000gX0000000g0g00000gUXJX00000000000000000g000g**B

Wypróbuj online!

Ha ha! I TUTAJ MYŚLĘ, ŻE ESOLANGS NIE STAŁA ŻADNEJ SZANSY!

Najpierw otrzymujemy 255 zapisanych w X:

00g               # Push 2 (length of 00).
   00000g         # Push 5 (length of 00000).
         00000g   # Push 5.
               JU # Join to 255 and store in X.

Następnie, używając tej samej długości sztuczki, naciskamy: 1296995323340359595058728869715

0g00g000000000g000000g000000000g000000000g00000g000g00g000g000g0000g0 000g00000g000000000g00000g000000000g00000g0 00000g00000000g0000000g00g00000000g00000000g000000g000000000g0000000g0g00000gJ

Gdzie 0<space>zamiast zer używamy sztuczki długości.

Następnie w końcu wypychamy 255, które zachowaliśmy i konwertujemy z 255 na bazę 10 :

X  # Push stored 255.
 B # Convert to base 255.

Wciąż gra w golfa przy użyciu innych dozwolonych znaków i powielanie, to będzie minuta.

Beatnik , 148 bajtów

K QQQQQQQG ZD XA K QQJA KD ZD XA K KG KD ZD ZD ZD XA XA K B KD ZD XA K QQQQF ZD ZD XA K QQQD XA K A Z KD XA ZD XA K B KD XA ZD XA K J Z XA K QQQB XA

Wypróbuj online!

Wyjaśnienie

Beatnik opiera wykonaną instrukcję na podstawie wyniku scrabble słowa. Oto skrócone wyjaśnienie:

Code         Scrabble Score   Explanation

K            5                push the scrabble score of the next word
QQQQQQQG     72               72 ['H']
ZD           12               pop a value; push it back twice
XA           9                pop a value; print its ASCII character
KD           7                pop two values; push their sum
Z            10               pop two values; push their difference

Moorhens (v2.0), 3423 983 923 866 749 716 bajtów

Myślę, że można to trochę pograć w golfa, Moorhens nie jest łatwym językiem do pracy.

xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU KA AA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU KA KA xU xU xU AA AA AA AA AA KA xU AA KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU xU KA xU xU xU KA XI XI XI XI XI XI KA XI XI XI XI XI XI XI XI AA AA AA AA AA AA AA AA AA AA AA AA

Wyjaśnienie

Moorhens to język oparty na słowach słownikowych. Każde słowo odpowiada operacji opartej na jego wartości skrótu. Pięć operacje są tutaj używane xU, ER, XI, KA, iAA

• xU zwiększa TOS
• ER stawia nowe zero na stosie.
• XI zmniejsza TOS
• KA powiela warunki świadczenia usługi
• AA zrzuca TOS na dół

Naciskamy każdą literę z sukcesywnymi zastosowaniami tych operacji.

Glifo , 480 bajtów

AABCABABABBAABABAABCABBAABABABBCABBAABABABABABABABBAABBAABABABABABABABBAABBAAABCABBAABABAABCAABCABBAABABABBCABABABBAABBAABABAABCAABCABBAAABCABBAABABABBAABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABAAABABAABAABBAABCAABABABBAABBAAABCAABCABBAABABABBCABABABBCABABABBAABAAABABAABAABABABBAABABABBAABABABAAABABAABAABBAABABABBAAABCABBAABABAABCABCAABABABABABBAABBAABBAABABAABCABCAABAAABABAABAABBAABABABBCAABCABBAAABCAABCABBAAABCABBAABABABBAABABABBCABABABBAABAAABABABCAABBAAABAABACABBBABCB

Wypróbuj online!

Zagłówki , 78 bajtów

yyzyzzxNxNzx{yyy{y{y{yzzz_{_zzyy\zxxxxxx\zzy\\zz\zx\{{\{{\zzz\xxx\{{\{{y\zzzx\

Podwójny JavaScript, 318 bajtów

Nie jestem pewien, czy jest to dozwolone, nie mogłem tego zrobić za pomocą interpretera JavaScript. Jest podobny w użyciu, eval()ale zamiast tego używam interpretera dwa razy: (Wypróbuj go w konsoli, aby wydrukować wynik)

`\`\\x${0xA*0xA&0xC}${0xA&0xC}\\x${0xA*0xF&0xF}${0xB*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}F\\x${0xE*0xF&0xF}C\\x${0xE*0xF&0xF}${0}\\x${0xB*0xF&0xF}${0xB*0xB*0xF&0xF}\\x${0xA*0xF&0xF}F\\x${0xB*0xB*0xF&0xF}${0xE*0xF&0xF}\\x${0xA*0xF&0xF}C\\x${0xA*0xF&0xF}${0xA*0xA&0xC}\\x${0xE*0xF&0xF}${0**0}\``

Wypróbuj online!

Ocenia:

`\x48\x65\x6C\x6C\x6F\x2C\x20\x57\x6F\x72\x6C\x64\x21`

Wypróbuj online!

Który ocenia na Hello, World!

Smallf ** k , 266 bajtów:

zJ$NJ`ZZx*gQYQQ{zqyKKUkUR?AS`zB`JB&UCKCIxQ_G0*000FzzJ&?YwkC\qqgZ`xYQyC}DgY_&_S}KPZ\&?SGAE&{Gw_w} GAgA{qT{gC&`qI?xwCNQwgR}?{*QEwQUj&BT&jR__IJJIqUqAPF0yICXESL?AYR QIAFU& yYwE&$\Njj B0T*F j$?kCzQk*}U}UgI$}Ew_yDL`qYI*E_G}SCjXDFNJKGNIGyIwA\BzLP`*zCILGCNqyYZyq? GwN{q{gKSj

W rzeczywistości postacie są trochę nieistotne. To tylko kwestia, czy każdy znak ma parzysty lub nieparzysty kod. Dlatego też postarałem się użyć każdej dostępnej postaci (z wyjątkiem postaci wielobajtowej) (chociaż ponieważ była losowa, nie starałem się tego zagwarantować).

Pyke , 133 144 bajtów

? BXKKKKRKRKRK\CkJ00q}}}XEjTX}G_E\E\L\LkJjRT}}XRGREkJjR 00q}R? B_RE\ \wkJjRT}}XRGRE\R\L\DkJjRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJjRT}}RG_RE00q}}RAA

Wypróbuj online!

Okropny bałagan kodu, który prawie na pewno można skrócić ... Konstruuje go po jednym znaku na raz.

? BXKKKKRKRKRK\CkJ - ".C" - A string that when evaled, gets the character at the point
00q}}}XEj - Construct 64 by doing `((0==0)*2*2*2)**2` and then eval, getting the "@" character and store it in `j`
TX}G_E - Get "h" using `@` by looking it up in the alphabet
\E\L\LkJ - "hELL"
jRT}}XRGREkJ - "hELLo"
jR 00q}R? B_RE  - ","
\ \wkJ - "hELLo, w"
jRT}}XRGRE\R\L\DkJ - "hELLo, woRLD"
jRZ0q}}R? B_RER? JR? KREZjZ0q}AREkJ - "hELLo, woRLD!"
jRT}}RG_RE00q}}RAA - "Hello, World!"

dc , 164 162 bajty

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzS zzS?zzzzzzzzzzzzS$zzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzzzzzzzzzzzzzzzSwzzzzzzzzzzzzzzzPzzzzzzzzSLzPzPzzzzPL$PL PLwPzPzzzzPLLPAI*PL?P

Wypróbuj online!

Prawdopodobnie istnieje lepsze / bardziej interesujące podejście. Próbowałem użyć sztuczki ASCII + 256, która dcma, ale generuje również dodatkowe znaki (nawet jeśli nie są drukowane), a kiedy dotarłem do „o”, cudownie pierwszej 111, miałem problemy nawet z uzyskaniem wartość 111+ (wielokrotność 256), która została odpowiednio uwzględniona. Oto więc dość proste (choć grało w golfa, gdzie to możliwe) rozwiązanie:

In dc, zto polecenie, które wypycha głębokość stosu na stos. Oznacza to, że możemy użyć go jako przyrostu. W ten sposób tworzę większość moich wartości ASCII dla tego wyzwania (drukowane przy pomocy P), które wciskam na nazwane stosy Si wskakuję z powrotem na główny stosL .

dcpozwala używać wartości szesnastkowych AF, nawet gdy podstawa wejściowa jest dziesiętna (domyślnie). Na szczęście nasza pierwsza litera, 72, jest wielokrotnością 12, więc zapisuję tutaj bajt lub dwa, mnożąc 6 * 12 i drukując natychmiast (zzzzzzzC*P ). Moja 164-bajtowa wersja wykorzystywała mnożenie wcześnie, aby uzyskać 72 („H”), co było nieco sprytne, ale było zapisem poprzedniej próby i marnotrawstwem bajtów. Teraz zaczynam od zwiększenia i zaoszczędzenia miejsca, wykrzyknika i przecinka, które są nieczynne i dlatego nie można ich jeszcze wydrukować. Następnie przechodzę do litery „H”, którą drukuję od razu, zanim przejdę do „W”, którą muszę zachować na później.

Po prostu drukuję, kiedy uderzę w „e”, a następnie zwiększam do „l”. Drukuję dwa z nich i oszczędzam jeden. Kiedy przechodzę do „o”, najpierw pomyślałem, że będę musiał zapisać jeden z nich na później, ale wszystko jest w pewnym sensie w porządku w tym momencie. Piszę „o”, odzyskuję przecinek, spację i „W” wcześniej, a teraz wracam do „o”. Drukuję to i zwiększam kilka do najwyższej niezbędnej wartości, „r” (114), którą drukuję przed załadowaniem i wydrukowaniem „l”, które wcześniej schowałem.

Prawie skończone! „d” jest wartością ASCII 100, którą można łatwo zrobić, mnożąc 10 * 10 (mniej bajtów niż wcześniej ją zapisano i załadowano). Wartość szesnastkowa Awynosi 10, podobnie jak nasza podstawa wejściowa, którą możemy pobrać za pomocą polecenia I. Pomnóż je, wydrukuj, a następnie załaduj i wydrukuj nasz wykrzyknik wcześniej. Witaj świecie!