Herausforderung

Drucken Sie die folgenden Zeichen:

abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890

Der Haken ist, dass Sie keinen von ihnen in Ihrem Code verwenden dürfen.

Sie können sie in beliebiger Reihenfolge mit oder ohne führende oder nachfolgende Zeile drucken, aber Sie dürfen keine anderen Zeichen drucken.

Regeln

• Sie dürfen keine Zeichen aus dem oben genannten Satz verwenden
• Sie können andere Zeichen verwenden
• Kein Schummeln
• Standardlücken verboten
• Dies ist Code-Golf , die kürzeste Antwort gewinnt.

Klarstellungen

• Wenn Ihre Sprache einen anderen Zeichensatz verwendet, dürfen Sie in diesem Zeichensatz keine Codepunkte verwenden, die alphanumerischen Zeichen entsprechen.
• Die Rückgabe einer Zeichenfolge aus einer Funktion wird als gültige Ausgabeform betrachtet.
• Sie können ein char-Array zurückgeben.

V , 8 7 Bytes

Dank @DJMcMayhem wird 1 Byte gespart, indem alles in einer Regex-Anweisung zusammengefasst wird

¬/{Ó×ü_

Probieren Sie es online!

Ausgänge:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Hinweis: ×ist nicht x oder Xist es0xd7

Hexdump:

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

Erläuterung

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

Jetzt sieht die Ausgabe so aus:

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

Wir müssen alle nicht-alphanumerischen Zeichen und das _(da es nicht in enthalten ist \W) entfernen , also lasst uns das mit Regex machen

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

Oktave , 52 46 40 Bytes

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

Dies ergibt

9876543210ZYXWVUTSRQPONMLKJIHGFEDCBAabcdefghijklmnopqrstuvwxyz

Erläuterung

Hier verwenden wir die Tatsache, dass Zeichen implizit in Ganzzahlen konvertiert werden, wenn arithmetische Operationen wie +-oder die Bereichsfunktion :angewendet werden. Bei Verkettung mit einer leeren Zeichenfolge ( [...,'']) werden die Zahlen erneut in Zeichen umgewandelt.

Probieren Sie es online!

Brainfuck , 77 76 75 72 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Der Interpreter beginnt mit einem Band mit 0 Zellen.

++++++++

Dadurch wird die erste Zelle auf 8 gesetzt und das Band im folgenden Zustand belassen.

   8
   ^

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

Diese Inkremente die zweite Zelle einmal, die dritte Zelle 6 mal, die vierte Zelle 4 mal dekrementiert die fünfte Zelle einmal, dann an den Anfang des Bandes geht zurück und dekrementiert die erste Zelle. Nach 8 Iterationen sieht das Band folgendermaßen aus.

  0   8  48  32  -8
  ^

>++

Wir gehen zur zweiten Zelle über und erhöhen sie zweimal, um die Ziffern zu drucken.

  0  10  48  32  -8
      ^

[>.+<-]

Dadurch wird die dritte Zelle gedruckt, inkrementiert, dann zur zweiten Zelle zurückgekehrt und dekrementiert. Nach 10 Iterationen haben wir gedruckt 0123456789und das Band sieht wie folgt aus.

  0   0  58  32  -8
      ^

>>

Zeit, das Band für die Briefe vorzubereiten! Wir beginnen mit dem Vorrücken von zwei Zellen.

  0   0  58  32  -8   0   0
              ^

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

Dies inkrementiert die fünfte Zelle einmal, die sechste Zelle zweimal, die siebte Zelle dreimal, geht dann zurück zur vierten Zelle und dekrementiert sie. Nach 32 Iterationen sieht das Band folgendermaßen aus.

  0   0  58   0  24  64  96
              ^

>++

Als letzten Schritt vor dem Drucken der Buchstaben fahren wir mit der fünften Zelle fort und erhöhen sie zweimal.

  0   0  58   0  26  64  96
                  ^

[>+.>+.<<-]

Schließlich gehen wir zur sechsten Zelle, um sie zu erhöhen und auszudrucken, machen dasselbe für die siebte Zelle, gehen dann zurück zur fünften Zelle und dekrementieren sie. Nach 26 Iterationen haben wir gedruckt Aa...Zz.

Ruby, 42 Bytes

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

Eine Funktion, die ein char-Array zurückgibt. Ein Programm, das nur die Zeichen ausgibt, hat 49 Bytes:

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

Dies verwendet einfach die ASCII-Zeichen auf beiden Seiten der relevanten Bereiche, um einen Bereich zu definieren. Bedeutet zum Beispiel ?/...?:die Zeichen zwischen einem Schrägstrich und einem Doppelpunkt, mit Ausnahme des Endes. Um die Anfänge loszuwerden, subtrahieren wir ein Array mit den drei Anfangszeichen.

6502 Maschinensprache, 74 70 68 Bytes

Hex-Dump (6502-Programme können im Allgemeinen nicht verschoben werden; der Code wird hier ab Position $ 0603 gespeichert):

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

Sie sehen, dass dabei keines der verbotenen Bytes verwendet wird: 41 bis 5a, 61 bis 7a oder 30 bis 39.

Dies ist eine Funktion ohne Argumente, die beim Aufruf einen Zeiger auf das Zeichenarray "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789" am Anfang des Stapels gemäß den Standardaufrufkonventionen 6502 zurückgibt.

Zur Erklärung hier eine Demontage:

Hexdump-Demontage beheben
-------------------------------
$ 0603 a9 24 LDA # $ 24
$ 0605 0a ASL A
$ 0606 8d 20 06 STA $ 0620
$ 0609 8d 21 06 STA $ 0621
$ 060c 8d 23 06 STA $ 0623
$ 060f 8d 25 06 STA $ 0625
$ 0612 09 20 ORA # $ 20
$ 0614 8d 1a 06 STA $ 061a
$ 0617 8d 1c 06 STA $ 061c
$ 061a je NOP 
$ 061b aa STEUER 
$ 061c pro NOP 
$ 061d a8 TAY 
$ 061e a9 00 LDA # $ 00
$ 0620 pro NOP 
$ 0621 pro NOP 
$ 0622 98 TYA 
$ 0623 pro NOP 
$ 0624 8a TXA 
$ 0625 pro NOP 
$ 0626 a2 ff LDX # $ ff
$ 0628 a9 7b LDA # $ 7b
$ 062a a0 60 LDY # $ 60
$ 062c 20 3a 06 JSR $ 063a
$ 062f a9 5b LDA # $ 5b
$ 0631 a0 40 LDY # $ 40
$ 0633 20 3a 06 JSR $ 063a
$ 0636 a9 3a LDA # $ 3a
$ 0638 a0 2f LDY # $ 2f
$ 063a 85 80 STA $ 80
$ 063c c8 INY 
$ 063d e8 INX 
$ 063e 98 TYA 
$ 063f 95 00 STA $ 00, X
$ 0641 c8 INY 
$ 0642 c4 80 CPY $ 80
$ 0644 d0 f7 BNE $ 063d
$ 0646 60 RTS

Der maschinensprachliche Code ändert sich selbst. Für die Stapelmanipulation musste ich PHA und PLA verwenden, um den Akku zu pushen und zu platzieren, aber diese Anweisungen enthalten die verbotenen Opcodes $ 48 und $ 68 (dies sind die ASCII-Codes für die Buchstaben 'H' und 'h'). Also nehme ich für PHA die Zahl $ 24, mache eine arithmetische Verschiebung nach links (ASL) und speichere die resultierenden $ 48 an den vier Stellen im Code, an denen sie ausgeführt werden müssen. Dann verwende ich für PLA ein bitweises ODER auf den 48 $ im Akkumulator, um 68 $ zu berechnen, und speichere es an den beiden Stellen im Code, an denen es benötigt wird.

Es gab mehrere Anweisungen außer PHA und PLA, die ich auch nicht verwenden konnte, da ihre Opcodes zufällig mit ASCII-Buchstaben oder -Ziffern übereinstimmen, aber ich fand direkte Problemumgehungen für diese anderen.

Das gewünschte Zeichenarray wird ab Position 0 berechnet und gespeichert (es spielt keine Rolle, wo es gespeichert wird, da nur sichergestellt werden muss, dass ein Zeiger darauf oben im Stapel zurückgegeben wird).

Sie können dies am 6502-Assembler und -Emulator von Nick Morgan ausprobieren . Hier ist ein Screenshot; Das Monitorfeld unten zeigt die Ausgabezeichenfolge (an den Positionen $ 00 bis $ 3D), nachdem das Programm ausgeführt wurde.

Haskell , 75 72 63 58 56 Bytes

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

Probieren Sie es online! Mit anrufen __. Ausgabe:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Dank an xnor, der vorgeschlagen hat, __und _'als 2-Byte-Variablennamen anstelle von (!)oder ähnlich, 9 Bytes zu sparen. Mir gefällt besonders, wie _'die Syntaxhervorhebung bricht. Nochmals vielen Dank an xnor für die Verallgemeinerung der Bereiche und die Einsparung weiterer 4 Bytes.
Edit: Ich fand heraus , dass Unicode - Zeichen als Bezeichner in Haskell erlaubt ist, so zum Beispiel ä, ö... kann auch als Zwei - Byte - Bezeichner verwendet werden. Da im Programm noch ein Drei-Byte-Bezeichner vorhanden war, ersetzte ich ihn durch äund sparte weitere 2 Byte.

Erläuterung:

__und _'sind gültige Variablennamen. Aus der Sprachspezifikation :

Ein Bezeichner besteht aus einem Buchstaben, gefolgt von null oder mehr Buchstaben, Ziffern, Unterstrichen und einfachen Anführungszeichen. [...] Unterstrich,, _wird als Kleinbuchstabe behandelt und kann überall dort vorkommen, wo Kleinbuchstaben möglich sind. Doch _ganz von selbst ist ein reservierter Bezeichner, als Wild Card in den Mustern verwendet.

Der Code ist also äquivalent zu

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

In der Liste wird das Verständnis aan '/'und ban gebunden ':'( "/:"entspricht ['/',':'], damit der Mustervergleich erfolgreich ist). Dann bildet der Bereich [a..]die Zeichenfolge aller Zeichen größer gleich '/':

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

Für jedes Zeichen xin dieser Zeichenfolge wird dann geprüft, ob '/'<xund x<':', was zu den Zeichen führt 0123456789. Dann aund bsind gebunden an @ und [und ergeben die Zeichen ABCDEFGHIJKLMNOPQRSTUVWXYZund so weiter.

Perl (5.10 oder 5.12), 30 29 Bytes

Dieses Programm besteht hauptsächlich aus nicht druckbaren Zeichen. Hier ist ein Hexdump:

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

Dieses Programm ist sehr einfach: Wir regexen ( =~) einen Unterstrich ( _; danke @Dennis für den Hinweis, dass dies funktioniert) gegen einen regulären Ausdruck. Der reguläre Ausdruck wird nicht wörtlich, sondern als Ausdruck angegeben. Insbesondere nehmen wir das bitweise Komplement ( ~) eines Strings. Wenn Sie das bitweise Komplement umkehren, um an den zugrunde liegenden String zu gelangen, erhalten Sie den folgenden regulären Ausdruck, der ausgeführt wird:

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

In den Perl-Versionen 5.10 und 5.12 war die (?{…})Syntax eine experimentelle Syntax, mit der reguläre Ausdrücke zur Laufzeit beliebigen Code ausführen können. In diesem Fall verwenden wir es, um ein einfaches Perl-Programm zum Drucken der gewünschten Ausgabe auszuführen. (Versionen vor 5.10 können nicht verwendet werden, da sie keine haben say.)

Moderne Perl-Versionen wurden (?{…})aus Sicherheitsgründen standardmäßig deaktiviert. Wenn Sie jedoch über eine solche Perl-Version verfügen, können Sie die Prüfung (und damit die Ausführung dieses Programms) -Mre=evalals Befehlszeilenargument (zusammen mit dem Standard -M5.010, der die Version angibt ) deaktivieren der zu implementierenden Sprache, und die nicht gegen die bytecount zählt).

Eigentlich 8 5 4 Bytes

'>┘▀

Wie es funktioniert:

 '>    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]

Der Ausdruck erfolgt implizit am Ende des Programms.

Edit 1: Ersetzt das Setzen des Alphabets in Klein- / Großbuchstaben und dann des Zahlenbereichs (10), indem nur die druckbaren Zeichen der Basis 62 abgerufen werden.

Edit 2: geändert ">" zu '> dank Mego :) 1 Byte gespeichert.

Probieren Sie es online!

PHP, 69 Bytes

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

Der Code wird hier mit Windows-1252 stilisiert. Unten ist ein umkehrbarer xxd- Hexdump.

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                                   ...";

Probieren Sie es online!

Java (OpenJDK 9) , 277 Byte

Ja, Java, das hast du gut gelesen!

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

Probieren Sie es online!

Dadurch werden die Bereiche gedruckt, jedoch umgekehrt, da die Reihenfolge keine Bedeutung hat.

zyxwvutsrqponmlkjihgfedcbaZYXWVUTSRQPONMLKJIHGFEDCBA9876543210

Ich habe das Fehlen einer "No Input" -Regel ausprobiert, um implizit eine zu definieren, chardie erforderlich ist, damit das Ganze funktioniert. Wenn das Schummeln ist, sagen Sie es bitte.

Ungolfed & Prüfung

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 Bytes

Da Brainfuck alphanumerische Zeichen sowieso ignoriert, ist dies nur eine Herausforderung mit konstanter Ausgabe ... (Bearbeiten: Siehe Dennis 'Lösung für eine Version, die 10 Byte kürzer ist)

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

Probieren Sie es online!

Dieser Code ist ein gutes Beispiel für grundlegende Zählschleifen in Brainfuck:

+[-[--<]>>--]   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)

Beachten Sie, dass beim Generieren von Zahlen Umbruchverknüpfungen verwendet werden. Dies bedeutet, dass der Interpreter 8-Bit-Umbruchzellen haben muss (z. B. die, mit der ich verknüpft bin).

JavaScript (ES6), 983 Byte

Es stellte sich heraus, dass in ES6 viele Zeichen in JavaScript-Variablennamen verwendet werden können ! Funktioniert hervorragend, nachdem Sie die sechs 1-2-Byte-Variablennamen mit $und ausgeschöpft haben _.

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

JavaScript, 1223 Byte

Dies war meine Antwort, bevor ich davon erfuhr.

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

Ich bin console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')durch jjencode gelaufen und habe das Ergebnis manuell golfen. Es gibt definitiv mehr Optimierungen, die durchgeführt werden können.

Befunge, 73 72 59 57 55 53 Bytes

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

Probieren Sie es online!

Dies ist eine einzelne Schleife, die abwärts zählt {(dh ein Zeichen danach z). Bei der ersten Iteration legt die "{"<Sequenz zwei Kopien von {auf den Stapel - eine ist der anfängliche Schleifenzähler und die andere dient zum Dekrementieren dieses Zählers unter Verwendung der Sequenz !!-(zwei NOTs make 1, die dann subtrahiert werden). Bei nachfolgenden Iterationen befindet sich der Schleifenzähler bereits auf dem Stapel, sodass nur einer {zum Einrichten der Dekrementierungssequenz erforderlich ist.

Der Rest des Codes ist nur ein langer boolescher Ausdruck, der berechnet, ob sich das Zeichen im Bereich befindet. Wenn dies der Fall ist, wird der Zweig in der zweiten Zeile nach links geteilt, um den Wert zu schreiben. Wenn nicht, wird der rechte Zweig umgebrochen, um zu testen, ob wir Null erreicht haben und enden sollten. Die beiden Zweige verschmelzen in der Mitte, um die Schleife zu wiederholen. Beachten Sie, dass alle Befehle für die vertikale Richtung nach oben gerichtet sind, da wir a nicht verwenden können. Dies vist jedoch in Ordnung, da der Anweisungszeiger automatisch am oberen Rand des Spielfelds umbrochen wird.

Vielen Dank an Mistah Figgins, die sich zunächst eine bessere Technik für das Loop-Inkrement ausgedacht hat.

Ein besonderer Dank geht jedoch an Jo King für einen noch besseren Countdown und ein kompakteres Zweiglayout.

Jelly , 17 16 Bytes

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

Probieren Sie es online!

Wie es funktioniert

“:[{“/@`‘Ḷḟ"/ỌḊ€  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 '`').

Selbstmodifizierender Brainfuck , 32 Bytes

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

Probieren Sie es online!

xxd -r-reversibler Hexdump (enthält nicht druckbare Dateien):

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

C 128 Bytes

Ja, C. Und es ist sogar kürzer als einige der esoterischen.

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

Rufen Sie _einen ausreichend großen, leeren char *Puffer auf.

_{Kann ein winziger bisschen compilerabhängig sein. Getestet mit GCC; Datei wurde in Codepage 1252 gespeichert.}

JavaScript (ES6), 812 745 657 650 536 520 416 Bytes

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

Bearbeiten: Mit ISO8859-1-Codierung ist diese Lösung 416 Bytes anstelle von 520 Bytes. Das vollständige Programm umfasst 432 Bytes, wobei die zusätzlichen 16 Bytes für berücksichtigt werden

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

Dies ist eine Funktionsübermittlung im Gegensatz zu einem vollständigen Programm. Ich habe ziemlich viel Zeit damit verbracht, JJEncode ( Hutspitze für darrylyeo ) zu golfen , aber anstatt zu golfen

console.log('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890')

Ich habe Golf gespielt

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

wo Øwird ""im Overhead initialisiert .

Umgeschrieben mit Kommaoperatoren, die in Zeilenumbrüche umgewandelt wurden:

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

Erläuterung

In diesem Skript werden zunächst einige integrierte Typen initialisiert und in Zeichenfolgen umgewandelt. Die Zeichenfolgen, die wir ohne alphanumerische Zeichen erhalten können, sind:

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

Aus diesen Zeichenfolgen und den erforderlichen Ziffern, um einzelne Zeichen zu referenzieren, können wir die Zeichenfolgen returnund erhalten constructor, die wie folgt verwendet werden können:

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

Der Konstruktor des Objekts ist Object()und sein Konstruktor ist Function(), den wir im Wesentlichen wie verwenden können eval().

In diesem Fall besteht das forauszuführende codierte Skript aus den verschachtelten Schleifen, die alle alphanumerischen Zeichen unter Verwendung ihrer Codepunkte zu einer Zeichenfolge verketten und diese zurückgeben.

Für alphabetische Zeichen im codierten Skript, auf die mit den integrierten Funktionen nicht zugegriffen werden kann, verwendet JJEncode Oktal-Escape-Zeichen, um sie darzustellen, und decodiert dann die gesamte Zeichenfolge, indem es sie von einer inneren Funktion zurückgibt. Die äußere Funktion kann dann aufgerufen werden, um die Quelle auszuführen.

Demo

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

Brain-Flak , 171 Bytes

Beinhaltet +3 für -A

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

Probieren Sie es 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

Es gibt wahrscheinlich eine Möglichkeit, dies zu tun, ohne die Funktion add 1 wiederholen zu müssen.

Julia 0,4 , 46 Bytes

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

Dies ist eine generische Funktion, die ein Zeichenarray zurückgibt.

Probieren Sie es online!

Alternative Version, 47 Byte, nur ASCII

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

Probieren Sie es online!

J, 171 Bytes

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

Au ... mein Gehirn tut weh ... Online ausprobieren!

Hier ist, damit Sie alles in einer Zeile sehen können (es wird jedoch nicht mit Zeilenumbrüchen ausgeführt.)

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

Funktioniert garantiert nur mit der J-Version j805/j64/linux/release/commercial/www.jsoftware.com/2016-12-11T08:02:52in dieser Reihenfolge. (Nur die ersten 12 Zeichen sind wichtig.)

Erläuterung

Der größte Teil des Programms ist der ständigen Generierung gewidmet. Wenn diese Konstanten durch ihre Werte ersetzt werden, sieht das Programm folgendermaßen aus:

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

Mit einigen Klammern entfernt und einige Zahlen schöner gemacht:

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

Dies setzt sich aus einer Reihe von ,und ,~s zusammen, die Argumente anhängen und voranstellen. Hier sind die einzelnen Werte:

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

1ist 26wie eine Zeichenfolge.

9!:14'' generiert den folgenden String auf TIO:

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

mit 2erhalten wir das 10th-Zeichen ( ivon linux) und fügen .am Ende ein hinzu, was ergibt i..

3und 5sind selbsterklärend.

4ist die Liste der Zahlen 65 97 48als Zeichenfolge.

6ist ähnlich wie 2, mit der Ausnahme, dass es das 12th-Zeichen ( uvon linux) ist und :am Ende ein fügt , was ergibt u:.

Dies alles zusammen ergibt u:,65 97 48+/i.26. ".bewertet dies und gibt uns:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789:;<=>?@ABCDEFGHI

(Hinweis: +/ist zusätzlich tabellarisch aufgeführt.)

Dann 62{.nehmen wir mit die ersten 62Zeichen davon und geben uns ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.

05AB1E , 18 15 11 Bytes

-4 danke an Adnan, denn wenn die Eingangsgröße 1 ist, verwendet 05AB1E beim ersten Befehl 0 für b.

•£•Ýç©á®þ«˜

Probieren Sie es 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. 

Ich habe so viele verschiedene Ansätze ausprobiert, aber die wichtigsten Punkte hier, die es schwierig machten:

- 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 Bytes

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

Ausgabe:

aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ0123456789

Probieren Sie es online!

Initialisiert das Band auf 3 · 2 ⁿ und arbeitet von dort aus.

+++[[<+>->++<]>]    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 Bytes - nicht konkurrierend

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

Ein Lambda, das eine Liste von Zeichen zurückgibt.
Erläuterung:

   '`'                                       # 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"

Hängt von einem Bugfix des Rakudo Perl 6-Interpreters ab, der heute nur für das Git-Repo verwendet wurde und noch nicht Teil einer offiziellen Rakudo-Veröffentlichung ist. Tatsächlich bin ich bei der Beantwortung dieser Herausforderung auf den Fehler gestoßen und habe es geschafft, ihn mithilfe eines der Perl 6-Kernentwickler zu beheben. Die Regeln dieser Site erlauben es, so wie ich sie verstehe, nicht, dass Antworten in einer solchen Situation konkurrieren. Deshalb habe ich sie als nicht konkurrierend markiert.

PHP 7.0+, 110 Bytes

Gott segne bitweise Fäden!

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

Ersetzen Sie die \ndurch eine echte * NIX-ähnliche Newline.
Es ist im Code enthalten, um Probleme mit Zeilenumbrüchen zu vermeiden, wird jedoch nicht in der Punktzahl berücksichtigt.

Dies wirft eine Reihe von Warnungen auf, die jedoch unterdrückt werden können, indem @vor jedem Streuner eine angefügt wird _.

Warnung frei , 113 Bytes

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

65c02 Maschinensprache + Apple] [ROM, 25 Bytes

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

Druckt abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.

Sollte um beginnen $8000.

Demontage

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 (unter Linux), 507 493 490 485 Bytes

Dadurch wird ein Array von Zeichen in der globalen Variablen gespeichert __

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

es muss auf einem frisch gebooteten Linux-Rechner mit /procoder so etwas wie einem PID-Namespace ausgeführt werden

Erläuterung:

# {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}
__=(${__[@]} ${___[@]} ${___[@]^})

Zum Ausprobieren können wir declare -p __am Ende hinzufügen , um das Ergebnis anzuzeigen

$ 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 Bytes

Diese Lösung funktioniert im Wesentlichen auf die gleiche Weise wie die beiden anderen Antworten auf diesen Thread hier und hier , wo es Briefe von den verwendet true, false, undefined, und [object Object]Strings , die die Funktionen zu bauen , dass es die anderen Buchstaben erzeugen muss.

Da eine gute Anzahl der Buchstaben bereits in das Objekt eingefügt wurde, habe ich versucht, alle verbleibenden winzigen Buchstaben und die Zahlen zum Objekt hinzuzufügen, und dann toUpperCaseauf alle Werte im Objekt angewendet , um die fehlenden majuskularen Buchstaben zu generieren.

Aktualisieren:

Ich konnte die Art und Weise, wie die Oktalwerte eingestellt wurden, verbessern, aber sie belegen immer noch 13 x 30 Bytes (oder sie werden jeweils 30 Bytes sein, nachdem ich die Zahlen in verschiedene Schlüssel geändert habe) Muster: $.ž=\'\\'+$.一+$.七+$.二+'\';.

Weitere 49 Bytes können einfach durch Umschalten der Zifferntasten auf 2 Byte Zeichen entfernt werden.

Aktuelle Einreichung:

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

C (clang) , 164 Bytes

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

Probieren Sie es online!

Dies ist eine rekursive Funktion, die die Zeichen ab einem Wert von 1 (von Selbst subtrahiert und inkrementiert) abruft und alle anderen Zahlen daraus erstellt.

Ungolfed / Erklärung:

é,ú,í,ó;
_(*$){ //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 Bytes

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

Probieren Sie es online!

Erläuterung

"{`[@:/" 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 Zeichen / 19 Bytes

ᶐ+ᶛ+⩥Ⅹă⬯

Probieren Sie es hier aus!

ᶐdie Großbuchstaben - Alphabet ist, ᶛist die Kleinbuchstaben, und ⩥Ⅹă⬯ist Bereich ( ⩥) aus , 0um 10( Ⅹdie Unicode römische Ziffer) minus 1, zusammen mit ( ă) nichts ( ⬯).