Die Herausforderung ist hier einfach und geht überhaupt nicht um die Anzahl der Bytes. Ihre Aufgabe ist es, die ersten 50 Zeichen des Quellcodes der vorherigen Quine auszugeben, verknüpft mit den ersten 50 Zeichen, beginnend mit den 50 Zeichen, die ich unten platziert habe:

abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXY

Nehmen wir hier ein Beispiel, wenn Sie in 05AB1E antworten würden, wäre eine Lösung, um einfach die ersten 50 Bytes auszugeben:

ži50£

Was bedeuten würde, dass Sie Folgendes ausgeben müssten:

abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXYži50£

Wenn Ihr Programm kürzer ist, verwenden Sie einfach die ersten x < 50Zeichen. Wenn Ihr Programm länger ist, verketten Sie nur die ersten 50 Zeichen, die mit dem 50. Zeichen enden. Die nächste Person muss dann die ersten 50 Zeichen Ihres Quines ausgeben, die mit ihrem eigenen Code verknüpft sind.

Ihr Code kann eine beliebige Größe haben. Sie sollten jedoch nur die ersten 50 Zeichen Ihres Codes ausgeben, die bis zum Ende der ersten 50 Byte des Codes der vorherigen Antwort verkettet sind.

Beschränkungen:

Dies verwendet die Definition eines richtigen Quines und zusätzlich die folgenden Dinge:

• Kommentare sind gänzlich unzulässig.
• BEACHTEN SIE DIESEN ABSCHNITT, ER KANN SICH ENTWICKELN, WENN SCHLEIFEN FALLEN

So posten Sie eine verkettete Antwort:

1. Platzhalter posten:
   • Erwähnen Sie Ihre Antwortnummer und die Sprache, die Sie verwenden werden.
2. Sortieren nach Datum, wenn Sie bemerken, dass eine andere Person einen Platzhalter 1 Millisekunde vor Ihnen gepostet hat:
   • Lösche deine, warte auf die nächste Gelegenheit, sorry.
3. Wenn Sie sich den nächsten Platz gesichert haben, antworten Sie bitte innerhalb von 6 Stunden :
   • Wenn Sie nicht antworten können, entfernen Sie Ihren reservierten Platz.
4. WENN der Raum länger als 6 Stunden überfüllt ist.
   • Stimmen Sie ab, um reservierten Platz zu löschen, ich werde damit umgehen.

Ihr Beitragsformat:

#[Answer #]:[Character Count] Characters, [Language Used]

{TIO MARKDOWN}

{LINE_SEPARATOR="---"}

{ADDITIONAL EXPLANATION OR INFORMATION}

Einige spezielle Hinweise (Wichtig für einen einfachen Wettbewerb):

• Wenn die Person vor Ihnen Zeilenumbrüche oder Nicht-ASCII-Zeichen in ihre Quelle aufgenommen hat, können Sie sie STREIFEN. Das heißt das x="a\nb"wird abwo x[0]=a;x[1]=b;.
  • Sie müssen die Mutation angeben, die Sie auf die vorherige Quelle angewendet haben.
• Alle Zeichen werden trotz Codepage- oder Sprachcodierung als ein einzelnes Zeichen gezählt. Bitte verwenden Sie nicht die Anzahl der Bytes, sondern die Anzahl der Zeichen.

Die akzeptierte Antwort ist die 50thAntwort, nur weil; Ich meine, es ist immerhin SE.

1: 96 Charaktere, Haskell

abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXY:z=['`'..'z']++'A':['C'..'Y']
main=putStr$z++z

Probieren Sie es online!

Ich fühlte mich albern und sah nichts, was es verbot, den ersten Eintrag mit genau demselben zu beginnen 50 Zeichen wie die ursprüngliche Zeichenfolge zu beginnen.

• ['`'..'z']++'A':['C'..'Y']ist ein Ausdruck, der die Zeichenfolge dieser Zeichen mit `vorangestelltem Wert bewertet .
• Das Ergebnis ist ein Mustervergleich, bei dem die Variable abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXYgleich '`'und istz gleich den 50 Zeichen ist.
• main=putStr$z+z dann erfolgt die eigentliche Ausgabe.

5:76 Zeichen, Emojicode

🏁🍇🍦a🔤s=:'"alert(eval(c="''abcdefghijklmnopqrstuvwxyzACD🔤😀🍪a🔤🏁🍇🍦a❌🔤🔤🔪a 0 45🍪🍉

Probieren Sie es online!

Erläuterung:

🏁🍇		👴 start
  🍦 a 🔤...🔤	👴 define variable a as that string
  😀    	👴 print:
    🍪		👴 combine those strings:
      a		👴 a, and:
      🔤🏁🍇🍦a❌🔤🔤	👴 string literal. the ❌🔤 works like \"
      🔪a 0 45	👴 between indexes 0 and 45 of a
    🍪
🍉		👴 end

2: 119 Zeichen, Javascript

alert(eval(c="'abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXY'+`alert(eval(c=${JSON.stringify(c).substr(0,37)}`"))

Online ausprobieren (wird console.loganstelle der alertAusgabe verwendet)

Basierend auf dieser JS-Quine.

Alte Version (liest den Quellcode):

f=_=>`abcdefghijklmnopqrstuvwxyzACDEFGHIJKLMNOPQRSTUVWXYf=${(f+"").substr(0,48)}`;alert(f())

Basierend auf dieser JS-Quine

8: 70 Zeichen, Stax

"v->{String t=`"⛽as=:'\`"alert(eval(c=\`"''abcdefghijk"c'".`"R34|S50(+

Online ausführen und debuggen

Erläuterung

"..."c'".`"R34|S50(+
"..."                   The string from last output
     c'".`"R            Escape all double quotes
            34|S        Surround with double quotes
                50(     Take the first 50 characters
                   +    Append to the string from last output
                        Implicit output

3:56 Zeichen, SOGL

"alert(eval(c="'abcdefghijklmnopqrstuvwxyzACDEFGHIJ”1#Οj

Probieren Sie es hier aus!

Erläuterung:

"...”      push the first 50 bytes of the previous answer
     1#Ο   wrap a quote around with that
        j  take the last letter off, as my answer has one more byte for the starting quote.

Die Javascript-Antwort enthielt ein Zitat, also musste ich ein Startzitat hinzufügen, aber da dies kein Code-Golf ist, spielt es keine Rolle.

4:81 Zeichen, J

s=:'"alert(eval(c="''abcdefghijklmnopqrstuvwxyzACDEFGHI'
echo s,50{.'s=:',quote s

Probieren Sie es online!

7: 137 Zeichen, Java 8

v->{String t="⛽as=:'\"alert(eval(c=\"''abcdefghijklmnopqrstuvwxyzA";return t+("v->{String t=\""+t.replace("\"","\\\"")).substring(0,50);}

Probieren Sie es online aus.

Erläuterung:

v->{        // Method with empty unused parameter and String return-type
  String t="⛽as=:'\"alert(eval(c=\"''abcdefghijklmnopqrstuvwxyzA";
            //  String containing the first 50 characters of the previous answer
  return t  //  Return those first 50 characters
   +"v->{String t=\""+t.replace("\"","\\\"")).substring(0,50);}
            //  Concatted with the first 50 characters of my answer
            //  with correct escape-slashes

6: 70 Zeichen, Emoji

⛽as=:'"alert(eval(c="''abcdefghijklmnopqrstuvwxyzAC🚘👥💬⛽💬🔀👫💬0💬📥💬-1💬📥✂👫➡

Probieren Sie es online!

Es scheint unmöglich zu sein, die nachfolgende Newline nicht auszugeben. Wenn das nicht in Ordnung ist, entferne ich die Antwort.

Erläuterung:

⛽ ... 🚘	String literal
👥		Duplicate
💬⛽💬		Push ⛽ as a string
🔀		Swap the top two strings. Stack: [long literal] "⛽" [long literal]
👫		Concatenate.
💬0💬📥💬-1💬📥✂	Remove the last character
👫		Concatenate.
➡		Print.

12: 202 Zeichen, Ruby

puts "21ipdgmtwkkke7ynvzpcnlzt7kl".to_i(36).to_s(7).gsub('0','>').gsub('1','+').gsub('2','-').gsub('3','<').gsub('4','[').gsub('5','.').gsub('6',']')+'puts "21ipdgmtwkkke7ynvzpcnlzt7kl".to_i(36).to_s(7'

Probieren Sie es online!

Codiert die ersten fünfzig Zeichen der vorherigen Antwort in Basis sieben

• 0:>
• 1: +
• 2: -
• 3: <
• 4: [
• 5:.
• 6:]

Wandelt es dann in Basis 36 um, um "21ipdgmtwkkke7ynvzpcnlzt7kl" zu erhalten

9: 55 Zeichen, Jelly

“"v->{String t=`"as=:'\`"alert(eval(c=\`"''abcdefg”;”“;

Probieren Sie es online!

Ich habe das Nicht-ASCII-Zeichen entfernt ⛽ aus der Ausgabe entfernt, da dies zulässig ist, und Jelly hat es ignoriert.

Erläuterung

Dies beginnt mit dem Zeichenkettenliteral der ersten 50 Zeichen (Minus ⛽) der vorherigen Antwort, hängt dann das Zeichen “an dieses an ;”“und hängt dann das ursprüngliche Zeichenkettenliteral wieder an das Ende des Finales an ;. Da ein Zeichen entfernt wurde, sind die ersten 50 Zeichen meines Quellcodes die 49 aus der vorherigen Antwort mit einem “vorangestellten, wodurch dieses Programm so kurz sein kann. (Ja, mir ist klar, dass dies kein Code-Golf ist, aber warum nicht Golf spielen, wenn Sie können?)

10: 116 Zeichen, Python 3

print('''“"v->{String t=`"as=:'\`"alert(eval(c=\`"''abcdefgprint(\'\'\'“"v->{String t=`"as=:'\`"alert(eval(c=\`"''')

Druckt einfach eine Zeichenfolge aus den ersten 50 Zeichen von Antwort 9, gefolgt von den ersten 50 Zeichen der eigenen Quelle. Es ist keine quineartige Klugheit erforderlich, da die entgangenen Anführungszeichen (\'\'\' ) nach dem 50. Zeichen erscheinen und daher nicht in der Ausgabe reproduziert werden müssen.

Diese Methode funktioniert in praktisch jeder Sprache - Sie müssen nur Anführungszeichen, die in der vorherigen Antwort erscheinen, maskieren. Dementsprechend denke ich nicht, dass diese Herausforderung viel Herausforderung ist.

11: 723 Zeichen, Brainf ***

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

Nicht druckbares “Zeichen entfernt. Fast vollständig von Brainfuck Text Generator generiert . Könnte auch faul sein, oder?

TIO

Print [print('''"v->{String t=`"as=:'\`"alert(eval(c=\`"] +[------->++<]>++.++.---------.+++++.++++++.+[--->+<]>+.-...-----------.++++++.[----->++<]>++.--[++>---<]>-.---[-->+++<]>-.[->++<]>-.[--->++<]>+.[--->+<]>+++.--.---------.+++++.-------.-[--->+<]>--.---[->++++<]>.[-->+<]>+++.+++[-->+++<]>.[->+++<]>++.+[--->+<]>.--[--->+<]>--.+[-->+<]>+++.---.-[--->++<]>+.+[------>+<]>.++++.[->+++<]>++.+[--->+<]>.+++++++++++.-------.+++++++++++++.++.+[--->+<]>+.+[--->+<]>++.[--->+<]>-.[->+++<]>-.+++++++++++.[--->+<]>++++.+[--->+<]>.[--->++<]>-----.+[-->+++<]>-.++++.[->+++<]>++.
Clear all cells to left until first empty cell [[-]<]
Print [+[------->++<]>++.++.---------.+++++.++++++.+[--->] ++[------>+<]>.++[->++<]>+.-[-->+<]>.......---[-->+++<]>-.+[--->++<]>+..+[----->+<]>.++[-->+++<]>.[--->++<]>.+[--->++<]>+..+++.---..+++.-.........+.---.....+++.---......+++.---.++[->++<]>+.-[-->+<]>...---[-->+++<]>-.