To wątek złodziei. Wątek gliniarzy idzie tutaj .

Napisz kod, który ma taką samą liczbę bajtów jak post gliniarza i gdzie ujawnione znaki są identyczne. Kod musi generować 1w stanie początkowym i generować liczby 2, 3 ..po wprowadzeniu pojedynczych zmian.

Zwycięzcą zostanie złodziej, który złamał najwięcej postów.

Przykładowy post:

MyLang, 9 bajtów, 8 cyfr (w tym link do odpowiedzi), nazwa użytkownika Cop.

Oryginalny kod:

abc1efghi

Kod produkujący 1–8:

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

Wyjaśnienia są zachęcane. Dokładny format postu rabusia jest opcjonalny.

Retina, 2 bajty, 10 cyfr, autor: Martin Ender .

Oryginalny kod:

1

Zastępuje to puste dane wejściowe liczbą 1.

Kod, który tworzy 1–10 ( \ndla ułatwienia wyświetla nowe znaki ):

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

Od 2 i więcej liczymy liczbę pustych łańcuchów w poprzednim etapie. Dla 2 jest pusty ciąg przed i po 1. Dla 3 jest pusty ciąg przed nimi, pomiędzy nimi i po nich. Działa to do 10.

Wypróbuj online

Perl, 12 bajtów, 10 liczb, autor: ais523

Oryginalny kod:

____;say__-9

Kod produkujący 1–10:

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

Wyjaśnienie:

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 bajtów, 10 cyfr, według produkcji ETH .

Oryginalny kod:

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

Inne liczby

 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)

Wyjaśnienie

Array(2)tworzy tablicę z dwoma pustymi komórkami. .joinSposób łączy wszystkie elementy w tablicy przy użyciu separatora, który zamienia go na String. W Kodzie Oryginalnym ogranicznikiem było 3. Oznaczało to, że dwie puste komórki w macierzy są ze sobą połączone i używane 3jako ich ogranicznik. To ocenia "3", bez niczego po obu stronach, 3ponieważ tablica jest pusta. A ponieważ lengthof "3"jest 1, ta wartość jest wysyłana do konsoli.

Dla pozostałych liczb dodam jeszcze 1 cyfrę do separatora, który łączy elementy tablicy. W ten sposób zwiększa się jego długość, a tym samym alertwzrost wartości. Zauważ, że wartość liczbowa separatora nie jest ważna, tylko jej długość.

Snack Snippet!

Uwaga: Z oczywistych powodów użyłem go console.logzamiast alertw moim Snack Snippet. Ponadto dane wyjściowe z konsoli są wyświetlane we fragmencie.

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)

Oktawa, 17 bajtów, 10 cyfr, autor: 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 bajtów, 10 liczb, według 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 bajtów, 10 liczb, 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 bajtów, 10 cyfr, autor: Dada

Oryginalny kod:

say_!"___"%""_

Kod produkujący 1–10:

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

Mam wrażenie, że nie o to ci chodziło.

JavaScript, 22 bajty, 10 liczb, autor: Arnauld

Oryginalny program:

alert(0_6_4_>_0_2_0_7)

Pęknięty:

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)

Najtrudniejsze jest radzenie sobie z tym >, który ma bardzo niski priorytet. Próbowałem zmienić go na >>, ale najłatwiej jest po prostu go pochłonąć, czyniąc go bezużytecznym obliczaniem logicznego fałszu ( 42>101210sekcja), który jest liczbowo 0, i po prostu generuje liczby od 1 do 10 za pomocą operatorów o jeszcze niższym priorytecie niż >. Użyłem ^bitowej xor, ponieważ może dość łatwo generować liczby od 1 do 10 (wygodnie, 6 i 7 na oryginalnym wejściu pozwolą mi uprościć wyrażenie do 6^71).

JavaScript, 9 bajtów, Hedi

Oryginalny kod:

alert(+1)

Modyfikacje:

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

Oktawa, 55 bajtów, 10 cyfr, wada

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

Ostateczna 1mogą być przełączane do 9, a następnie zmienić +1się +2.

Python 3, 16 bajtów, 10 liczb, wg Sp3000

To było fajne.

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

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

Wykorzystuje fakt (którego do tej pory nie znałem), że literał szesnastkowy kończy się, gdy tylko 0-9a-fA-Fnapotka znak, który nie jest spotykany - 0xforjest to więc bardzo podstępny sposób pisania 15 or. Następnie należało znaleźć odpowiednią wartość zgodną z 10 modulo 15.

JavaScript, 22 bajty, 10 liczb według Arnauld

Oryginalny kod :

alert(__14_337__xc_de)

Zmodyfikowano :

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

Zgaduję, że to nie jest zamierzone rozwiązanie, ale mam nadzieję, że nie jest zbyt daleko ...

Oktawa, 32 bajty, 10 cyfr, autor: Luis Mendo

Oryginalny kod:

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

Zmodyfikowane kody:

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

Istnieje wiele sposobów wprowadzania modyfikacji (na przykład s=2i +0na początku).

Edycja: Bardziej prawdopodobna alternatywa:

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 bajtów, 10 cyfr, wg Oliver

Oryginalny kod:

 1: 3628801zï0>

Inne liczby

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

Wyjaśnienie

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

Podsumowując, pchnij 3628801, przenieś odwrotność i zaokrąglij to do najbliższej liczby całkowitej (ocenia na0 ). Następnie zwiększ stos. TADA!

Wypróbuj online! Dla wyjścia = 1 Następnie dodaj tyle >s, ile chcesz, w zależności od liczby, którą chcesz wyprowadzić.

JavaScript, 12 bajtów, 10 liczb, Hedi

Oryginalny kod:

alert(+[+1])

Od 2 do 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])

Tyle kodu można zrobić tylko tyle ...

Galaretka, 7 bajtów, 10 liczb, Jonathan Allan

Oryginalny kod:

“1‘ỌȮḊ‘

Następnie:

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

Możesz sprawdzić ostatni na TryItOnline!

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

Oktawa, 21 bajtów, 10 cyfr, autor: Stewie Griffin

To fprbyło miłe wprowadzenie w błąd =) Ale uwielbiam (1') -> 2(1') -> 2+(1')sekwencję!

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

Sześciokąt, 7 bajtów, 10 cyfr, autor: Martin Ender

Oryginalny:

1<@|!__

Kod produkujący 1–10:

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

1: Wypróbuj online!
9: Wypróbuj online!
10: Wypróbuj online!

Oto heks dla pierwszych 9 programów (gdzie # to liczba, którą chcesz wydrukować):

 # <
@ | !
 ) .

Krawędź pamięci jest ustawiona na wartość, którą chcesz wydrukować, odchyla się do SE i drukuje.

I heks dla 10:

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

Tutaj na końcu dodałem znak, który zwiększył rozmiar heksa. Najpierw krawędź pamięci jest ustawiona na 9, wskaźnik jest odchylany do SE, pamięć jest zwiększana, owija się, wskaźnik jest odchylany do SW, wartość jest drukowana i program się kończy.

Oto drugie rozwiązanie:

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

1: Wypróbuj online!
9: Wypróbuj online!
10: Wypróbuj online!

Szesnastka dla 1 - 9 (tym razem *jest to liczba do wydrukowania):

 * <
@ | !
 $ )

Działa to tak samo jak 1 - 9 powyżej.

Heks dla 10:

 9 #
@ | !
 $ )

Trafia 9następnie #przełącza wskaźnik instrukcji na prawy dolny, pamięć jest zwiększana do 10, $przeskakuje nad !, wskaźnik jest odwracany z powrotem na wschód, gdzie przeskakuje )i kończy się.

C #, 90 bajtów, 10 liczb, Scepheo

Oryginalny:

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

Pierwszy:

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

Następnie:

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();}}

Rubin, 81 bajtów, 10 liczb, histokrat

Oryginalny kod:

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

Pęknięty:

x=/$/=~%q
)

p x

To było trudne. Wiele ujawnionych postaci okazało się czerwonymi śledziami! /nie jest dzieleniem, ale częścią wyrażenia regularnego. %nie jest modem, ale częścią niecodziennej składni literału. Ten program po prostu drukuje długość ciągu ograniczonego znakami nowej linii. Kolejne programy można uzyskać, wstawiając dodatkowe znaki w drugim wierszu.

Oktawa, 25 bajtów, 10 cyfr, autor: 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 bajtów, 10 liczb, według JHM

Oryginalny kod:

봃法희
반자뭉

Zmodyfikowano:

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

Oktawa, 24 bajty, 9 liczb, według 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))%

Oktawa, 24 bajty 9 10 liczb

Uwaga: to pęknięcie jest dla pierwszej wersji stanowisko policjanta (Wysłany niewłaściwy fragment), z objawionej kod wygląda tak: ___a__repmat(__one__),__). Prawidłowa wersja jest powyżej.

Oryginalny kod:

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

Zmodyfikowane wersje, które drukują 2-10

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 bajtów, 10 liczb, ETHProductions

Oryginalny kod:

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

Programy:

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

Oktawa, 21 bajtów, 9 liczb, według flawr

Naprawdę podobał mi się ten ... Sprytny :)

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 bajtów, 9 liczb, według DLosc

Oryginalny kod:

Write 49+_

Aby utworzyć liczby od 1 do 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 to kod ascii z 1. _domyślnie zawiera 0 (więc 49+_ = 1). I Writedrukuje znak odpowiadający kodowi ascii jego argumentu. Całkiem prosto.

Python 2, 49 bajtów, 10 liczb, AlexRacer

Może (tylko może) zamierzone rozwiązanie, ale jeśli tak, to można było oderwać wiele bajtów:

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 bajtów, 10 cyfr, James Holderness

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

Wypróbuj online!

Prawdopodobnie nie jest to zamierzone rozwiązanie.

To, co zrobiłem, to pozbycie się nieznośnych 25 ( 5:*) poprzez pomnożenie przez 0. Jeśli następnie umieścimy 9na początku, wówczas wyjścia będą 9 - Ntam, gdzie trzeba wygenerować Nz jednego polecenia. Jedynym problemem jest -1uzyskanie 10, ale próba odczytania liczby całkowitej, jeśli nie ma danych wejściowych, wypycha a -1.

05AB1E, 5 bajtów, 10 cyfr według Adnana .

Oryginalny kod:

…[==1

1-10:

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

Wyjaśnienie:

…[==   3 char string
    1  Push number

05AB1E, 6 bajtów, 10 cyfr, Adnan

Oryginalny kod:

¼ [==q

Dodawaj ¼kolejne, aby uzyskać wynik do 10:

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

Wypróbuj online

Jak to działa:

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