Dies ist der Faden der Räuber. Für den Thread der Polizei klicken Sie hier .

Aufgabe der Polizei

Für den Thread der Polizei klicken Sie hier .

Räuberaufgabe

• Finde eine ungerissene Einsendung im Thread der Polizei. (Eine Einreichung darf nur einmal geknackt werden.)
• Entschlüsseln Sie den Code, um eine funktionierende Quine zu finden.
• Poste eine Antwort auf den Thread der Räuber. Geben Sie die Sprache, die Anzahl der Bytes, den Benutzer, der den verschlüsselten Code gepostet hat, einen Link zu dieser Antwort und den nicht verschlüsselten Code an.

Hier ist ein Beispiel für eine Räubereinreichung:

Python, 29 Bytes, Oliver

_='_=%r;print _%%_';print _%_

Wertung

Der Benutzer mit den meisten Rissen ist der Gewinner dieses Abschnitts.

Vim, 22 Bytes, Loojvo

qtiqtqx0l"tp^V^[^[qx0l"tp

Probieren Sie es online aus!

Erläuterung:

qt                  " Start recording in register 'q'
  i                 " Enter insert mode
   qtqx0l"tp        " Enter this string
            ^V^[    " Enter a literal 'esc' character
                ^[  " Exit insert mode
                  q " Stop recording

Zu diesem Zeitpunkt sieht der Puffer folgendermaßen aus:

qtqx0l"tp^[

Und der Cursor befindet sich in der letzten Spalte (die 'Esc'-Taste).

x                   " Delete the esc character
 0l                 " Move to the second character on this line
   "tp              " And paste register 't'

Unterlast , 20 Bytes, ais523

(:a~*(*S)):a~*(*S)*S

Probieren Sie es online aus!

Erläuterung

Die Grundvoraussetzung in Underload lautet:

(:aSS):aSS

So funktioniert es:

                                  Stack:               Output:
(:aSS)      # Push string.        (:aSS)
      :     # Duplicate.          (:aSS) (:aSS)
       a    # Wrap in (...).      (:aSS) ((:aSS))
        S   # Print.              (:aSS)               (:aSS)
         S  # Print.                                   (:aSS):aSS

Das erste Problem war, die Anzahl der Sbenötigten zu reduzieren , da wir hier nur 3 zur Verwendung haben. Wir können dies tun, indem wir swapping ( ~) und verketten ( *) verwenden:

(:a~*S):a~*S

Anstatt zweimal zu drucken, setzen wir hier die (...)Version und die einfache Version der Zeichenfolge zusammen und drucken diese nur einmal.

Das größere Rätsel ist, wie eine ungerade Anzahl von *und gedruckt wird S. Ich bin mir nicht einmal sicher, wie ich tatsächlich zur endgültigen Lösung gekommen bin, aber es stellt sich heraus, dass wir dies tun können, indem wir das Ende der Ausgabe in eine separate Zeichenfolge setzen. Diese Zeichenfolge selbst wird in der ersten Zeichenfolge dupliziert, der Inhalt jedoch nicht. Dies gibt uns die zusätzlichen Vorkommen von *und die Swir benötigen. Hier ist eine Aufschlüsselung der endgültigen Lösung:

                        Stack:                       Output:
(:a~*(*S))              (:a~*(*S))              
          :             (:a~*(*S)) (:a~*(*S))              
           a            (:a~*(*S)) ((:a~*(*S)))
            ~           ((:a~*(*S))) (:a~*(*S))
             *          ((:a~*(*S)):a~*(*S))
              (*S)      ((:a~*(*S)):a~*(*S)) (*S)
                  *     ((:a~*(*S)):a~*(*S)*S)
                   S                                 (:a~*(*S)):a~*(*S)*S

MATL, 20 Bytes, Luis Mendo

'wo&GzL0fk'tl#DwI-ch

Probieren Sie es online aus!

Ich habe MATL noch nie zuvor verwendet, daher ist mein Verständnis möglicherweise etwas verfälscht, aber im Grunde funktioniert es so:

'wo&GzL0fk' This is a string representation of the code, offset by 3
t           Creates a duplicate copy of the string
l#D         Adds quotes to the second copy
w           Swap the unquoted version to the top of the stack
I-          Offset the characters in that version by 3
c           Convert back to characters
h           Join with the quoted string

Python 2, 54 Bytes, Loojvo

l= ['l=', ';print l[0],`l`,l[1]'] ;print l[0],`l`,l[1]

Es fiel mir schwer, es zu finden, da ich Python im Grunde fast nie berührt habe

Netzhaut, 20 Bytes, Martin Ender

\)1S*`\(?
\)1S*`\(?

Probieren Sie es online aus

Ich fand das einfach, indem ich herumspielte und versuchte, eine Quine zu kreieren. Ich fand die "kürzere Quine", die er zuerst andeutete (oder zumindest eine ähnliche), einfach durch Experimentieren (14 Bytes):

\)1S*`
\)1S*`

Probieren Sie es online aus

Ich brauchte ungefähr eine halbe bis eine Stunde. Sehr klug, Martin!

JavaScript ES6, 49 Bytes, Mama Fun Roll

function f(){return    `${(((((k=>f+'')(f)))))}`}

So ziemlich die Standard-JS-Funktion quine, mit ein wenig Verschleierung.

> <> , 36 Bytes, Erik der Golfer

'''000**rd3*:::?!;od0.!!+..233??dfrr

Probieren Sie es online aus!

Ich bin mir ziemlich sicher, dass dies nicht die beabsichtigte Lösung ist. > <> Quines machen es jedoch ziemlich einfach, die meisten unerwünschten Zeichen mit Ausnahme der zu entfernen '. Glücklicherweise :machte es das ziemlich einfach, sich auch um diese zu kümmern.

Erläuterung

'''                                    Push everything except these quotes onto the stack.
   000**                               In effect, pushes a zero.
        r                              Reverse the stack.
         d3*                           Push 39 (the quote character).
            ::                         Make two copies. The stack now holds
                                       a null-terminated representation of the
                                       entire code.
                                       The print loop begins here...
              :                        Duplicate top of stack.
               ?!;                     Terminate if zero.
                  o                    Otherwise, print.
                   d0.                 Jump back to position 13, i.e. the
                                       beginning of the print loop.
                      !!+..233??dfrr   Unused characters.

JavaScript, 147 Bytes, jrich

+function e(){window[(w=[``>``]+``)[i=9/9]+w[i+i]+"ert"]('+'+e+'()');"  +./;;;;;=======>[]````````ccddddddeeeeeeeefiinnnnoooooorrrrrrrsttuwwx{}"}()

Mit all diesen zusätzlichen Zeichen ist dies definitiv nicht die beabsichtigte Lösung :-)

Haskell, 86 Bytes, Laikoni

y!r=r:y:r:[y]>>=id;main=putStr$[succ$'!']!"y!r=r:y:r:[y]>>=id;main=putStr$[succ$'!']!"

Gute Idee, die "Via zu bekommen succ$'!'(ascii char after !). Es fehlten einige Zeichen, um sie auf die übliche Weise zu erhalten, dh implizit über showoder print.

Befunge , 15 Bytes, James Holderness

<:0:+1_@#%9,:g-

Probieren Sie es online aus!

Erläuterung

Der Haken dabei ist, dass die Schleife endet, wenn das aktuelle Zeichen durch 9 teilbar ist, was nur für der Fall ist -. Daher muss das am Ende gehen.

<                 Run code from right to left.
              -   There will always be 2 zeros on top of the stack at this
                  point, and this just reduces them to 1 zero.
             g    Get the character at the coordinates given by the top
                  two stack values, (0, 0) initially.
           ,:     Print a copy of that character.
         %9       Modulo 9.
      _@#         Terminate if that is 0.
    +1            Increment the x coordinate.
   :              Duplicate it.
 :0               Push two zeros.

PHP, 110 Bytes, Oliver

<?php $x='<?php $x=0; echo strtr($x, array(chr(39).$x.chr(39)));'; echo strtr($x, array(chr(39).$x.chr(39)));

Danke, ich hatte Spaß und der strtr([])Trick war neu für mich, von dem ich hoffe, dass er mir in Zukunft einige Bytes erspart.

Gelee , 3 Bytes, Erik der Golfer

”ṘṘ

Probieren Sie es online aus!

Es gibt nicht wirklich so viele Optionen ... (Außerdem ist dies die Standard-Quine.)

Python 2, 105 Bytes, Erik der Golfer

a='a=%r;print a%%a ###(((())))**-01::@@@@@[[]]gggiiirrr~';print a%a ###(((())))**-01::@@@@@[[]]gggiiirrr~

Es ist nur die Standard-Python-String-Formatierungs-Quine ...

Ruby, 53 Bytes, Wat

puts <<ENDIT*2,"ENDIT"
puts <<ENDIT*2,"ENDIT"
ENDIT

Nur eine Modifikation des Standard-Heredoc-Quines:

puts <<2*2,2
puts <<2*2,2
2