Vor ungefähr einem Jahr, am 31. Dezember 2015, hatte ich die Idee, dass:

Wir sollten eine Zeitkapselkette machen. Jeder darf einen Charakter hinzufügen und in den nächsten Jahren werden wir sehen, wer aus allen Charakteren mit den damals existierenden Esolangs das beste Programm machen kann.

Doorknob gnädig gesammelte Zeichen aus der PPCG Gemeinschaft und hielt sie für ein Jahr sicher.

Es nahmen sage und schreibe 74 Personen teil, sodass wir 74 druckbare ASCII- Zeichen zum Spielen haben!

Hier sind die 74 Zeichen der Zeitkapsel-Zeichenfolge für 2016 in der Reihenfolge, in der sie übermittelt wurden:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Hier sind die 74 Zeichen der Zeitkapsel-Zeichenfolge 2016 in ASCII-Reihenfolge (Leerzeichen am Anfang beachten):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

Es ist nicht viel zu tun, aber hier mögen wir eine Herausforderung.

Die Herausforderung

Um zu bestimmen, welche Sprache mit der Zeitkapsel-Zeichenfolge "am besten" ist, haben wir 6 (für 201 6 ) Herausforderungen mit zunehmendem Schwierigkeitsgrad, bei denen Sie jeweils eine Teilmenge der 74 Zeitkapsel-Zeichen verwenden müssen.

Mit 6 unterschiedlichen Herausforderungen können mehr Sprachen konkurrieren, aber nur die besten Sprachen können alle beantworten und punkten.

Wertung:

• Jede Herausforderung wird von 0 bis 74 bewertet, je nachdem, wie viele Charaktere verwendet werden.
• Höhere Werte sind besser.
• Wenn Ihre Sprache eine Herausforderung nicht bestehen kann, ist Ihre Punktzahl für diese Herausforderung 0.
• Jede nicht leere Teilmenge der Herausforderungen kann abgeschlossen werden.
• Ihre Endpunktzahl ist die Summe der Punkte aus allen 6 Herausforderungen.
• Das bestmögliche Endergebnis ist 6 × 74 oder 444 .

Die Herausforderungen

1. Führen Sie aus

Wenn der Code einer Sprache überhaupt nicht ausgeführt werden kann, kann er überhaupt nichts tun.

Schreiben Sie das längste vollständige Programm, das möglich ist (verwenden Sie dazu nur die 74 Zeichen in der Zeitkapsel), das ohne Fehler bei der Kompilierung oder zur Laufzeit ausgeführt wird.

Es ist egal, was das Programm macht, es ist egal, ob es Input / Output hat oder in eine Endlosschleife eintritt, es ist nur wichtig, dass es fehlerfrei läuft. (Warnungen sind in Ordnung, ebenso wie Fehler, die durch falsche Benutzereingaben verursacht wurden.)

Kommentare sind erlaubt, dies könnte also so einfach sein wie

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

in Python für eine Punktzahl von 74.

(Haben Sie keine Angst zu antworten, wenn dies die einzige Herausforderung ist, die Ihre Sprache bewältigen kann, aber erwarten Sie auch nicht viele Stimmen.)

Punktzahl = Programmlänge (längeres Programm ist besser)

2. I / O

Eine Sprache ohne Eingabe oder Ausgabe ist fast so nutzlos wie eine Sprache, die nicht ausgeführt werden kann.

Geben Sie bei einem druckbaren ASCII- Zeichen von !(0x33) bis (0x7D) }das druckbare ASCII-Zeichen davor und danach aus.

Die Ausgabe kann eine Zeichenfolge oder Liste der Länge zwei oder die durch ein Leerzeichen oder eine neue Zeile getrennten Zeichen sein.

Wenn es sich bei der Eingabe beispielsweise um }die Ausgabe handelt, kann dies |~oder ["|", "~"]oder | ~oder sein |\n~.

Ebenso "ist die Ausgabe für !und ACist die Ausgabe für B.

Punktzahl = 74 - Programmlänge (kürzeres Programm ist besser)

3. Verzweigungsfähigkeit

Bedingungen sind oft eine Voraussetzung für die Vollständigkeit des Turing , was oft eine Voraussetzung dafür ist, dass eine Sprache nützlich ist.

Wenn eine positive Ganzzahl mit den Dezimalstellen endet, 16ändern Sie die Zahl 6in a 7und geben Sie das Ergebnis aus. Andernfalls geben Sie die Eingabe unverändert aus. Bei Bedarf können Sie Zeichenfolgen für die Eingabe / Ausgabe verwenden.

Beispiele:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Punktzahl = 74 - Programmlänge (kürzeres Programm ist besser)

4. Endlos wiederholbar

Eine Sprache, die keine Schleifen ausführt, erzeugt sich wiederholenden Code, so dass Sie eine Weile eine Programmierpause einlegen müssen.

Geben Sie bei einer positiven Ganzzahl ein ASCII-Kunstquadrat mit dieser Seitenlänge aus, das mit einem Muster aus konzentrischen kleineren Quadraten gefüllt ist, die sich zwischen zwei verschiedenen druckbaren ASCII- Zeichen abwechseln . Sie müssen nicht die gleichen zwei Zeichen für verschiedene Eingaben sein.

Zum Beispiel:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Punktzahl = 74 - Programmlänge (kürzeres Programm ist besser)

5. Math

Eine Sprache, die nicht gut mit Zahlen und Mathematik umgehen kann, ist möglicherweise auch für die Hauptfächer der Geisteswissenschaften geeignet.

Nehmen Sie keine Eingabe, sondern geben Sie die 72 positiven und negativen Ganzzahlteiler von 2016 in beliebiger Reihenfolge aus. Die Ausgabe kann in angemessener Weise als Zeichenfolge oder Liste formatiert werden.

Beispiel:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Punktzahl = 74 - Programmlänge (kürzeres Programm ist besser)

6. Esoterik

(Nein, nicht das .) Wir bei PPCG mögen unser esoterisches Zeug , und Quines sind ein gutes Beispiel dafür.

Schreiben Sie die längste Quine, die Sie können, nach den üblichen Quine-Regeln . Ein Quine ist ein Programm, das keine Ein- und Ausgaben selbst vornimmt.

Punktzahl = Programmlänge (längeres Programm ist besser)

Spezifische Regeln

• In jeder der 6 Herausforderungen muss Ihr Programm eine Teilmenge der 74 Zeitkapsel-Zeichen sein, die nach Belieben neu angeordnet wurden. Es kann sich um eine leere Untermenge oder eine falsche Untermenge handeln , sodass jedes Ihrer Programme nur 0 und bis zu 74 Zeichen enthalten kann.
• Eine einzelne nachgestellte Zeile am Ende der Eingabe / Ausgabe / des Codes ist überall in Ordnung, da dies für einige Sprachen erforderlich ist oder nicht einfach vermieden werden kann.
• Sofern nicht anders angegeben, kann jede Herausforderung nach unseren Vorgaben als Funktion oder als vollständiges Programm abgeschlossen werden .
• Alle Herausforderungen müssen in derselben Sprache abgeschlossen werden.
• Sie müssen eine Sprache (oder Version einer Sprache) verwenden gemacht , bevor es war 2017 überall auf der Erde .
• Jeder kann gerne antworten, ob Sie der Zeitkapsel einen Charakter hinzugefügt haben oder nicht.

_{Fühlen Sie sich frei, die Zeitkapsel-Charaktere 2016 in Ihren eigenen Herausforderungen zu verwenden.}

Glypho , 74 + (74 - 36) = 112

1. Ausführen (74 Bytes)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 Bytes)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Erläuterung

Glypho schien eine ziemlich gute Wahl für diese Herausforderung zu sein, da es nicht darum geht, welche Charaktere verwendet werden. Stattdessen werden Gruppen von vier Zeichen angezeigt, und der Befehl wird basierend auf dem Wiederholungsmuster in diesen vier Zeichen ausgewählt. Da es viele Duplikate in der Zeitkapselzeichenfolge gibt, sind wir in den Programmen, die wir schreiben können, ziemlich flexibel, mit der Ausnahme, dass wir auf Programme mit 18 Befehlen beschränkt sind (was in Glypho nicht viel ist). Während dies mir erlaubte, die ersten beiden Probleme ziemlich leicht zu lösen, bezweifle ich, dass Glypho die anderen mit so wenigen Charakteren ausführen kann.

Ich habe diese mit dem Java-Interpreter getestet, der vom 23.06.2006 auf dem Wayback-Rechner abgerufen wurde und der eine etwas andere Zuordnung der Befehle verwendet:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Das Run- Programm übersetzt in:

1d-+[...]

Wo ...ist irgendein Müll, den ich nicht übersetzt habe?

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

Das IO- Programm übersetzt in:

id1-+o1+o

Folgendes bewirkt dies:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74 - 14) + (74 - 26) = 182 Punkte

1. Ausführen (74 Bytes)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Wenn Sie e#nach vorne gehen, wird die gesamte Zeile auskommentiert.

2. E / A (14 Byte)

9`)ZH*+~):Q(Q)

Dennis sparte 8 Bytes.

Erläuterung:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Verzweigungsfähigkeit (26 Bytes)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Erläuterung:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Ich schaue mir die anderen später an. ( EDIT : Ich bezweifle, dass sie möglich sind, ohne Block- oder String-Literale ... vielleicht die mathematische?)

J, Ergebnis 71 + (74 - 19) = 126

Aufgabe 1, Länge 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Dies definiert ein Verb AHILOals das Innere. Ungebraucht:

)))

Ich glaube nicht, dass es eine Möglichkeit gibt, länger zu werden.

Aufgabe 3, Länge 19

+($#~$~4)=1e4|&%:*~

Die Art und Weise, diese Aufgabe ohne Einschränkungen auszuführen +16=100|], lautet wie folgt:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Wir haben +, =und mehrere Kopien oder |in unserer Verfügung, und es ist leicht zu umgehen ], aber die Zahlen sind problematischer. Hier ist der erste Teil, der Input Modulo 100 berechnet:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Nachdem wir damit fertig sind, wollen wir die Zahl 16 produzieren. Der einfache Weg ist mit *~4(4 multipliziert mit sich selbst), aber wir haben sie bereits verwendet, *so dass das verboten ist. Stattdessen werden wir einige Array-Manipulationen durchführen.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Arbeit

2

Das ist definitiv unmöglich. Die einzigen Möglichkeiten, Zeichenwerte zu manipulieren, sind a.und u:, und wir haben Zugriff auf keine von beiden.

Wenn wir nun aanstelle von beispielsweise verwenden könnten A, wäre dies eine Lösung:

Q{~(*^.4%9 1)+I.~&Q=:a.

Der schwierigste Teil, dies zum Laufen zu bringen, bestand darin, die Zahl -1 zu erzeugen.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

Dies erzeugt die Form der Hülle, aber ich kann scheinbar keinen Weg finden, Zeichen zu erzeugen. Ach.

5

Zugegeben, dies scheint die einfachste Aufgabe zu sein, die in J zu erledigen ist. Ohne i.wird dies jedoch ziemlich schwierig.

6

Dies ist ohne eine solche 449oder ähnliche Fake-Out-Quine wahrscheinlich nicht möglich , da die Kapsel-Zeichenfolge keine Anführungszeichen oder andere Methoden zur Herstellung von J-Zeichenfolgen enthält.

PowerShell - Gesamtpunktzahl: 74

1. Durchlauf - Ergebnis: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Da dies in PowerShell äußerst schwierig ist (soweit ich das beurteilen kann, ist es mit den angegebenen Zeichen nicht möglich, jede mögliche Methode zum Abrufen von Eingaben zu verwenden), habe ich mich zumindest dazu entschlossen, die erste Herausforderung nach dem Zufallsprinzip zu sortieren, damit wir das Beispiel nicht alle direkt kopieren von der Post.

Hier ist also ein Zufallsgenerator für eine Herausforderung mit einer Antwort (für Sprachen, in denen #es einen Kommentar gibt):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Probieren Sie es online!

Meme , Score von ( 62 65 + 70) 135

1: Laufen

Ich habe alle Backticks ( `) und mathematischen Operatoren entfernt. Sie führten zu Konflikten, weil es nicht genügend Zahlen gab, um jeden unären und binären Operator zu befriedigen. Ich habe einige in gelassen, was zu +3 Bytes führte . Resultierendes Programm:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

Ich habe keine Ahnung warum und wie das funktioniert. Zumindest löst es keine C # -Laufzeitausnahme aus und stürzt daher nicht ab.

6: Quine

Wisst ihr, wenn es irgendwo in diesen 74 Zeichen einen -oder einen Kleinbuchstaben gegeben qhätte, wäre das viel zu einfach. Ich freue mich für den IBetreiber, zumindest.

1/4I

Dieser Code ist nicht ganz offensichtlich. Hier ist eine Erklärung:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Nachkommastellen (zB 1/4) werden am Ende mit einem I angezeigt, um genau das anzuzeigen. Der IOperator ist normalerweise nutzlos, ich habe ihn für andere Zwecke hinzugefügt, aber hey, es funktioniert so!

Der obige Code ist ungültig. Dumm habe ich nicht gesehen, dass die 74 Zeichen keinen einzelnen Divisionsoperator enthalten, vorwärts ( /). Ich habe mir allerdings noch etwas anderes ausgedacht:

True

Erläuterung:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Ausgaben True(aufgrund der Art und Weise, wie C # Boolean.ToString()Großbuchstaben und nicht Kleinbuchstaben verarbeitet). Ich bin mir nicht sicher, ob es sich um eine richtige Quine handelt. In der Zwischenzeit zerbreche ich immer noch den Kopf für eine gültige, wirklich richtige und intuitive Quine.

Könnte vielleicht auch die I / O- und Math-Herausforderung lösen, aber mir fehlen bestimmte Token (Zeichen), die in den 74 Zeichen nicht enthalten sind.

Brainfuck, 74 Bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Ich musste es einfach tun.

Erläuterung:

Jedes Zeichen, das kein gültiges Brainfuck-Zeichen ist, wird als Kommentar behandelt. Der einzige Code, der tatsächlich ausgeführt wird, ist folgender:

.+..

Dies erzeugt keine druckbare Ausgabe, da weder 0 noch 1 druckbare Zeichen in ASCII sind. Da dies jedoch keinen Fehler verursacht, haben wir die erste Herausforderung erfolgreich abgeschlossen.

Mathematica, Punktzahl von 62

Es würde mich wundern, wenn jemand in Mathematica die Herausforderungen 2-6 bewältigen könnte. Hier ist das Beste, was ich mit Herausforderung 1 gemacht habe:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Definiert eine ziemlich dumme Funktion Amit einem konstanten Wert. Die 12 nicht verwendeten Zeichen sind:

)))\\`````{~

Oktave, Partitur 74

1. Führen Sie aus

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 dieser Zeichen sind Teil der Funktion, die restlichen 24 nicht.

Was es macht:

x =@(AHILOQQQTTZeefmpy)Erstellt eine Funktion x, die eine Variable AHILOQQQTTZeefmpyals Eingabe annehmen kann .

Um den Rest zu verstehen:

a||bruft die Funktion all()auf beiden aund auf b. Wenn einer oder beide dieser Werte true zurückgeben, gibt der ||Operator true zurück.

!aund ~abedeutet hier dasselbe, sie sind beide not(a).

a.^b ist eine elementweise Kraft (a(1)^b(1), a(2)^b(2) ...)

Fortsetzung der Erklärung

Ich werde jeden der Schritte verkürzen, während ich vorwärts gehe:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

Und:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

Es gibt eine gerade Anzahl von not, dies entspricht not(not(4))also trueoder 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

Der Rest ist auskommentiert.

*> <> , Gesamtpunktzahl = 74

1. Lauf, erziele 74 Punkte

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Probieren Sie es hier aus!

Dies war sehr schwer ohne den ;Charakter zu tun . Ich dachte tatsächlich, dass es für ein paar Momente unmöglich sein würde, bis ich das sah %, hatte ich im Grunde aufgegeben.

Dies ist auch ein gültiges> <> Programm.

Erklärt (irrelevante Teile weggelassen)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Herausforderungen

Ich könnte die anderen Herausforderungen ausprobieren ... sie wären extrem schwierig und beinhalten möglicherweise das Biegen der Regeln in seltsamer Weise, aber ein großzügiger Einsatz der |Spiegel und der !Trampoline sollte mindestens eine weitere Herausforderung ermöglichen.

Diese Herausforderungen sind besonders schwierig, da wir keine Ausgaben mit *> <> ( ound n) oder sogar Funktionsaufrufen ( C), Funktionsrückgaben ( R) oder Programmterminatoren ( ;) zulassen . Auch wenn wir ikeine Eingabe haben, können wir die Eingabe dennoch auf dem Stapel ablegen, was ein Plus ist. Ein weiteres Plus ist, dass wir eine einzige pAnweisung erhalten, mit der wir eine Anweisung in der Codebox ersetzen können. Dies kann möglicherweise mehrmals verwendet werden (hat noch keinen praktischen Weg gefunden), wodurch die anderen Programme möglich erscheinen (da wir zwei oder mehr Anweisungen generieren können).

Haskell, Punktzahl 63

1. Führen Sie Folgendes aus:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Nicht verwendet werden )))```````{. Kommentare in Haskell sind --oder {- ... -}, daher gibt es keine einfache Vollkommentar-Version.

Dieser Code definiert einen Infix-Operator, !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~der zwei Argumente akzeptiert:

1. fmpxyAHILOQQQTTZ die ignoriert wird und daher von einem beliebigen Typ sein kann
2. eDies muss eine Funktion sein, die zwei Zahlen annimmt

Im Funktionskörper ewird dann auf 14 und 49 mit der `-infix-Notation zugegriffen.

Anwendungsbeispiel:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

Der Operator wird auf ()das leere Tupel angewendet und (*)der Multiplikationsoperator 14*49 = 686wird berechnet.

Probieren Sie es online!

Andere Herausforderungen

Ich bezweifle, dass eine der anderen Herausforderungen möglich ist, vor allem, weil es keine möglichen Variablennamen gibt, die doppelt vorkommen können. Dies ist nur e(oder so ähnlich eQT), weil Variablennamen nicht mit einem Großbuchstaben beginnen können. Natürlich =hilft es auch nicht , nur einen zu haben .

Pyth, 131 für jetzt (2 Herausforderungen abgeschlossen)

1. Run, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Dieses Programm nimmt keine Eingabe und erzeugt keine Ausgabe.

Dieses Programm verwendet $$, was die Ausführung von willkürlichem Code ermöglicht, und ist daher online gesperrt, so dass dieses Programm online offline ausgeführt wird. Hier ist die Kompilierungsausgabe, damit Sie sehen können, was tatsächlich ausgeführt wird:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

Es ist ziemlich schwierig, ein Programm mit beliebigen Zeichen zu schreiben, das in Pyth keine Fehler verursacht. Ich habe mir die zusätzliche Herausforderung gestellt, dass das Programm auch ohne Benutzereingabe ausgeführt werden muss.

Der erste Schritt besteht darin #, alle Fehler zu verzehren. Als nächstes müssen wir Fehler durch vermeiden ~, Iund L, die jeweils ihre eigenen Details haben. Dies wird erreicht, indem Sie sie in das $$einfügen, wodurch sie in die Ausgabe-Kompilierung eingebettet werden. Auf diese Weise werden sie den Kompilierungsregeln von Python und nicht den von Python unterworfen. Um Benutzereingaben zu vermeiden, werden die verschiedenen Arity-0-Token (Variablen und Ähnliches) am Ende platziert und die Qs im $$Block verschoben .

2. IO

Das wird unglaublich schwierig, wenn es überhaupt möglich ist. Keine der Pyth-Funktionen, die willkürliche Zeichenfolgen oder Zeichen erzeugen, ist vorhanden, es sei denn .f, die Erzeugung willkürlicher Zeichen funktioniert wirklich schlecht.

3. Verzweigungsfähigkeit: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Probieren Sie es online aus

Ein äquivalentes Pyth-Programm wäre:

?n%Q100 16Q+1

Dieser Code nimmt den Eingangs-Mod 100, vergleicht ihn mit 16 und verwendet dann einen Ternär, um zwischen dem Eingang und dem Eingang plus eins zu wählen. Aufgrund von Zeichenbeschränkungen habe ich einige Ersetzungen vorgenommen:

• Statt ?, ternäre, benutzen ich |&, ordann and, die die gleiche Funktionalität, mit der Ausnahme , dass es bricht , wenn der Eingang Null ist, aber da wir positive Integer - Eingang garantiert sind, ist es in Ordnung. (Dies hätte für keine zusätzlichen Zeichen behoben werden können, ist aber auf diese Weise einfacher.)

• Anstatt die beiden Zahlen direkt zu vergleichen, nehme ich ihr XOR mit x, das genau dann Null ist, wenn sie wie gewünscht gleich sind.

• Anstatt 100direkt zu schreiben, erstelle ich es mit *TT, da Tes auf initialisiert ist 10.

• Anstatt 16direkt zu schreiben, erstelle ich es mit ye|LZ9. |LZFunktioniert im wesentlichen als Range-Funktion, so |LZ9ergibt sich [0, 1, 2, 3, 4, 5, 6, 7, 8]. eNimmt das letzte Element einer Liste und gibt 8. yverdoppelt es und gibt 16wie gewünscht. Mit einem Extra +oder einem Extra *könnte ich einen Charakter retten, aber beide sind an anderer Stelle nützlicher.

Da kommt noch mehr!

Ruby - Ergebnis: 74

1. Führen Sie aus

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Von der Herausforderung gepackt.

JavaScript (ES6), Punktzahl = 74

1. Führen Sie 74 Byte aus

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esoterik (ungültig)

Mein Vorschlag für Quine lautete:

1.4e+49

was sich als ungültig herausstellte, wie in den Kommentaren unten diskutiert.

Retina, Punktzahl 74

1. Lauf, erziele 74 Punkte

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

Ich habe die zusätzlichen Parens in die Konfiguration verschoben, damit sie den regulären Ausdruck ausgleichen können. Ich zog auch das `Recht nach denjenigen, und geändert +.zu .+.

Probieren Sie es online aus

Die anderen sind wahrscheinlich unmöglich, da es keine Zeilenumbrüche gibt. Es gibt auch keine -für Transliteration oder dfür eine Ziffern-Zeichenklasse.

Pip, Ergebnis 74 + (74 - 19) = 129

So viele Backticks mit keinem Zitat zu sehen, einzeln oder doppelt!

Aufgabe 1, 74 Punkte

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Im Grunde genommen nur eine Reihe von Musterliteralen (Regex) in Backticks, von denen das letzte gedruckt wird. Da es eine ungerade Anzahl von Backticks gibt, müssen wir einen davon mit Backslash-Escape versehen ( `\``). Probieren Sie es online aus , wobei das -wFlag hinzugefügt wird, um zu beweisen, dass keine Warnungen generiert werden.

Aufgabe 3, Punktzahl 55 (Länge 19)

e+!!e%(1.#x.!9)=4*4

Mit einer ziemlich seltsamen Eingabemethode - dem fünften Befehlszeilenargument - ist dies möglich. Probieren Sie es online!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Andere Aufgaben

Es ist möglich, Eingaben für Aufgabe 2 auf dieselbe Weise wie für Aufgabe 3 oben zu erhalten. Das Problem besteht darin, in ASCII-Code und zurück in ein Zeichen zu konvertieren. Ersteres kann erledigt werden A, letzteres erfordert Coder möglicherweise die Indizierung in der PAVariablen. Auf die Erstellung und Auswertung von Code kann nicht verzichtet werden V. Ich denke nicht, dass die Aufgabe möglich ist.

Aufgabe 4 ist auch ohne eingeschränkten Zeichensatz eine Herausforderung. Vermutlich sind Listen erforderlich (ohne die []Begrenzer oder RL(Wiederholungsliste) und nur eine Möglichkeit zur Verwendung AL(Liste anhängen) - nicht wahrscheinlich) oder möglicherweise etwas mit CG(Koordinatengitter) oder MC(Kartenkoordinaten), die beide nicht zulässig sind .

Aufgabe 5 ist am Rande der Möglichkeiten. Schleifen wären schwierig, da Foder und Map nicht möglich sind und Bereiche nicht mit konstruiert werden können ,. Es könnte etwas mit TKrankheit zu tun geben . Inkrement kann von der x:x+1Sorte sein (natürlich mit einer anderen Variablen als x, obwohl). Teilbarkeitsprüfungen verwenden können %. Trotzdem glaube ich nicht, dass es genug Charaktere gibt - besonders wiederholte Buchstaben -, um alles zu tun, was passieren muss.

Aufgabe 6 sieht völlig unmöglich aus. Alle bekannten Pip Quines haben "in ihnen. Sie verwenden auch R(replace), RP(repr) oder V(eval), von denen keines verfügbar ist.

Tatsächlich ist score (74 + 0 + 0 + 0 + 0 + 0 ) = 74

Ja, die Kapselzeichenfolge funktioniert mit Actually as it is for Run, da Actually alle Fehler verwirft und jeder Fehler zu einem NOP wird.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( Online ausprobieren! )

Es wird jedoch ein Durcheinander von Dingen ausgeben (aber auch seine Quelle einmal: 3).

Ich werde jedoch an anderen Herausforderungen arbeiten.

05AB1E - Gesamtpunktzahl: 74

1. Führen Sie 74 Byte aus

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Alles, was einen Fehler verursacht, wird von 05AB1E übersprungen. Diese ganze Codezeile ist ein NOP.

Probieren Sie es online!

(missbraucht) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Der PHP-Interpreter gibt einfach den Quellcode aus, bis er eine findet, <?da uns <jede Permutation dieser Zeichen fehlt . Ich denke, das ist nicht schlimmer als die Verwendung eines eingebauten Quine-Befehls: P

Mathematica, Ergebnis 68

`A: = .1% *. 44y # +. 9 ^ H @` $ I @ `L @ (` $ O ~ `Q ~` Q ~ `Q ~` T ~ T ~ Z ~ e ~ e | f | m | p | x) !!!!! & \

Beachten Sie die nachgestellte Newline. Ich glaube nicht, dass eine der anderen Herausforderungen mit Mathematica erreicht werden kann.

Labyrinth, 74 Punkte

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Ich bin mir ziemlich sicher, dass jede Auswahl dieser Zeichen ein gültiges Labyrinth-Programm ergibt, aber um es zumindest ein wenig interessanter zu machen, wird es 2016Ziffer für Ziffer ausgedruckt. (Zusammenfassend: 2 2auf dem Stapel drücken , eine einfügen / drucken, die andere auf den Hilfsstapel verschieben, 0 ausdrucken, 2 1auf dem Stapel drücken , 1 einfügen / drucken, inkrementieren, bitweise nicht, negieren (das Letzte) 1ist a 3an dieser Stelle), Summe mit dem 2vom Aux-Stack, 5 * 10 + 4 = 54, als ASCII-Wert ausgeben, beenden)

Der Großteil der langen Zeile wird einfach ignoriert, da @das Programm beendet wird.

Die Herausforderungen 2, 3 und 4 sind unmöglich, da keiner der Labyrinth-Eingabebefehle verfügbar ist ( ,oder ?) und ich mir für 5 oder 6 nichts ausgedacht habe.

SmileBASIC, 48 Punkte

Herausforderung 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

Erläuterung:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

Andere:

Es sind keine Ein- / Ausgabebefehle verfügbar, der Rest ist also nicht möglich.

Trotzdem nicht schlecht für eine echte Sprache ohne Kommentare.

MATL , Gesamtpunktzahl 74

1. Lauf, erziele 74 Punkte

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Alles bis zu %ist aktueller Code. %ist ein Kommentarsymbol, daher werden die Zeichen rechts davon ignoriert.

Das Programm gibt 1fehlerfrei aus.

Probieren Sie es online!

Bash, Score 74

1: Laufen. Wir können alle 74 laufen

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esoterik:

Das leere Programm ist ein Quine in Bash.

Ohne Leerzeichen kann nichts anderes in der Liste erreicht werden. Ergo, ich habe den Gewinnerbeitrag.

Perl 6 , Gesamtpunktzahl 74

1. Lauf, erziele 74 Punkte

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Keine Kommentare.
(Wenn Sie einfach die Taste #nach vorne setzen, um einen Kommentar zu erstellen, funktioniert dies ebenfalls, aber das macht mehr Spaß.)

Arbeit

Dies ist die Teilmenge der Perl 6-Sprache, die nur die zulässigen Zeichen verwendet:

Konstanten: e

Typnamen: IO

Funktionen: exp

Methoden:
    bei Typ IO: .e .f .x
    (... wahrscheinlich mehr.)

Betreiber: | Infix: | Präfix:
    ----------- + ------------------- + ---------
    numerisch: | + * + ^ + | + &% | + + ^
    Zeichenfolge: | ~ x ~ ^ ~ | ~ & | ~
    Boolescher Wert: | || ~~ | !
    Kreuzungen: | | & ^ |  
    Sonstiges: | =: = Z .. ... |  

Syntax:
    Anzahl Literale: 1 4 9
    String-Literale: Q` `Q! ! usw.
    Shell-Befehle: Q: x` `Q: x! ! usw.
    Welcher Stern auch immer: *
    Variablen: meine \ $ @ &
    Gruppierung: ()
    Kommentare: # # `()
    Leerzeichen aufheben: \

Die unmittelbare Hürde, die die Herausforderungen 2 bis 6 verhindert, besteht darin, dass es anscheinend keine Möglichkeit gibt, E / A-Vorgänge durchzuführen:

• Wenn wir davon ausgehen, dass es eine Datei mit dem Namen gibt f, können wir Q`f`.IO.eüberprüfen, ob sie existiert oder Q`f`.IO.xob sie ausführbar ist. Aber wir können es nicht lesen oder schreiben.

• Wir könnten Q:x` `einen Shell-Befehl ausführen (vorausgesetzt, wir finden die Zeichen für einen). Wir können aber nichts interpolieren, es wäre also nur gut zum Lesen, nicht zum Schreiben.

• Da es keine schließende Klammer gibt, können wir keinen Lambda-Block erstellen {1 + $_}, der automatisch den Wert seiner letzten Anweisung zurückgibt.

• Wir könnten das Sternchen verwenden, um einen Ausdruck Lambda (zB 1+*) zu erstellen , aber dann können wir nur ein Argument verwenden, nur einmal auf dieses Argument verweisen und sind in der Syntax / den Operatoren, die wir verwenden können, noch eingeschränkter.

Lua, Punktzahl 31

1. Lauf (31 von 74 Punkten)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Jelly , Punktzahl 74

1. Laufen , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Ich bin mir nicht sicher, wie ich die anderen machen soll.

/// , Ergebnis: 146

1. Laufen, Ergebnis: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Ergebnis: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Ja, wenn der Code keine Schrägstriche vorwärts oder rückwärts enthält, druckt er sich selbst.