Das ist der Räuberfaden. Der Faden der Bullen geht hier .

Schreiben Sie einen Code, der die gleiche Anzahl von Bytes aufweist wie der Cop-Post und bei dem die offenbarten Zeichen identisch sind. Der Code muss 1im Ausgangszustand produzieren und die Zahlen produzieren, 2, 3 ..wenn einzelne Änderungen vorgenommen werden.

Der Gewinner ist der Räuber, der die meisten Beiträge geknackt hat.

Beispielbeitrag:

MyLang, 9 Bytes, 8 Zahlen (einschließlich Link zur Antwort), Cop's Benutzername.

Originalcode:

abc1efghi

Code, der 1 - 8 erzeugt:

1: abc1efghi
2: abc2efghi
3: abc2efghij
4: kbc2efghij
5: kbc23fghij
6: kbc23fghi
7: kbc63fghi
8: kbc63fhi

Erklärungen sind erwünscht. Das genaue Format des Räuberpostens ist optional.

Retina, 2 Bytes, 10 Ziffern, von Martin Ender .

Originalcode:

1

Dies ersetzt die leere Eingabe durch die Nummer 1.

Code, der 1 - 10 erzeugt (der Einfachheit halber werden Zeilenumbrüche angezeigt \n):

1 : \n1
2 : \n1\n
3 : \n11\n
4 : \n111\n
5 : \n1111\n
6 : \n11111\n
7 : \n111111\n
8 : \n1111111\n
9 : \n11111111\n
10: \n111111111\n

Ab 2 zählen wir die Anzahl der leeren Zeichenketten in der vorherigen Stufe. Für 2 gibt es eine leere Zeichenfolge vor und nach der 1. Für 3 gibt es eine leere Zeichenfolge vor den Einsen, zwischen den Einsen und nach den Einsen. Dies funktioniert bis zu 10.

Probieren Sie es online aus

Perl, 12 Bytes, 10 Zahlen, von ais523

Originalcode:

____;say__-9

Code, der 1 - 10 erzeugt:

wait;say$!-9
wait;say$!-8
wait;say$!-7
wait;say$!-6
wait;say$!-5
wait;say$!-4
wait;say$!-3
wait;say$!-2
wait;say$!-1
wait;say$!-0

Erläuterung:

wait;         # waits for a child process to end (there is no child so it just returns)
     say      # put the following on the screen:
        $!    # current value of the C errno. In this case, ECHILD (No child processes)
              # which has a value of 10
          -9  # minus 9

JavaScript, 30 Bytes, 10 Zahlen, von ETHproductions .

Originalcode:

1: alert(Array(2).join(3).length)

Andere Nummern

 2: alert(Array(2).join(31).length)
 3: alert(Array(2).join(314).length)
 4: alert(Array(2).join(3141).length)
 5: alert(Array(2).join(31415).length)
 6: alert(Array(2).join(314159).length)
 7: alert(Array(2).join(3141592).length)
 8: alert(Array(2).join(31415926).length)
 9: alert(Array(2).join(314159265).length)
10: alert(Array(2).join(3141592653).length)

Erläuterung

Array(2)Erstellt ein Array mit zwei leeren Zellen. Die .joinMethode verbindet alle Elemente in einem Array mithilfe eines Begrenzers, der es in einen String konvertiert. Im Originalcode war das Trennzeichen 3. Dies bedeutet, dass die beiden leeren Zellen im Array zusammengefügt werden und 3als Trennzeichen dienen. Dies wird ausgewertet "3", ohne dass auf beiden Seiten des 3Arrays etwas angezeigt wird, da das Array leer ist. Und da das lengthvon "3"ist 1, wird dieser Wert an die Konsole ausgegeben.

Für die anderen Zahlen füge ich dem Begrenzer, der die Elemente des Arrays verbindet, eine weitere Ziffer hinzu. Dies verlängert sich also alertmit zunehmenden Werten. Beachten Sie, dass der numerische Wert des Begrenzers nicht wichtig ist, sondern nur die Länge.

Snack Snippet!

Hinweis: Ich habe aus offensichtlichen Gründen console.loganstelle von alertin meinem Snack Snippet verwendet. Die Ausgabe von der Konsole wird auch im Snippet angezeigt.

console.log(Array(2).join(3).length)
console.log(Array(2).join(31).length)
console.log(Array(2).join(314).length)
console.log(Array(2).join(3141).length)
console.log(Array(2).join(31415).length)
console.log(Array(2).join(314159).length)
console.log(Array(2).join(3141592).length)
console.log(Array(2).join(31415926).length)
console.log(Array(2).join(314159265).length)
console.log(Array(2).join(3141592653).length)

Oktave, 17 Bytes, 10 Zahlen, von Stewie Griffin

original:
_i_(__i__(2_5_))

solution:
fix( 'i'-(2*52))
fix( 'j'-(2*52))
fix( 'k'-(2*52))
fix( 'l'-(2*52))
fix( 'm'-(2*52))
fix( 'n'-(2*52))
fix( 'o'-(2*52))
fix( 'p'-(2*52))
fix( 'q'-(2*52))
fix( 'r'-(2*52))

Python 2, 17 Bytes, 10 Zahlen, von xnor

print len(['  '])
print len(*['  '])
print len(*['   '])
print len(*['    '])
print len(*['     '])
print len(*['      '])
print len(*['       '])
print len(*['        '])
print len(*['         '])
print len(*['          '])

repl.it

Python 2, 9 Bytes, 10 Zahlen, xnor

print 8/8
print 18/8
print 28/8
print 38/8
print 38/7
print 38&7
print 31&7
print 31&72
print 31&73
print 31&74

Perl, 14 Bytes, 10 Zahlen, von Dada

Originalcode:

say_!"___"%""_

Code, der 1 - 10 erzeugt:

1. say"!"+1#"%""r
2. say"!"+2#"%""r
3. say"!"+3#"%""r
4. say"!"+4#"%""r
5. say"!"+5#"%""r
6. say"!"+6#"%""r
7. say"!"+7#"%""r
8. say"!"+8#"%""r
9. say"!"+9#"%""r
10. say"1"+9#"%""r

Ich habe das Gefühl, dass Sie das nicht wollten.

JavaScript, 22 Bytes, 10 Zahlen, von Arnauld

Ursprüngliches Programm:

alert(0_6_4_>_0_2_0_7)

Gebrochen:

1. alert(0+6^42>101210^7)
2. alert(0+5^42>101210^7)
3. alert(0+4^42>101210^7)
4. alert(0+3^42>101210^7)
5. alert(0+2^42>101210^7)
6. alert(0+1^42>101210^7)
7. alert(0+0^42>101210^7)
8. alert(0+0^42>101210^8)
9. alert(0+0^42>101210^9)
10. alert(0+3^42>101210^9)

Der schwierige Teil ist, sich mit dem zu befassen >, was eine sehr geringe Priorität hat. Ich habe versucht, es in ein zu ändern >>, aber es ist am einfachsten, es zu absorbieren, indem es nutzlos gemacht wird, um ein boolesches Falsch (the) zu berechnen42>101210 Abschnitt) zu das numerisch 0 ist, und einfach die Zahlen von 1 bis 10 mit Operatoren mit einer noch niedrigeren Priorität als zu generieren >. Ich habe ^bitweises xor verwendet, weil es die Zahlen von 1 bis 10 ziemlich einfach erzeugen kann (praktischerweise lassen mich die 6 und 7 in der ursprünglichen Eingabe den Ausdruck bis auf 6^71 vereinfachen ).

JavaScript, 9 Bytes, Hedi

Originalcode:

alert(+1)

Änderungen:

alert(1+1)   // 2
alert(2+1)   // 3
alert(3+1)   // 4
alert(4+1)   // 5
alert(5+1)   // 6
alert(6+1)   // 7
alert(7+1)   // 8
alert(8+1)   // 9
alert(9+1)   // 10

Oktave, 55 Bytes, 10 Zahlen, fehlerhaft

(o=@(O,o)(@(O,o)o{2-O} ) (0<O,{ (yo=O-1)+1,@()1}))(1,o)

Die letzte 1kann bis 9 radelte werden, und dann die Änderung +1zu +2.

Python 3, 16 Bytes, 10 Zahlen, von Sp3000

Das hat Spaß gemacht.

print(?%??f?r?t)

print(1%0xfor t)
print(2%0xfor t)
...
print(8%0xfor t)
print(84%0xfor t)
print(85%0xfor t)

Nutzt die Tatsache (die ich bis jetzt nicht kannte) aus, dass ein Hex-Literal endet, sobald ein Zeichen, das nicht 0-9a-fA-Fangetroffen wird, auftaucht - also 0xforeine sehr hinterhältige Art zu schreiben 15 or. Danach galt es, den richtigen Wert zu finden, der mit 10 modulo 15 übereinstimmt.

JavaScript, 22 Bytes, 10 Zahlen von Arnauld

Originalcode :

alert(__14_337__xc_de)

Geändert :

alert(00140337-0xc0de) // 1
alert(00140337-0xc0dd) // 2
alert(00140337-0xc0dc) // 3
alert(00140337-0xc0db) // 4
alert(00140337-0xc0da) // 5
alert(00140337-0xc0d9) // 6
alert(00140337-0xc0d8) // 7
alert(00140337-0xc0d7) // 8
alert(00140337-0xc0d6) // 9
alert(00140337-0xc0d5) // 10

Ich vermute, das ist nicht die beabsichtigte Lösung, aber ich hoffe, es ist nicht zu weit weg ...

Oktave, 32 Bytes, 10 Ziffern, von Luis Mendo

Originalcode:

nnz(isprime(floor(s=3):i*-2i))+1

Geänderte Codes:

2:  nnz(isprime(floor(s=3):i*-3i))+1
3:  nnz(isprime(floor(s=3):i*-5i))+1
4:  nnz(isprime(floor(s=3):i*-9i))+1
5:  nnz(isprime(floor(s=3):i*-9i))+2
6:  nnz(isprime(floor(s=3):i*-9i))+3
7:  nnz(isprime(floor(s=3):i*-9i))+4
8:  nnz(isprime(floor(s=3):i*-9i))+5
9:  nnz(isprime(floor(s=3):i*-9i))+6
10: nnz(isprime(floor(s=3):i*-9i))+7

Hier gibt es viele Möglichkeiten, Änderungen vorzunehmen (z. B. s=2und+0 am Anfang).

Edit: Eine wahrscheinlichere Alternative:

nnz(isprime(floor(s=2):i*-2i))+0
nnz(isprime(floor(s=2):i*-2i))+1
nnz(isprime(floor(s=2):i*-2i))+2
nnz(isprime(floor(s=2):i*-2i))+3
nnz(isprime(floor(s=2):i*-2i))+4
nnz(isprime(floor(s=2):i*-2i))+5
nnz(isprime(floor(s=2):i*-2i))+6
nnz(isprime(floor(s=2):i*-2i))+7
nnz(isprime(floor(s=2):i*-2i))+8
nnz(isprime(floor(s=2):i*-2i))+9

05AB1E , 11 Bytes, 10 Zahlen, von Oliver

Originalcode:

 1: 3628801zï0>

Andere Nummern

 2: 3628801zï0>>
 3: 3628801zï0>>>
 4: 3628801zï0>>>>
 5: 3628801zï0>>>>>
 6: 3628801zï0>>>>>>
 7: 3628801zï0>>>>>>>
 8: 3628801zï0>>>>>>>>
 9: 3628801zï0>>>>>>>>>
10: 3628801zï0>>>>>>>>>>

Erläuterung

3628801                        # push this number
       z                       # find its reciprocal
        ï                      # round it to the nearest integer (becomes 0)
         0                     # push 0
          >>>>                 # increment by 1 for each `>` present (this is for 4)
                               # implicit output

Um es zusammenzufassen, drücken Sie 3628801 , nehmen Sie den Kehrwert und runden Sie ihn auf die nächste ganze Zahl (ergibt 0). Dann erhöhen Sie den Stapel. TADA!

Probieren Sie es online! Für output = 1 Fügen Sie dann so viele >s hinzu, wie Sie möchten, je nachdem, welche Zahl Sie ausgeben möchten.

JavaScript, 12 Bytes, 10 Zahlen, Hedi

Originalcode:

alert(+[+1])

2 bis 10:

alert(+[1+1])
alert(+[2+1])
alert(+[3+1])
alert(+[4+1])
alert(+[5+1])
alert(+[6+1])
alert(+[7+1])
alert(+[8+1])
alert(+[9+1])

Mit so viel Code kann man nur so viel machen ...

Jelly, 7 Bytes, 10 Zahlen, Jonathan Allan

Originalcode:

“1‘ỌȮḊ‘

Dann:

“1‘‘ỌȮḊ‘
“1‘‘‘ỌȮḊ‘
“1‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌȮḊ‘
“1‘‘‘‘‘‘‘‘‘ỌvḊ‘

Sie können den letzten auf TryItOnline überprüfen!

“2‘ỌȮḊ‘
“3‘ỌȮḊ‘
...
“9‘ỌȮḊ‘
“9‘ỌvḊ‘

Oktave, 21 Bytes, 10 Zahlen, von Stewie Griffin

Das fprwar ein netter Irrtum =) Aber ich liebe die (1') -> 2(1') -> 2+(1')Sequenz!

original:
disp(fpr___f__e_(_'_)     % original
disp(fprintf= e=(1'))     % my solution
disp(fprintf= e=2(1'))
disp(fprintf= e=2+(1'))
disp(fprintf= e=3+(1'))
disp(fprintf= e=4+(1'))
disp(fprintf= e=5+(1'))
disp(fprintf= e=6+(1'))
disp(fprintf= e=7+(1'))
disp(fprintf= e=8+(1'))
disp(fprintf= e=9+(1'))

Hexagony, 7 Bytes, 10 Zahlen, von Martin Ender

Original:

1<@|!__

Code, der 1 - 10 erzeugt:

1<@|!).
2<@|!).
3<@|!).
4<@|!).
5<@|!).
6<@|!).
7<@|!).
8<@|!).
9<@|!).
9<@|!).!

1: Online ausprobieren!
9: Online ausprobieren!
10: Online ausprobieren!

Hier ist das Hex für die ersten 9 Programme (wobei # die Nummer ist, die Sie drucken möchten):

 # <
@ | !
 ) .

Die Speicherkante wird einfach auf den Wert gesetzt, den Sie drucken möchten, auf die SE umgelenkt und gedruckt.

Und das Hex für 10:

  9 < @
 | ! ) .
! . . . .
 . . . .
  . . . 

Hier habe ich ein Zeichen am Ende hinzugefügt, wodurch die Hex-Größe erhöht wurde. Zuerst wird die Speicherflanke auf 9 gesetzt, der Zeiger wird auf SE abgelenkt, der Speicher wird inkrementiert, der Zeiger wird auf SW abgelenkt, der Wert wird gedruckt und das Programm endet.

Hier ist eine zweite Lösung:

1<@|!$)
2<@|!$)
3<@|!$)
...
8<@|!$)
9<@|!$)
9#@|!$)

1: Online ausprobieren!
9: Online ausprobieren!
10: Online ausprobieren!

Das Hex für 1 - 9 (diesmal *ist es die zu druckende Zahl):

 * <
@ | !
 $ )

Dies funktioniert genauso wie 1 - 9 oben.

Das Hex für 10:

 9 #
@ | !
 $ )

Diese Treffer haben 9dann #den Befehlszeiger nach rechts unten verschoben, der Speicher wird auf 10 erhöht , der Zeiger $springt über !den Zeiger und der Zeiger wird wieder nach Osten gedreht, wo er über den Zeiger springt )und endet.

C #, 90 Bytes, 10 Zahlen, Scepheo

Original:

using ______________________________________________;class C{static void Main(){_______;}}

Zuerst:

using System;class D{public D(){Console.Write(+1);}};class C{static void Main(){new D();}}

Dann:

using System;class D{public D(){Console.Write(1+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(2+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(3+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(4+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(5+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(6+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(7+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(8+1);}};class C{static void Main(){new D();}}
using System;class D{public D(){Console.Write(9+1);}};class C{static void Main(){new D();}}

Ruby, 81 Bytes, 10 Zahlen, Histokrat

Originalcode:

x=##/=#%#
)
###x

Gebrochen:

x=/$/=~%q
)

p x

Das war eine knifflige Sache. Viele Charaktere, die enthüllt wurden, erwiesen sich als rote Heringe! /ist keine Teilung, sondern Teil eines Regex-Buchstabens. %ist kein Mod, sondern Teil einer ungewöhnlichen String-Literal-Syntax. Dieses Programm gibt einfach die Länge eines durch Zeilenumbrüche begrenzten Strings aus. Die nachfolgenden Programme erhalten Sie, indem Sie zusätzliche Zeichen in die zweite Zeile einfügen.

Oktave, 25 Bytes, 10 Zahlen, von Luis Mendo

mean(repmat(1,ones(1,1)))
mean(repmat(2,ones(1,1)))
mean(repmat(3,ones(1,1)))
mean(repmat(4,ones(1,1)))
mean(repmat(5,ones(1,1)))
mean(repmat(6,ones(1,1)))
mean(repmat(7,ones(1,1)))
mean(repmat(8,ones(1,1)))
mean(repmat(9,ones(1,1)))

아희 (Aheui), 19 Bytes, 10 Zahlen, von JHM

Originalcode:

봃法희
반자뭉

Geändert:

2
봃法희
반반뭉
3
봃法희
반밬뭉
4
봃法희
반밭뭉
5
봃法희
반발뭉
6
봃法희
반타뭉
7
봃法희
반밝뭉
8
봃法희
반밣뭉
9
봃法희
반밢뭉
10
봃法희
반다뭉

Oktave, 24 Bytes, 9 Ziffern, von flawr

max(repmat(1,ones(),1))%
max(repmat(2,ones(),1))%
max(repmat(3,ones(),1))%
max(repmat(4,ones(),1))%
max(repmat(5,ones(),1))%
max(repmat(6,ones(),1))%
max(repmat(7,ones(),1))%
max(repmat(8,ones(),1))%
max(repmat(9,ones(),1))%

Oktave, 24 Bytes 9 10 Zahlen

Hinweis: Dieser Riss ist für die erste Version des Kops Post (das falsche Schnipsel gepostet), mit dem geoffenbarten Code wie folgt aussehen: ___a__repmat(__one__),__). Die richtige Version ist oben.

Originalcode:

+mean(repmat(1,ones(),1))

Geänderte Versionen, die 2-10 drucken

1+mean(repmat(1,ones(),1))
2+mean(repmat(1,ones(),1))
3+mean(repmat(1,ones(),1))
4+mean(repmat(1,ones(),1))
5+mean(repmat(1,ones(),1))
6+mean(repmat(1,ones(),1))
7+mean(repmat(1,ones(),1))
8+mean(repmat(1,ones(),1))
9+mean(repmat(1,ones(),1))

JavaScript, 15 Bytes, 10 Zahlen, ETHProductions

Originalcode:

alert( +"+1"+0)  // Prints 1

Programme:

alert( +"+1"+1)  // Prints 2
alert( +"+1"+2)  // Prints 3
alert( +"+1"+3)  // Prints 4
alert( +"+1"+4)  // Prints 5
alert( +"+1"+5)  // Prints 6
alert( +"+1"+6)  // Prints 7
alert( +"+1"+7)  // Prints 8
alert( +"+1"+8)  // Prints 9
alert( +"+1"+9)  // Prints 10

Oktave, 21 Bytes, 9 Ziffern, von flawr

Ich habe es wirklich genossen ... Clever :)

a='repmat(1one'(1,8)
a='repmat(2one'(1,8)
a='repmat(3one'(1,8)
a='repmat(4one'(1,8)
a='repmat(5one'(1,8)
a='repmat(6one'(1,8)
a='repmat(7one'(1,8)
a='repmat(8one'(1,8)
a='repmat(9one'(1,8)

Acc !! , 10 Bytes, 9 Zahlen, von DLosc

Originalcode:

Write 49+_

So erzeugen Sie die Zahlen 1 bis 9:

Write 49+_
Write 49+1
Write 49+2
Write 49+3
Write 49+4
Write 49+5
Write 49+6
Write 49+7
Write 49+8

49 ist der ASCII-Code von 1. _enthält standardmäßig 0 (so 49+_ = 1). Und gibt Writedas Zeichen aus, das dem ASCII-Code seines Arguments entspricht. Ziemlich einfach.

Python 2, 49 Bytes, 10 Zahlen, AlexRacer

Vielleicht (nur vielleicht) die beabsichtigte Lösung, aber wenn ja, könnten viele Bytes abgegolft sein:

y=10-6;s='0901100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0902100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0903100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0904100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0905100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0906100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0907100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0908100000';print int(s[8-8+y-2+0+0:y])
y=10-6;s='0909100000';print int(s[8-8+y-2+0+0:y])
y=10-4;s='0909100000';print int(s[8-8+y-2+0+0:y])

Befunge-93 , 11 Bytes, 10 Zahlen, James Holderness

905:**-8-.@
905:**-7-.@
905:**-6-.@
905:**-5-.@
905:**-4-.@
905:**-3-.@
905:**-2-.@
905:**-1-.@
905:**-0-.@
905:**-~-.@

Probieren Sie es online!

Wahrscheinlich nicht die beabsichtigte Lösung.

Was ich getan habe, war die lästige 25 ( 5:*) durch Multiplikation mit loszuwerden 0. Wenn wir dann ein 9am Anfang setzen, werden die Ausgaben dort sein, 9 - Nwo sie Naus einem einzelnen Befehl generiert werden müssen . Das einzige Problem ist -1zu bekommen 10, aber der Versuch, eine Ganzzahl zu lesen, wenn es keine Eingabe gibt, drückt bequem a -1.

05AB1E, 5 Bytes, 10 Zahlen, von Adnan .

Originalcode:

…[==1

1-10:

…[==1
…[==2
…[==3
…[==4
…[==5
…[==6
…[==7
…[==8
…[==9
…[==T

Erläuterung:

…[==   3 char string
    1  Push number

05AB1E, 6 Bytes, 10 Zahlen, Adnan

Originalcode:

¼ [==q

Fügen Sie weitere hinzu ¼, um bis zu 10 auszugeben:

¼¼ [==q
¼¼¼ [==q
¼¼¼¼ [==q
¼¼¼¼¼ [==q
¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼ [==q
¼¼¼¼¼¼¼¼¼¼ [==q

Probieren Sie es online aus

Wie es funktioniert:

¼        # Increment counter_variable to count_of(¼), it's printed at some point...
  [      # Infinite loop start
   ==    # Print nothing because stack is empty
     q   # Quit