Wyzwanie

Wydrukuj następujące znaki:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Problem polega na tym, że nie możesz użyć żadnego z nich w swoim kodzie.

Możesz wydrukować je w dowolnej kolejności, z wiodącym lub końcowym znakiem nowej linii lub bez, ale nie możesz drukować żadnych innych znaków.

Zasady

• Nie możesz używać żadnych znaków z zestawu wspomnianego powyżej
• Możesz użyć innych znaków
• Bez oszukiwania
• Standardowe luki zabronione
• To jest golf golfowy , wygrywa najkrótsza odpowiedź.

Wyjaśnienia

• Jeśli twój język używa innego zestawu znaków, nie możesz używać w tym zestawie znaków kodowych, które odpowiadają znakom alfanumerycznym.
• Zwracanie ciągu z funkcji jest uważane za prawidłową formę wyniku.
• Możesz zwrócić tablicę znaków.

V , 8 7 bajtów

Zapisano 1 bajt dzięki @DJMcMayhem, umieszczając wszystko w jednym wyrażeniu regularnym

¬/{Ó×ü_

Wypróbuj online!

Wyjścia:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Uwaga: nie× jest lub jest xX0xd7

Hexdump:

00000000: ac2f 7bd3 d7fc 5f                        ./{..._

Wyjaśnienie

¬/{            " inserts every character in the range / to {

Teraz dane wyjściowe wyglądają następująco:

/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{

Musimy usunąć wszystkie znaki niealfanumeryczne i _(ponieważ nie jest to uwzględnione \W), więc zróbmy to za pomocą wyrażenia regularnego

Ó×ü_           " removes every character that is non-alphanumeric or an underscore _ 
               " vim equivalent of :s/\W\|_//g

Oktawa , 52 46 40 bajtów

['['-('"':'+'),'{'-(_='!':':'),_+'@','']

To ocenia na

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Wyjaśnienie

Wykorzystujemy tutaj fakt, że znaki są domyślnie konwertowane na liczby całkowite, gdy stosowane są operacje arytmetyczne, takie jak +-lub funkcja zakresu :. Po połączeniu z pustym ciągiem ( [...,'']) liczby ponownie są konwertowane na znaki.

Wypróbuj online!

pieprzenie mózgu , 77 76 75 72 bajtów

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

Wypróbuj online!

Jak to działa

Tłumacz rozpoczyna się taśmą 0 komórek.

++++++++

To ustawia pierwszą komórkę na 8 , pozostawiając taśmę w następującym stanie.

   8
   ^

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

To zwiększa raz drugą komórkę, trzecia komórkę 6 razy, czwarta komórka 4 razy, zmniejsza piątą komórkę raz, a następnie wraca na początek taśmy i zmniejsza pierwszą komórkę. Po 8 iteracjach taśma wygląda następująco.

  0   8  48  32  -8
  ^

>++

Przechodzimy do drugiej komórki i zwiększamy ją dwukrotnie, przygotowując się do wydrukowania cyfr.

  0  10  48  32  -8
      ^

[>.+<-]

Drukuje trzecią komórkę, zwiększa ją, a następnie wraca do drugiej komórki i zmniejsza ją. Po 10 iteracjach wydrukowaliśmy, 0123456789a taśma wygląda następująco.

  0   0  58  32  -8
      ^

>>

Czas przygotować taśmę na litery! Zaczynamy od przejścia dwóch komórek.

  0   0  58  32  -8   0   0
              ^

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

To zwiększa jednokrotnie piątą komórkę, szóstą komórkę dwukrotnie, siódmą komórkę trzy razy, a następnie wraca do czwartej komórki i zmniejsza ją. Po 32 iteracjach taśma wygląda następująco.

  0   0  58   0  24  64  96
              ^

>++

Ostatnim krokiem przed wydrukowaniem listów jest przejście do piątej komórki i dwukrotne zwiększenie.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Na koniec przechodzimy do szóstej komórki, aby zwiększyć i wydrukować, zrób to samo dla siódmej komórki, a następnie wróć do piątej komórki i zmniejsz ją. Po 26 iteracjach wydrukowaliśmy Aa...Zz.

Rubin, 42 bajty

->{[*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`]}

Funkcja, która zwraca tablicę znaków. Program, który wyświetla tylko znaki, ma 49 bajtów:

$><<([*?/...?:,*?@...?[,*?`...?{]-[?/,?@,?`])*''

To po prostu używa znaków ascii po obu stronach odpowiednich zakresów, aby zdefiniować zakres. Na przykład ?/...?:oznacza znaki między ukośnikiem i dwukropkiem, z wyłączeniem końca. Aby pozbyć się początków, odejmujemy tablicę zawierającą trzy początkowe znaki.

6502 język maszynowy, 74 70 68 bajtów

Zrzut heksadecymalny (programy 6502 zasadniczo nie są relokowalne; kod tutaj jest przechowywany od lokalizacji 0603 $):

0600:          a9 24 0a 8d 20 06 8d 21 06 8d 23 06 8d 
0610: 25 06 09 20 8d 1a 06 8d 1c 06 ea aa ea a8 a9 00 
0620: ea ea 98 ea 8a ea a2 ff a9 7b a0 60 20 3a 06 a9 
0630: 5b a0 40 20 3a 06 a9 3a a0 2f 85 80 c8 e8 98 95 
0640: 00 c8 c4 80 d0 f7 60

Widać, że nie wykorzystuje to żadnego z zabronionych bajtów: od 41 do 5 USD, od 61 do 7 USD lub od 30 do 39 USD.

Jest to funkcja bez argumentów, która po wywołaniu zwraca wskaźnik do tablicy znaków „abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789” u góry stosu, zgodnie ze standardowymi konwencjami wywoływania 6502.

Dla wyjaśnienia, oto demontaż:

Adres Demontaż Hexdump
-------------------------------
0603 a9 24 LDA # 24 USD
0605 USD 0 ASL A.
0606 8d 20 06 STA 0620 $
0609 8d 21 06 STA 0621 $
060c 8d 23 06 STA 0623 $
060 $ 8d 25 06 STA 0625 $
0612 09 20 ORA 20 USD
0614 8d 1a 06 STA 061a
0617 8d 1c 06 STA 061c
061 USD za sztukę NOP 
061 mld USD PODATKU 
061 USD za sztukę NOP 
061D a8 DZISIAJ 
061 USD a9 00 LDA # 00 USD
0620 USD za sztukę NOP 
0621 USD rocznie NOP 
0622 98 TYA 
0623 USD rocznie NOP 
0624 $ 8a TXA 
0625 USD za sztukę NOP 
0626 $ a2 ff LDX # $ ff
0628 a9 7b LDA # 7 mld $
062 USD a0 60 LDY # 60 USD
062c 20 3a 06 JSR 063a
062 $ a9 5b LDA # 5 mld $
0631 a0 40 LDY # 40 USD
0633 20 3a 06 JSR 063a
0636 a9 3a LDA # 3a
0638 $ a0 2f LDY # 2f $
063 USD 85 80 STA 80 USD
063 $ c8 INY 
063 USD e8 INX 
063 USD 98 TYA 
063 USD z 95 00 STA 00 USD, X
0641 USD C8 INY 
0642 c4 80 CPY 80 USD
0644 d0 f7 BNE 063d
0646 USD 60 RTS

Kod języka maszynowego sam się modyfikuje. Do manipulacji na stosie musiałem użyć PHA i PLA do popchnięcia i wyjęcia akumulatora, ale instrukcje te mają kody 48 $ i 68 $, które są zabronione (są to kody ASCII dla liter „H” i „h”). Tak więc dla PHA biorę liczbę 24 USD, wykonuję przesunięcie arytmetyczne w lewo (ASL) i przechowuję powstałe 48 USD w czterech miejscach w kodzie, w których trzeba ją wykonać. Następnie, w przypadku PLA, używam bitowego OR na 48 USD w akumulatorze, aby obliczyć 68 USD i przechowywać go w dwóch miejscach w kodzie, gdzie jest to potrzebne.

Było kilka instrukcji innych niż PHA i PLA, których również nie mogłem zastosować, ponieważ ich kody operacyjne są takie same jak litery lub cyfry ASCII, ale znalazłem bezpośrednie obejścia tych innych.

Pożądana tablica znaków jest obliczana i przechowywana od położenia 0 (tak naprawdę nie ma znaczenia, gdzie jest przechowywana, ponieważ musimy tylko upewnić się, że wskaźnik do niej zostanie zwrócony na górze stosu).

Możesz to wypróbować w asemblerze i emulatorze Nicka Morgana 6502 . Oto zrzut ekranu; pole monitora u dołu pokazuje ciąg wyjściowy (w lokalizacjach od 00 $ do $ 3D) po uruchomieniu programu.

Haskell , 75 72 63 58 56 bajtów

__=[__|[_',ä]<-["/:","@[","`{"],__<-[_'..],_'<__,__<ä]

Wypróbuj online! Zadzwoń z __. Wynik:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Dzięki xnor, który zasugerował __i _'jako dwie bajty nazw zmiennych zamiast (!)lub podobnych, oszczędzając 9 bajtów. Szczególnie podoba mi się to, jak _'łamie podświetlanie składni. I jeszcze raz dziękuję xnor za uogólnienie zakresów, oszczędzając kolejne 4 bajty.
Edit: I okazało się, że znaki Unicode są dozwolone jako identyfikatory w Haskell, więc na przykład ä, ö... może być również używany jako dwóch identyfikatorów bajtowych. Ponieważ w programie pozostał jeden trzy bajtowy identyfikator, zastąpiłem go ä, oszczędzając kolejne 2 bajty.

Wyjaśnienie:

__i _'są poprawnymi nazwami zmiennych. Ze specyfikacji języka :

Identyfikator składa się z litery, po której następuje zero lub więcej liter, cyfr, znaków podkreślenia i pojedynczych cudzysłowów. [...] Podkreślenie, _jest traktowane jako mała litera i może występować wszędzie tam, gdzie jest to możliwe. Jednak _sam w sobie jest zastrzeżonym identyfikatorem, używanym jako symbol wieloznaczny we wzorach.

Więc kod jest równoważny z

s = [x|[a,b]<-["/:", "@[", "`{"], x<-[a..], a<x, x<b]

Na liście zrozumieniem azostaje związany '/'i bdo ':'( "/:"odpowiada ['/',':'], więc dopasowywanie do wzorca powiedzie). Następnie zakres [a..]tworzy ciąg wszystkich znaków większy równy '/':

"/0123456789:;<=>?@ABCDE ... \1114110\1114111"

Dla każdego znaku xw tym ciągu jest następnie sprawdzane, czy '/'<xi x<':', w wyniku czego powstają znaki 0123456789. Następnie ai bsą przyłączone @ i [, uzyskując znaków ABCDEFGHIJKLMNOPQRSTUVWXYZi tak dalej.

Perl (5.10 lub 5.12), 30 29 bajtów

Ten program składa się głównie z niedrukowalnych znaków, więc oto zrzut heksowy:

00000000: 5f 3d 7e 7e 22 d7 c0 84 8c 9e 86 df 9e d1 d1 85 _=~~"...........
00000010: d3 be d1 d1 a5 d3 cf d1 d1 c6 82 d6 22          ............"

Ten program jest bardzo prosty: regexujemy ( =~) znak podkreślenia ( _; dzięki @Dennis za wskazanie, że to działa) przeciwko wyrażeniu regularnemu. Wyrażenie regularne jest określone jako wyrażenie, a nie dosłownie; w szczególności bierzemy bitowe uzupełnienie ( ~) ciągu. Odwracając bitowe dopełnienie, aby dostać się do bazowego ciągu, otrzymujemy następujący regex, który jest wykonywany:

(?{say a..z,A..Z,0..9})

W wersjach Perla 5.10 i 5.12 (?{…})składnia była składnią eksperymentalną umożliwiającą regexom uruchamianie dowolnego kodu w czasie wykonywania. W tym przypadku używamy go do uruchomienia prostego programu Perl do wydrukowania pożądanego wyjścia. (Wersji wcześniejszych niż 5.10 nie można używać, ponieważ ich nie mają say.)

Nowoczesne wersje Perla są (?{…})domyślnie wyłączone ze względów bezpieczeństwa, ale jeśli masz taką wersję Perla, możesz wyłączyć sprawdzanie (a tym samym uruchomić ten program) za -Mre=evalpomocą argumentu wiersza poleceń (wraz ze standardem -M5.010określającym wersję języka do wdrożenia, który nie jest wliczany do liczby bajtów).

Właściwie 8 5 4 bajtów

'>┘▀

Jak to działa:

 '>    Pushes > onto the stack as a string
           STACK: [>]
    ┘  Converts the top item of the stack to it's ordinal
           STACK: [62]
     ▀ Push all digits from base n(top item of the stack)
           STACK: [012...xyz]

Wydruk jest niejawny na końcu programu.

Edycja 1: Zastąpiono wstawianie alfabetu małymi / dużymi literami, a następnie zakresu liczb (10), po prostu otrzymywanie drukowanych znaków bazy 62.

Edycja 2: zmieniono „>” na „> dzięki Mego :) zapisano 1 bajt.

Wypróbuj online!

PHP, 69 bajtów

<?=~"ÏÎÍÌËÊÉÈÇƾ½¼»º¹¸·¶µ´³²±°¯®­¬«ª©¨§¦¥žœ›š™˜—–•”“’‘ŽŒ‹Š‰ˆ‡†…";

Kod jest stylizowany przy użyciu Windows-1252 tutaj. Poniżej znajduje się odwracalny zrzut xxd .

00000000: 3c 3f 3d 7e 22 cf ce cd cc cb ca c9 c8 c7 c6 be  <?=~"...........
00000010: bd bc bb ba b9 b8 b7 b6 b5 b4 b3 b2 b1 b0 af ae  ................
00000020: ad ac ab aa a9 a8 a7 a6 a5 9e 9d 9c 9b 9a 99 98  ................
00000030: 97 96 95 94 93 92 91 90 8f 8e 8d 8c 8b 8a 89 88  ................
00000040: 87 86 85 22 3b                                   ...";

Wypróbuj online!

Java (OpenJDK 9) , 277 bajtów

Tak, Java, dobrze to czytasz!

$->""+($='='+'=')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='-'+'-')+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+--$+($='_'-'&')+--$+--$+--$+--$+--$+--$+--$+--$+--$

Wypróbuj online!

Spowoduje to wydrukowanie zakresów, ale zostanie odwróconych, ponieważ kolejność nie ma znaczenia.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Grałem przy braku reguły „brak danych wejściowych”, aby domyślnie zdefiniować, charktóra jest wymagana, aby całość działała. Jeśli to oszustwo, powiedz to.

Niekluczone i testowanie

public class PCG105781 {
  interface X { String apply(char x); }

  public static void main(String[] args) {
    X x = $
        -> "" // Force the result as a String.
        // The line below appends "zyxwvutsrqponmlkjihgfedcba"
        // '=' + '=' is 122 as int. $=122 casts 122 as a char, 'z'
        + ($ = '=' + '=') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "ZYXWVUTSRQPONMLKJIHGFEDCBA"
        // '-' + '-' is 90 as int. $=90 casts 90 as a char, 'Z'
        + ($ = '-' + '-') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
        // The line below appends "9876543210"
        // '_' - '&' is 57 as int. $=57 casts 57 as a char, '9'
        + ($ = '_' - '&') + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$ + --$
      ;

    System.out.println(x.apply('_'));
  }
}

Brainfuck, 89 85 bajtów

Ponieważ i tak mózg ignoruje znaki alfanumeryczne, jest to tylko wyzwanie o stałej wydajności ... (Edycja: Zobacz rozwiązanie Dennisa dla wersji o 10 bajtów krótszej)

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

Wypróbuj online!

Ten kod jest dobrym przykładem podstawowych zliczonych pętli w pieprzeniu mózgu:

+[-[--<]>>--]   Create value 47: char just before '0'
++++++++++      Set adjacent cell to 10: to be used as a counter

[               While the counter is not 0:
 <+.              Increment and print the char
    >-            Decrement the counter
       ]        (End loop: Exits when all digits have been printed)


<++++++++>           The char is now at '9' so add 8 to make it 'A'
+[-[---<]>>-]<-      In another cell create lowercase 'a'
<<+++++[>+++++<-]>+  Create 26: the number of times to loop

[                While the counter is not 0:
 >.+               Print and increment the lowercase char
    <<<.+          Print and increment the uppercase char
         >>-       Decrement the counter
            ]    (End loop: Exits when all letters have been printed)

Zauważ, że używa to skrótów zawijania do generowania liczb, co oznacza, że ​​interpreter musi mieć 8-bitowe zawijające komórki (takie jak ta, z którą się łączyłem).

JavaScript (ES6), 983 bajty

Okazuje się, że w ES6 jest wiele znaków, których można używać w nazwach zmiennych JavaScript ! Działa świetnie po wyczerpaniu sześciu 1-2-bajtowych nazw zmiennych przy pomocy $i _.

_=~[]
$={}
Á=++_
À=![]+""
Â=À[_]
Ã=++_
Ä=À[_]
Å=++_
Æ=($+"")[_]
Ç=(_[_]+"")[_]
È=++_
É=(!""+"")[_]
Ë=++_
Ì=++_
Ê=($+"")[_]
Í=++_
µ=++_
Î=++_
Ï=++_
_="\\"
Ð=$.$
È_=(!""+"")[Ã]
Å_=$+""
Ñ=Å_[Ã]
Ò=(Ð+"")[Ã]
__=Å_[Í]
Ó=(!""+"")[Å]
$_=Å_[Ì]+Ñ+Ò+(!$+"")[È]+__+È_+Ó+Å_[Ì]+__+Ñ+È_
$$=È_+(!""+"")[È]+__+Ó+È_+Ò
$=Á[$_][$_]
$($($$+"\""+Ê+Ñ+_+Ã+Ì+Í+_+Ã+Í+È+Ñ+À[Å]+É+"."+À[Å]+Ñ+_+Ã+Ë+µ+"('"+Ä+Æ+Ê+Ç+É+Â+_+Ã+Ë+µ+_+Ã+Ì+Á+_+Ã+Ì+Ã+_+Ã+Ì+Å+_+Ã+Ì+È+À[Å]+_+Ã+Ì+Ì+_+Ã+Ì+Í+Ñ+_+Ã+Í+Á+_+Ã+Í+Ã+_+Ã+Í+Å+_+Ã+Í+È+__+Ó+_+Ã+Í+Í+_+Ã+Í+µ+_+Ã+µ+Á+_+Ã+µ+Ã+_+Ã+µ+Å+_+Ã+Á+Ã+_+Ã+Á+Å+_+Ã+Á+È+_+Ã+Á+Ë+_+Ã+Á+Ì+_+Ã+Á+Í+_+Ã+Á+µ+_+Ã+Ã+Á+_+Ã+Ã+Ã+_+Ã+Ã+Å+_+Ã+Ã+È+_+Ã+Ã+Ë+_+Ã+Ã+Ì+_+Ã+Ã+Í+_+Ã+Ã+µ+_+Ã+Å+Á+_+Ã+Å+Ã+_+Ã+Å+Å+_+Ã+Å+È+_+Ã+Å+Ë+_+Ã+Å+Ì+_+Ã+Å+Í+_+Ã+Å+µ+_+Ã+È+Á+_+Ã+È+Ã+_+Ã+È+Å+Ã+Å+È+Ë+Ì+Í+µ+Î+Ï+Á+"')\"")())()

JavaScript, 1223 bajty

To była moja odpowiedź, zanim dowiedziałem się o powyższym.

_=~[]
$={}
___=++_
____=![]+""
$$$$=____[_]
__$=++_
$_$_=____[_]
_$_=++_
$_$$=($+"")[_]
$$_$=(_[_]+"")[_]
_$$=++_
$$$_=(!""+"")[_]
$__=++_
$_$=++_
$$__=($+"")[_]
$$_=++_
$$$=++_
$___=++_
$__$=++_
_="\\"
_$_$=$.$
_$$_=(!""+"")[__$]
_$__=$+""
_$=_$__[__$]
__$_=(_$_$+"")[__$]
__=_$__[$$_]
___$=(!""+"")[_$_]
$_=_$__[$_$]+_$+__$_+(!$+"")[_$$]+__+_$$_+___$+_$__[$_$]+__+_$+_$$_
$$=_$$_+(!""+"")[_$$]+__+___$+_$$_+__$_
$=___[$_][$_]
$($($$+"\""+$$__+_$+_+__$+$_$+$$_+_+__$+$$_+_$$+_$+____[_$_]+$$$_+"."+____[_$_]+_$+_+__$+$__+$$$+"('"+$_$_+$_$$+$$__+$$_$+$$$_+$$$$+_+__$+$__+$$$+_+__$+$_$+___+_+__$+$_$+__$+_+__$+$_$+_$_+_+__$+$_$+_$$+____[_$_]+_+__$+$_$+$_$+_+__$+$_$+$$_+_$+_+__$+$$_+___+_+__$+$$_+__$+_+__$+$$_+_$_+_+__$+$$_+_$$+__+___$+_+__$+$$_+$$_+_+__$+$$_+$$$+_+__$+$$$+___+_+__$+$$$+__$+_+__$+$$$+_$_+_+__$+___+__$+_+__$+___+_$_+_+__$+___+_$$+_+__$+___+$__+_+__$+___+$_$+_+__$+___+$$_+_+__$+___+$$$+_+__$+__$+___+_+__$+__$+__$+_+__$+__$+_$_+_+__$+__$+_$$+_+__$+__$+$__+_+__$+__$+$_$+_+__$+__$+$$_+_+__$+__$+$$$+_+__$+_$_+___+_+__$+_$_+__$+_+__$+_$_+_$_+_+__$+_$_+_$$+_+__$+_$_+$__+_+__$+_$_+$_$+_+__$+_$_+$$_+_+__$+_$_+$$$+_+__$+_$$+___+_+__$+_$$+__$+_+__$+_$$+_$_+__$+_$_+_$$+$__+$_$+$$_+$$$+$___+$__$+___+"')\"")())()

Przebiegłem console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')przez jjencode i ręcznie wybrałem wynik golfa. Istnieje zdecydowanie więcej optymalizacji, które można wykonać.

Befunge, 73 72 59 57 55 53 bajtów

"{"< ^+`"`"\+*`\":"\`"/":\*`\"["\`"@":::::-!!
#@_^,_!

Wypróbuj online!

Jest to pojedyncza pętla odliczająca od {(tj. Jeden znak po z). Podczas pierwszej iteracji "{"<sekwencja wypycha dwie kopie {na stos - jedna jest początkowym licznikiem pętli, a druga służy do zmniejszania tego licznika za pomocą sekwencji !!-(dwie wartości NIE 1, które są następnie odejmowane). Podczas kolejnych iteracji licznik pętli znajduje się już na stosie, więc tylko jedna {jest wymagana do ustawienia sekwencji zmniejszania.

Reszta kodu to po prostu długie wyrażenie logiczne obliczające, czy znak znajduje się w zakresie. Jeśli tak, gałąź w drugim wierszu dzieli się w lewo, aby zapisać wartość. Jeśli nie, prawy oddział zawija się, aby sprawdzić, czy osiągnęliśmy zero i powinniśmy zakończyć. Dwie gałęzie łączą się w środku, aby przejść w górę i powtórzyć pętlę. Zauważ, że wszystkie polecenia kierunku pionowego idą w górę, ponieważ nie możemy użyćv , ale to dobrze, ponieważ wskaźnik instrukcji automatycznie zawija się u góry pola gry.

Dzięki Mistah Figgins za początkowe opracowanie lepszej techniki przyrostu pętli.

Ale specjalne podziękowania dla Jo King za jeszcze lepsze podejście odliczanie niż wzrost, a także za bardziej kompaktowy układ gałęzi.

Galaretka , 17 16 bajtów

“:[{“/@`‘Ḷḟ"/ỌḊ€

Wypróbuj online!

Jak to działa

“:[{“/@`‘Ḷḟ"/ỌḊ€  Main link. No arguments.

“:[{“/@`‘         Yield [[58, 91, 123], [47, 64, 96]].
         Ḷ        Unlength; map each n to [0, ..., n-1].
          ḟ"/     Reduce by vectorizing filter-false.
                  This yields [[47, ..., 57], [64, ..., 90], [96, ..., 122]].
             Ọ    Unordinal; replace each n with the corr. Unicode character.
              Ḋ€  Deqeue each; remove the first character of each of the three
                  generated strings ('/', '@', and '`').

Samomodyfikujący Brainfuck , 32 bajty

<[-<+.>]<<[-<+.>]<<[-<+.>]`@/

Wypróbuj online!

xxd -r-wracalny zrzut heksadecymalny (zawiera niedrukowalne):

00000000: 3c5b 2d3c 2b2e 3e5d 3c3c 5b2d 3c2b 2e3e  <[-<+.>]<<[-<+.>
00000010: 5d3c 3c5b 2d3c 2b2e 3e5d 601a 401a 2f0a  ]<<[-<+.>]`.@./.

C, 128 bajtów

Tak, C. I nawet krótszy niż kilka ezoterycznych.

__($$,_,$,_$,$_){$>_$?_$=_$?!$:$,$=*(""-_+$_++)&*"{":_;_$?*(""-_+$$++)=$++:_;$&&__($$,_,$,_$,$_);}_(_){__(_,"",_,!!_,"½´ÞÅþå");}

Wezwij _dostatecznie duży, pusty char *bufor.

_{Może być zależny od kompilatora bitów tee. Testowane przy użyciu GCC; plik został zapisany na stronie kodowej 1252.}

JavaScript (ES6), 812 745 657 650 536 520 416 bajtów

(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))

Edycja: przy użyciu kodowania ISO8859-1 to rozwiązanie ma 416 bajtów zamiast 520 bajtów. Pełny program ma 432 bajty, biorąc pod uwagę dodatkowe 16 bajtów dla

f=\r\n
416 byte submission here\r\n
alert(f())

Jest to przesłanie funkcji, w przeciwieństwie do pełnego programu. Spędziłem dość dużo czasu grając w golfa JJEncode (za to polecam darrylyeo ), ale zamiast grać w golfa

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Grałem w golfa

for($ of[[48,58],[65,91],[97,123]])for(_=$[0];_<$[1];)Ø+=String.fromCharCode(_++);return Ø

gdzie Øjest inicjowany ""w kosztach ogólnych.

Przepisane z operatorami przecinków przekonwertowanymi na nowe linie:

À=(Á=!($={})+(Ø=""))[Â=_=+[]]
Ã=(Ä=!_+Ø)[Å=++_]
Æ=(Ç=$+Ø)[_]
È=(É=$.$+Ø)[_]
Ê=Ä[Ë=++_]
Ì=Ä[Í=++_]
Î=++_
Ï=Ç[Ð=++_]
Ñ=Ç[Ò=++_]
Ó=++_
$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô]
// function that returns string
$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)())

Wyjaśnienie

Ten skrypt rozpoczyna się od zainicjowania kilku wbudowanych typów i zmuszenia ich do ciągów znaków. Ciągi, które możemy uzyskać bez użycia znaków alfanumerycznych, to:

{}+""     -> "[object Object]"
!{}+""    -> "false"
!+[]+""   -> "true"
{}[{}]+"" -> "undefined"

Z tych ciągów i niezbędnych cyfr w celu odniesienia do poszczególnych znaków, możemy uzyskać ciągi returni constructor, które mogą być używane w następujący sposób:

$={}[Ô="constructor"][Ô]
$(("return"+`"encoded script"`)())

Konstruktor obiektu jest Object(), a jego konstruktorem jest Function(), którego możemy zasadniczo użyćeval() .

W tym przypadku kodowany skrypt do wykonania jest zagnieżdżony for pętla łącząca wszystkie znaki alfanumeryczne z ciągiem znaków przy użyciu ich punktów kodowych i zwracająca go.

W przypadku znaków alfabetycznych w kodowanym skrypcie, do których nie można uzyskać dostępu za pomocą wbudowanych funkcji, JJEncode używa ósemkowych znaków ucieczki do ich reprezentowania, a następnie dekoduje cały ciąg znaków, zwracając go z funkcji wewnętrznej. Następnie można wywołać funkcję zewnętrzną w celu wykonania źródła.

Próbny

f=
(À=(Á=!($={})+(Ø=""))[Â=_=+[]],Ã=(Ä=!_+Ø)[Å=++_],Æ=(Ç=$+Ø)[_],È=(É=$.$+Ø)[_],Ê=Ä[Ë=++_],Ì=Ä[Í=++_],Î=++_,Ï=Ç[Ð=++_],Ñ=Ç[Ò=++_],Ó=++_,$=$[Ô=Ï+Æ+È+Á[Í]+Ñ+Ã+Ê+Ï+Ñ+Æ+Ã][Ô],$($((Õ=Ã+Ä[Í]+Ñ+Ê+Ã+È)+`"${Ù=($=À)+Æ+(Ö=Ô[Ð])}($ ${[Æ+$+"[["+Î+ ++_,Ø+Ð+_+"],["+Ò+Ð,Ø+ ++_+Å+"],["+_+Ó,Ú=Ø+Å+Ë+Í]}]])${Ù}(_=$[Â];_<$[Å];)Ø+=${(_="\\")+Ú+Ñ+Ö+(Û=(_=_+Å)+Ð)+Å+Ô[Ë]+_+Î+Ó}.${$+Ö+Æ+Û+Ð+_+Â+Í+Û+Â+Á[Å]+Ö+_+Â+Í+Æ+É[Ë]+Ì}(_++);${Õ} Ø"`)()))
console.log(f())

Brain-Flak , 171 bajtów

Obejmuje +3 za -A

(((((()()()){}){}){}){})(((()()())){}{}){({}[()]<(({})())>)}{}(({})(()()()()){})(((((()()()){}){}){}())<{({}[()]<(({})())>)}{}(({})(()()()){}())>){({}[()]<(({})())>)}{}

Wypróbuj online!

(((((()()()){}){}){}){}) # push 48
(((()()())){}{})         # push 9
{({}[()]<                # for 9..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()()){})       # pop a, push a, push a + 8
(((((()()()){}){}){}())< # push 26 and save a 26 for later
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for
(({})(()()()){}())       # pop a, push a, push a + 7
>)                       # push that 26 that we held
{({}[()]<                # for 26..0
(({})())                 # pop a, push a, push a+1
>)}{}                    # end for

Prawdopodobnie istnieje sposób, aby to zrobić bez powtarzania „funkcji” dodawania 1.

Julia 0.4 , 46 bajtów

_()=['¥':'®';'¶':'Ï';'Ö':'ï'].-['~'-'	']

Jest to ogólna funkcja zwracająca tablicę znaków.

Wypróbuj online!

Wersja alternatywna, 47 bajtów, tylko ASCII

_(_=_==_)=['/'+_:':'-_;'@'+_:'['-_;'`'+_:'{'-_]

Wypróbuj online!

J, 171 bajtów

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Ow ... mój mózg boli ... Wypróbuj online!

Oto, dlaczego możesz zobaczyć wszystko w jednym wierszu (jednak nie będzie działał z podziałem wierszy).

(+:>.+:^^*_){.".(':',~(+:+:>.^*_){(*:>.^*_)!:(+:<.^+:*_)''),',',(":(>:*:+:+:+:*_),(<.^<:^<:^*
_),<:*:<.^+:*_),'+/',('.',~(+:<.+:^*_){(*:>.^*_)!:(+:<.^+:*_)''),":+:<.*:>:^*_

Gwarantowana tylko praca z wersją J j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52, w tej kolejności. (Tylko pierwsze 12 znaków ma znaczenie.)

Wyjaśnienie

Większość programu poświęcona jest ciągłemu generowaniu. Po zastąpieniu tych stałych ich wartościami program wygląda następująco:

(62){.".(':',~(12){(9)!:(14)''),',',(":(65),(97),48),'+/',('.',~(10){(9)!:(14)''),":26

Po usunięciu niektórych nawiasów i poprawieniu niektórych liczb:

62{.".(':',~12{9!:14''),',',(":65 97 48),'+/',('.',~10{9!:14''),":26

Ten składa się z bandą ,i ,~S, które poprzedzić Append i argumentów. Oto osobne wartości:

1. ":26
2. ('.',~10{9!:14'')
3. '+/'
4. (":65 97 48)
5. ','
6. (':',~12{9!:14'')

1jest 26jak ciąg.

9!:14'' generuje następujący ciąg znaków na TIO:

j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52

z 2, otrzymujemy 10th znak ( iod linux) i dodajemy .go na końcu, dając i..

3i 5są oczywiste.

4to lista liczb 65 97 48w postaci ciągu.

6jest podobny do 2, z tym wyjątkiem, że jest to 12znak th ( ufrom linux) i dodaje :na końcu a, dającu: .

To wszystko razem daje u:,65 97 48+/i.26. ".ocenia to, dając nam:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Uwaga: +/ jest uzupełnieniem tabelarycznym).

Następnie, z 62{., bierzemy z tego pierwsze 62postacie, dając nam ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 bajtów

-4 dzięki Adnanowi, ponieważ jeśli rozmiar wejściowy to 1, 05AB1E użyje 0 dla b przy pierwszym poleceniu.

•£•Ýç©á®þ«˜

Wypróbuj online!

•£•Ÿ            # Push [0..122] using implicit 0 and the base-214 of `£`.
    ç           # Convert to ASCII chars.
     ©          # Store full array in register.
      á         # Push the same array with ONLY letters.
       ®        # Push contents of register (char)[0..122].
        þ       # Push only the digits.
         «˜     # Concat to list, flatten it. 

Próbowałem tak wielu różnych podejść, ale kluczowe kwestie, które utrudniały to:

- Basic commands will not work, only extended and a select few of the basics.
- Extended commands are pretty complex.
- Eval (.V) will not work.
- To push numbers you can do a base 214 compression.
- ALL sequence pushes (E.G. žK) won't work.
- ALL number pushes won't work, except for compression and the -1 an empty register pushes.

Brainfuck, 55 bajtów

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

Wynik:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Wypróbuj online!

Inicjuje taśmę do 3,2 ⁿ i działa od tego momentu .

+++[[<+>->++<]>]    initialize the tape
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 | 192 | 128 |   0 |   0 |
                                                                                    ^
<<[-<->]            subract 128 from 192
                    |   0 |   3 |   6 |  12 |  24 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                                        ^
<<<<++              increment 24 twice
                    |   0 |   3 |   6 |  12 |  26 |  48 |  96 |  64 |   0 |   0 |   0 |
                                                ^
[->>+.>+.<<<]       output aAbBcC ~ zZ
                    |   0 |   3 |   6 |  12 |   0 |  48 | 122 |  90 |   0 |   0 |   0 |
                                                ^
<--[->>.+<<]        decrement 12 twice; output 0 ~ 9
                    |   0 |   3 |   6 |   0 |   0 |  58 | 122 |  90 |   0 |   0 |   0 |
                                          ^

Perl 6 , 43 bajty - niekonkurujące

{|('`'^..^'{'),|('@'^..^'['),|('/'^..^':')}

Lambda, która zwraca listę znaków.
Wyjaśnienie:

   '`'                                       # The character before "a" (in Unicode order)
          '{'                                # The character after "z"
      ^..^                                   # Endpoint-exclusive range between them
 |(          )                               # Slip the range into the outer list
               |('@'^..^'[')                 # Same thing for "A" to "Z"
                             |('/'^..^':')}  # Same thing for "0" to "9"

Zależy od poprawki błędu w interpretatorze Rakudo Perl 6, który został dzisiaj zaangażowany tylko w repozytorium git i nie jest jeszcze częścią oficjalnej wersji Rakudo. W rzeczywistości napotkałem błąd podczas odpowiadania na to wyzwanie i udało mi się go naprawić przy pomocy jednego z głównych deweloperów Perla 6. Zasady tej witryny, tak jak je rozumiem, nie pozwalają na konkurowanie odpowiedzi w takiej sytuacji, dlatego oznaczyłem ją jako niekonkurencyjną.

PHP 7.0+, 110 bajtów

Niech Bóg błogosławi bitowe łańcuchy!

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^_,'%'^_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^_));

Zamień na \nprawdziwą nową linię w stylu * NIX.
Jest obecny w kodzie, aby uniknąć problemów z nowymi liniami, ale nie jest liczony w wyniku.

To rzuca wiele ostrzeżeń, ale można je stłumić, umieszczając @przed każdym zabłąkanym _.

Bez ostrzeżenia , 113 bajtów

<?=($__='`@`@'^'*/).')(($_='->.<:'^'__@[_')('>'^@_,'%'^@_)),$__($_('|'^'=','|'^'&')),$__($_(':'^"\n",';'^']'^@_));

65c02 język maszynowy + Apple] [ROM, 25 bajtów

A9 E0 20 0F 80 A9 C0 20 0F 80 A2 0A A9 AF 2C A2 1A 1A 20 ED FD CA D0 F9 60

Wydruki abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Powinien zacząć od $8000.

Demontaż

8000-   A9 E1       LDA   #$E0
8002-   20 0F 80    JSR   $800F
8005-   A9 C1       LDA   #$C0
8007-   20 0F 80    JSR   $800F
800A-   A2 0A       LDX   #$0A
800C-   A9 B0       LDA   #$AF
800E-   2C          HEX   2C     ; SKIPS NEXT 2 BYTES
800F-   A2 1A       LDX   #$1A
8011    1A          INC   
8012-   20 ED FD    JSR   $FDED
8015-   CA          DEX   
8016-   D0 F9       BNE   $8011
8018-   60          RTS   

bash (na Linuksie), 507 493 490 485 bajtów

przechowuje tablicę znaków w zmiennej globalnej __

: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
__=(/????/????/??/??)
___=${__%??}
__=(${__[@]#$___?})
____=${___#/*/?}
____=${____%?/*/}
_____=${____%?}
____=${____#?}
___=${___%??/}
______=($___*_??)
______=${______#$___???????}
______=${______%??_*}
_______=($___$_____???*)
_______=${_______#$___??}
_______=${_______%????}
___=$#
___=$((++___))$((___+++++___+___--))$___
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
__=(${__[@]} ${___[@]} ${___[@]^})

należy go wykonać na świeżo uruchomionym komputerze z systemem Linux /proc lub w przestrzeni nazw pid

wyjaśnienie:

# {var}>file opens a file descriptor >= 10 to that file
: {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_ {_}>_
# at startup no pid is > 999 so there's no other /proc/pid/fd/??
__=(/????/????/??/??)                                 # /proc/self/fd/1[0-9]
___=${__%??}                                          # /proc/self/fd/
__=(${__[@]#$___?})                                   # {0..9}
____=${___#/*/?}                                      # elf/fd/
____=${____%?/*/}                                     # el
_____=${____%?}                                       # e
____=${____#?}                                        # l
___=${___%??/}                                        # /proc/self/
______=($___*_??)                                     # /proc/self/timerslack_ns
______=${______#$___???????}                          # ack_ns
______=${______%??_*}                                 # a
_______=($___$_____???*)                              # /proc/self/environ
_______=${_______#$___??}                             # viron
_______=${_______%????}                               # v

___=$#                                                # 0
___=$((++___))$((___+++++___+___--))$___              # 172 (z in octal)

# eval eval                   ___="\({a..$'\172'}\)"
$_____$_______$______$____{,} ___="\({$______..$'\\$___'}\)"
#   {0..9}   {a..z}    {A..Z}
__=(${__[@]} ${___[@]} ${___[@]^})

aby to wypróbować, możemy dodać declare -p __na końcu, aby wyświetlić wynik

$ sudo unshare --fork --pid --mount-proc bash golf
declare -a __=([0]="0" [1]="1" [2]="2" [3]="3" [4]="4" [5]="5" [6]="6" [7]="7" [8]="8" [9]="9" [10]="a" [11]="b" [12]="c" [13]="d" [14]="e" [15]="f" [16]="g" [17]="h" [18]="i" [19]="j" [20]="k" [21]="l" [22]="m" [23]="n" [24]="o" [25]="p" [26]="q" [27]="r" [28]="s" [29]="t" [30]="u" [31]="v" [32]="w" [33]="x" [34]="y" [35]="z" [36]="A" [37]="B" [38]="C" [39]="D" [40]="E" [41]="F" [42]="G" [43]="H" [44]="I" [45]="J" [46]="K" [47]="L" [48]="M" [49]="N" [50]="O" [51]="P" [52]="Q" [53]="R" [54]="S" [55]="T" [56]="U" [57]="V" [58]="W" [59]="X" [60]="Y" [61]="Z")

JavaScript, 1273 1351 1610 bajty

To rozwiązanie działa w zasadzie tak samo jak dwóch innych odpowiedzi dotyczących tego wątku tutaj i tutaj , gdzie używa litery z true, false, undefinedi [object Object]ciągów zbudować funkcje potrzebne do wygenerowania inne litery.

Ponieważ znaczna liczba liter jest już umieszczona w obiekcie, próbowałem dodać wszystkie pozostałe małe litery i cyfry do obiektu, a następnie zastosowałem toUpperCasedo wszystkich wartości w obiekcie, aby wygenerować brakujące duże litery.

Aktualizacja:

Udało mi się poprawić sposób ustawiania wartości ósemkowych, ale nadal zajmują one 13 x 30 bajtów (lub będą miały 30 bajtów każdy po zmianie liczb na różne klucze), teraz każdy podąża za tym ogólnym wzór: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Dodatkowe 49 bajtów można łatwo wyjąć, przełączając klawisze cyfr na znaki 2-bajtowe.

Aktualne zgłoszenie:

$=~[];_={ť:!""+"",ň:![]+"",û:$._+'',ô:{}+"",ø:''};$={零:++$,ƒ:_.ň[$],ť:_.ť[$],一:++$,â:_.ň[$],ř:_.ť[$],ô:_.ô[$],ň:_.û[$],二:++$,ľ:_.ň[$],û:_.ť[$],ƅ:_.ô[$],ď:_.û[$],三:++$,ŝ:_.ň[$],ĵ:_.ô[$],四:++$,ě:_.ň[$],五:++$,ĉ:_.ô[$],î:_.û[$],六:++$,七:++$,八:++$,Ô:_.ô[$],九:++$};_.ĉ=$.ĉ+$.ô+$.ň+$.ŝ+$.ť+$.ř+$.û+$.ĉ+$.ť+$.ô+$.ř;_.ř=$.ř+$.ě+$.ť+$.û+$.ř+$.ň;_.ƒ=(0)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()

C (brzęk) , 164 bajty

é,ú,í,ó;_(*$){ú-=ú;ú++;í=ú+ú;ó=í<<í*í<<ú;!é?é++,é<<=í*í+ú,é+=í<<í+ú:é;*$++=é++;é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú;é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú;é<í*ó-(í*í)-ú?_($):ú;}

Wypróbuj online!

Jest to funkcja rekurencyjna, która pobiera znaki, zaczynając od wartości 1 (odejmując od siebie i zwiększając), i tworzy z niej wszystkie inne liczby.

Nieskluczone / Wyjaśnienie:

é,ú,í,ó;
_(*$){ //function "_" taking a pointer "$"
	ú-=ú;ú++; //constant ú=1
	í=ú+ú; //constant í=2
	ó=í<<í*í<<ú; //constant ó=64
	!é?é++,é<<=í*í+ú,é+=í<<í+ú:é; //if é isn't initialized, seek to character '0'
	*$++=é++; //write to string and increase string index
	é+=é==ó-(í*í+í)?(í<<í)-ú:ú-ú; //skip to 'A'
	é+=é==ó+(í<<í<<í)-í*í-ú?í*í+í:ú-ú; //skip to 'a'
	é<í*ó-(í*í)-ú?_($):ú; //keep recursing until end of alphabet
}

CJam , 15 bajtów

"{`[@:/"_:,:^\-

Wypróbuj online!

Wyjaśnienie

"{`[@:/" e# Push this string. Note that these are the characters just above and
         e# below the a-z, A-Z and 0-9 ranges, respectively.
_        e# Get a copy of the string.
:,       e# Turn each character into a range, i.e. all characters from the null byte
         e# to the the character below the given one. E.g. { is turned into "...xyz".
:^       e# Fold symmetric set difference over the list. Gives us the characters that
         e# appear in an odd number of the strings. Those are the letters, the digits
         e# as well as `, @ and /.
\        e# Pull the other copy of the string on top.
-        e# Remove these characters from the string. That leaves only the alphanumerics.

𝔼𝕊𝕄𝕚𝕟, 8 znaków / 19 bajtów

ᶐ+ᶛ+⩥Ⅹă⬯

Wypróbuj tutaj!

ᶐjest wielkimi literami, ᶛjest małymi literami i ⩥Ⅹă⬯ma zakres ( ⩥) od 0do 10( Ⅹcyfra rzymska unicode) minus 1, połączone przez ( ă) nic ( ⬯).