Wydrukuj wszystkie znaki alfanumeryczne ASCII bez ich używania

51

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 , 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.
dkudriavtsev
źródło
8
To jest trochę niejednoznaczne. Jeśli masz na myśli generowanie nieprzetworzonych bajtów bez tych bajtów w kodzie, powinieneś określić, że nie możesz używać punktów kodowych tych znaków, nawet jeśli są one odwzorowane na coś innego na stronie kodowej twojego języka.
FlipTack,
11
Oznacza to, że nie mogę używać żadnych liter ani cyfr w moim kodzie źródłowym. Cóż, to prawie eliminuje wszelkie nie ezoteryczne języki.
R. Kap
2
Co jeśli język jest tylko surowymi bajtami (jako opcodes), które nie mają reprezentacji? Czy mogę używać dowolnych postaci?
FlipTack,
1
@Briantist jest w porządku, jeśli są wewnętrznie reprezentowane przez ints, ale same postacie muszą zostać wydrukowane.
dkudriavtsev
3
@ R.Kap Javascript może działać, pod warunkiem, że nie uważasz go za eso
Destructible Lemon

Odpowiedzi:

19

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
Kritixi Lithos
źródło
Niesamowity! +1 za pobicie mnie do tego. :) Ponadto, możesz to uprościć do jednego wyrażenia regularnego, jeśli tak zrobiłeś Ó×ü_(co jest równoważne z :s/\W\|_//g)
DJMcMayhem
50

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!

wada
źródło
7
+1za bycie pierwszym nie-ezoterycznym językiem w wyzwaniu bardzo odpowiednim dla esolangów.
DJMcMayhem
4
Duża +1, nie do używania Octave (jest dość prosta), ale do bardzo dobrej gry w golfa i używania _jako zmiennej! Nie miałem pojęcia, że ​​to możliwe ... Fajnie!
Stewie Griffin,
1
Po połączeniu z pustym ciągiem ([..., '']) liczby ponownie są konwertowane na znaki .... bardzo ładne
rahnema1
29

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.

Dennis
źródło
Niezły golf! Link do twojej odpowiedzi
FlipTack
25

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.

histocrat
źródło
Dobra robota. Widziałem to właśnie, gdy przyszedłem opublikować moją 60-bajtową wersję przy użyciu tego samego pomysłu.
AShelly,
3
Możesz zapisać jeden bajt z nieco innymi zakresami: $> << ([ (? / ...? {)] - [* (?: ..? @), * (? [..? `),? / ]) ''
AShelly,
To naprawdę jest ładne. Cóż, brzydkie. Wiesz co mam na myśli. Ładnie wykonane.
Wayne Conrad
22

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.

Mitchell Spector
źródło
16

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.

Laikoni
źródło
3
Możesz używać __i _'jako zmiennych.
xnor
@xnor Dzięki, nie wiedziałem o Underscore is treated as a lower-case letterregule.
Laikoni
1
Możesz zapisać niektóre bajty, uogólniając zakresy: _'_=[__|[_',__']<-["`{","@[","/:"],__<-[_'..],_'<__,__<__'](w zmiennych normalnych z=[x|[a,b]<-["`{","@[","/:"],x<-[a..],a<x,x<b]).
xnor
@xnor Jeszcze raz dziękuję! Świetny pomysł na połączenie początku i końca zakresów w ciąg. Próbowałem również uogólnić zakresy, ale zawsze kończyło się to dłużej bez tego pomysłu. Dodatkowy bajt można zapisać, wiążąc ciąg __zamiast, _'_ mimo że __jest on używany jako identyfikator w rozumieniu listy.
Laikoni
13

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


źródło
13

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!

Pelikan turkusowy
źródło
'>jest bajtem krótszym niż ">".
Mego
@Mego tak jest, edytowane :) dzięki.
Teal pelikan
11

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!

Dennis
źródło
10

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('_'));
  }
}
Olivier Grégoire
źródło
3
Czekaj, co?? Brakuje mi wszystkich rozwiązań JavaScript? o_O
Olivier Grégoire
To dlatego, że JavaScript nie ma char, w przeciwnym razie byłby to bułka z masłem. I szczerze mówiąc, moja odpowiedź jest krótsza niż odpowiedź początkowa. Spójrz na moje wyjaśnienie wszystkich kosztów ogólnych, przez które muszę przejść.
Patrick Roberts,
2
@PatrickRoberts Aby być uczciwym, powinniśmy porównać wstępną edycję do pierwszej edycji lub ostatnią edycję do ostatniej edycji, a nie wstępną edycję do ostatniej ...;) Uważnie przeczytałem, co zrobiono dla JavaScript, zwłaszcza że nie rozumiałem, jak mogłem uzyskać krótszą odpowiedź niż wszystkie JS.
Olivier Grégoire,
9

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

FlipTack
źródło
5
Brainfuck był pierwszym językiem, o którym myślałem. Szkoda, że ​​tego nie wiem. Niezła odpowiedź.
ElPedro,
7

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ć.

darrylyeo
źródło
Hej, do Twojej wiadomości opublikowałem codegolf.stackexchange.com/a/105854/42091, ponieważ wkładam w to dużo pracy i myślę, że wystarczająco różni się od twojej odpowiedzi.
Patrick Roberts,
Nie ma problemu, dobrze wyglądasz!
darrylyeo
Miły! Ta ostatnia aktualizacja pomogła mi uzyskać ponad 100 bajtów poza moim!
Patrick Roberts,
1
Jeśli zmienisz kodowanie na ISO8859-1 i pozostawisz go dokładnie tak, będzie to 769 bajtów.
Patrick Roberts,
7

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.

James Holderness
źródło
1
Jeśli na stosie nie ma nic oprócz licznika, możesz zmienić część przyrostową na \! + Jeśli tak, możesz: !! +. dla wartości niezerowych
MildlyMilquetoast
-2 bajty poprzez zmianę kolejności czeku na początku linii
Jo King
@JoKing Dobrze zauważony. Nie możemy użyć, vponieważ jest to ograniczone źródło, ale nadal działa równie dobrze z ^. Dzięki.
James Holderness
-2 bajty poprzez odliczanie w dół zamiast w górę i użycie dodatkowej kopii licznika w drugiej linii, aby sprawdzić, czy pętla się skończyła (tym razem pamiętano o ograniczonym źródle;))
Jo King
@JoKing Wow, jesteś naprawdę lepszy w golfie ode mnie! Dzięki jeszcze raz.
James Holderness
6

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 '`').
Dennis
źródło
Ponieważ galaretka ma własną stronę kodową, pomocne byłoby dołączenie
zrzutu heksowego
@FlipTack IIRC Strona kodowa Jelly jest kompatybilna z drukowalnym ASCII.
PurkkaKoodari
@FlipTack Pietu1998 ma rację. A nawet gdyby tak nie było, spec zabrania znaków, a nie bajtów.
Dennis
@Dennis W rzeczywistości banuje bajty na komentarze , chociaż jest to nadal aktualne (kompatybilne z ASCII).
Erik the Outgolfer
6

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  ]<<[-<+.>]`.@./.
Erik the Outgolfer
źródło
Czego @/zrobić?
Yytsi
@TuukkaX Istnieje 6 ostatnich znaków, `\x1a@\x1a/\nponieważ ich współrzędne kodowe są bardzo przydatne w grze w golfa. Nie możesz ich usunąć.
Erik the Outgolfer
@downvoter: Jeśli natkniesz się na ten post, usuń swoje zdanie. Zostało to już naprawione.
Erik the Outgolfer
Cieszę się, że nie jestem jedynym, który korzysta z SMBF. :)
mbomb007
@ mbomb007 Praktyczność :) Myślałem o BF, i przyszło im na myśl SMBF, więc mam przygotowane punkty kodowe. Ograniczenie nie kosztowało mnie bajtów, jak użyłem +.zamiast .+.
Erik the Outgolfer,
6

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.

Anonimowy
źródło
6

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

Patrick Roberts
źródło
5

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.

Riley
źródło
5

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!

Dennis
źródło
5

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.

Conor O'Brien
źródło
Możesz uzyskać stałą 14, <:<.^^*_która zapisuje bajt. Próbowałem również wygenerować cały zakres i usunąć symbole, aby uzyskać ':;<=>?@[\]^_`'-.~".(':',~(+:+:>.^*_){(*:>.^*_)!:(<:<.^^*_)''),":(#@}.@}.@}.@,~(+#\)],,~)(*:@#$])'+++++'104 bajty. Jestem pewien, że może być znacznie krótszy
mile
5

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.
Urna Magicznej Ośmiornicy
źródło
1
You may print them in arbitrary ordermówi wyzwanie.
AdmBorkBork
1
Działa •£•Ýç©á®þ«˜również?
Adnan
@Adnan miło, nie wiedziałem, że używa 0, gdy nie ma b.
Magic Octopus Urn
5

Brainfuck, 55 bajtów

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

Wynik:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Wypróbuj online!


Inicjuje taśmę do 3,2 n 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 |
                                          ^
primo
źródło
5

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ą.

smls
źródło
41 bajtów
Jo King
4

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",';'^']'^@_));
Ismael Miguel
źródło
3

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   
wstaw nazwę_tutaj
źródło
To narusza zasadę codepoint - po prostu używasz znaków z innego zestawu znaków. Bajty są OK, o ile nie są iteralne lub odczytywane przez kod.
dkudriavtsev
@ wat Ah, OK. Zmodyfikowałem swój kod, aby nie używał żadnych bajtów kodu maszynowego odwzorowanych na znaki alfanumeryczne w „normalnym” (dodatnim) ASCII i nie używał żadnych dodatnich lub ujemnych literałów alfanumerycznych ; czy to jest teraz ważne?
insert_name_here
Chyba tak ...
dkudriavtsev
@wat Obecnie używane są punkty kodu w porządku rosnącym 10, 15, 26, 32, 44, 96, 128, 162, 169, 175, 192, 202, 208, 224, 237, 249, 253, które odwzorowują znaki, w ↵.. ,`.¢©¯ÀÊÐàíùýktórych .s są znakami , które nie mogą być drukowane. Jest ważny
Patrick Roberts,
3

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")
izabera
źródło
+1. Myślę, że powinieneś podać to jako Bash w Linuksie, czego nie mają inne systemy operacyjne (np. MacOS) /proc. W rzeczywistości /procnie jest to absolutnie konieczne w Linuksie, chociaż prawdopodobnie trudno byłoby znaleźć nowoczesną dystrybucję bez niego.
Cyfrowa trauma
3

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)[_.ĉ][_.ĉ];_.ƒ(_.ƒ(_.ř+' "$.Û=\'\\'+$.一+$.二+$.五+'\';$.Ĉ=\'\\'+$.一+$.零+$.三+'\';$.Ě=\'\\'+$.一+$.零+$.五+'\';$.ĝ=\'\\'+$.一+$.四+$.七+'\';$.ĥ=\'\\'+$.一+$.五+$.零+'\';$.ǩ=\'\\'+$.一+$.五+$.三+'\';$.ӎ=\'\\'+$.一+$.五+$.五+'\';$.ƥ=\'\\'+$.一+$.六+$.零+'\';$.ǫ=\'\\'+$.一+$.六+$.一+'\';$.ư=\'\\'+$.一+$.六+$.六+'\';$.ŵ=\'\\'+$.一+$.六+$.七+'\';$.ӽ=\'\\'+$.一+$.七+$.零+'\';$.ŷ=\'\\'+$.一+$.七+$.一+'\';$.ž=\'\\'+$.一+$.七+$.二+'\';"')())();_.ƒ(_.ƒ(_.ř+' "_.â=\''+$.Ô+$.ƅ+$.ĵ+$.ě+$.ĉ+$.ť+'.'+$.ǩ+$.ě+$.ŷ+$.ŝ+'($).'+$.ƒ+$.ô+$.ř+$.Ě+$.â+$.ĉ+$.ĥ+'\';_.ƅ=\''+$.ť+$.ô+$.Û+$.ƥ+$.ƥ+$.ě+$.ř+$.Ĉ+$.â+$.ŝ+$.ě+'\';"')())();_.ƒ(_.ƒ(_.ř+' "'+_.â+'((ǩ)=>{$[ǩ.'+_.ƅ+"()]=($[ǩ]+'')."+_.ƅ+"()});"+_.â+"((ǩ)=>{_.ø+=$[ǩ];});"+$.â+$.ľ+$.ě+$.ř+$.ť+'(_.ø);"')())()
jaskółka oknówka
źródło
1
To wydaje się interesujące, ale w tej chwili nie jest bardzo golfa. Usunięcie białych znaków pozwoliłoby zaoszczędzić 74 bajty, pojedynczych cudzysłowów można użyć w przypadku ciągów zawierających podwójne cudzysłowy, a 3-bajtowe znaki Unicode można zastąpić tańszymi.
Dennis
@Dennis prawda, choć myślę, że największym problemem w tej chwili jest to, że ustawiono tak wiele znaków za pomocą kodów ósemkowych.
martin
3

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

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.
Martin Ender
źródło
2

𝔼𝕊𝕄𝕚𝕟, 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 ( ).

Conor O'Brien
źródło