Это нить грабителей. Нить полицейских идет сюда .

Напишите код, который имеет такое же количество байтов, что и пост полицейского, и где обнаруженные символы идентичны. Код должен производить 1в своем начальном состоянии и производить числа, 2, 3 ..когда делаются отдельные изменения.

Победителем станет грабитель, взломавший большинство постов.

Пример поста:

MyLang, 9 байт, 8 цифр (включая ссылку на ответ), имя пользователя полицейского.

Оригинальный код:

abc1efghi

Код, который выдает 1 - 8:

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

Пояснения приветствуются. Точный формат сообщения грабителя не является обязательным.

Сетчатка, 2 байта, 10 номеров, автор Martin Ender .

Оригинальный код:

1

Это заменяет пустой ввод числом 1.

Код, который выдает 1 - 10 (показаны \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

Для 2 и далее мы подсчитываем количество пустых строк на предыдущем этапе. Для 2 есть пустая строка до и после 1. Для 3 есть пустая строка до тех, между ними и после них. Это работает вплоть до 10.

Попробуйте онлайн

Perl, 12 байт, 10 цифр, по ais523

Оригинальный код:

____;say__-9

Код, который выдает 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

Объяснение:

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 байтов, 10 чисел, ETHproductions .

Оригинальный код:

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

Другие номера

 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)

объяснение

Array(2)создает массив с двумя пустыми ячейками. .joinМетод объединяет все элементы массива , используя разделитель, который преобразует его в строку. В оригинальном коде разделитель был 3. Это означало, что две пустые ячейки в массиве соединены вместе и используются в 3качестве их разделителя. Это оценивает "3", без чего-либо по обе стороны от, 3потому что Массив пуст. А так как lengthв "3"это 1, это значение выводится на консоль.

Для других чисел я добавляю еще одну цифру к разделителю, который соединяет элементы массива. Следовательно, это увеличивает его длину, тем самым alertувеличивая значения. Обратите внимание, что числовое значение разделителя не важно, только его длина.

Закуска

Примечание: я использовал console.logвместо alertсвоего Snacket по понятным причинам. Кроме того, вывод из консоли отображается в фрагменте.

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)

Октава, 17 байтов, 10 цифр, Стьюи Гриффин

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 байтов, 10 чисел, 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 байтов, 10 чисел, 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 байтов, 10 цифр, Дада

Оригинальный код:

say_!"___"%""_

Код, который выдает 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

У меня такое чувство, что это не то, ради чего ты собирался.

JavaScript, 22 байта, 10 чисел, Арнаулд

Оригинальная программа:

alert(0_6_4_>_0_2_0_7)

Трещины:

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)

Сложнее всего разобраться с тем >, что имеет очень низкий приоритет. Я попытался изменить его на an >>, но проще всего просто поглотить его, заставив бесполезно вычислять логическое значение false ( 42>101210раздел), который численно равен 0, и просто генерировать числа от 1 до 10 с операторами с еще более низким приоритетом, чем >. Я использовал ^побитовый xor, потому что он может довольно легко генерировать числа от 1 до 10 (удобно, 6 и 7 в исходном вводе позволяют мне упростить выражение до 6^71).

JavaScript, 9 байт, хеди

Оригинальный код:

alert(+1)

Модификации:

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

Октава, 55 байт, 10 цифр, ошибка

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

Окончательный 1может быть циклически до 9, а затем изменить +1с +2.

Python 3, 16 байтов, 10 номеров, по Sp3000

Это было весело

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

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

Использует тот факт (который я не знал до сих пор), что шестнадцатеричный литерал заканчивается, как только встречается символ, с которым не 0-9a-fA-Fсталкиваются - таким образом 0xfor, это очень хитрый способ написания 15 or. После этого нужно было найти правильное значение, равное 10 по модулю 15.

JavaScript, 22 байта, 10 чисел по Арнаулду

Оригинальный код :

alert(__14_337__xc_de)

Модифицировано :

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

Я предполагаю, что это не предполагаемое решение, но я надеюсь, что это не слишком далеко ...

Октава, 32 байта, 10 чисел, по Луис Мендо

Оригинальный код:

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

Модифицированные коды:

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

Есть много способов внести изменения здесь (например, s=2и+0 в начале).

Изменить: более вероятная альтернатива:

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 байтов, 10 чисел, Оливер

Оригинальный код:

 1: 3628801zï0>

Другие номера

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

объяснение

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

Подводя итог, нажмите 3628801 , возьмите его обратное и округлите до ближайшего целого числа (оценивается как 0). Затем увеличьте стек. TADA!

Попробуйте онлайн! Для output = 1 Затем добавьте столько >s, сколько хотите, в зависимости от того, какое число вы хотите вывести.

JavaScript, 12 байт, 10 цифр, хеди

Оригинальный код:

alert(+[+1])

Со 2 по 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])

С таким большим количеством кода вы можете сделать так много ...

Желе, 7 байтов, 10 номеров, Джонатан Аллан

Оригинальный код:

“1‘ỌȮḊ‘

Затем:

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

Вы можете проверить последний на TryItOnline!

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

Октава, 21 байт, 10 цифр, Стьюи Гриффин

Это fprбыло хорошее заблуждение =) Но я люблю (1') -> 2(1') -> 2+(1')последовательность!

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 байтов, 10 чисел, автор Martin Ender

Оригинал:

1<@|!__

Код, который выдает 1 - 10:

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

1: попробуйте онлайн!
9: попробуйте это онлайн!
10: попробуйте онлайн!

Вот гекс для первых 9 программ (где # - это число, которое вы хотите напечатать):

 # <
@ | !
 ) .

Край памяти просто устанавливается на значение, которое вы хотите напечатать, отклоняется на SE и печатается.

И гекс на 10:

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

Здесь я добавил персонажа в конец, который увеличил размер гексагона. Во-первых, край памяти устанавливается на 9, указатель отклоняется на SE, память увеличивается, оборачивается, указатель отклоняется на SW, значение печатается, и программа завершается.

Вот второе решение:

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

1: попробуйте онлайн!
9: попробуйте это онлайн!
10: попробуйте онлайн!

Гекс для 1 - 9 (на этот раз *номер для печати):

 * <
@ | !
 $ )

Это работает так же, как 1 - 9 выше.

Гекс на 10:

 9 #
@ | !
 $ )

Эти попадания 9затем #переключают указатель команд на нижний правый, память увеличивается до 10, $перепрыгивает через !, указатель возвращается на восток, где он перепрыгивает )и заканчивается.

C #, 90 байтов, 10 цифр, Scepheo

Оригинал:

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

Первый:

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

Затем:

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

Рубин, 81 байт, 10 цифр, гистократ

Оригинальный код:

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

Трещины:

x=/$/=~%q
)

p x

Это было сложно. Многие обнаруженные персонажи оказались красными сельдями! /не деление, а часть литерала регулярных выражений. %это не мод, а часть необычного строкового литерального синтаксиса. Эта программа просто печатает длину строки, разделенную символами новой строки. Последующие программы можно получить, вставив дополнительные символы во вторую строку.

Октава, 25 байтов, 10 чисел, Луис Мендо

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 байтов, 10 цифр, автор JHM

Оригинальный код:

봃法희
반자뭉

Изменен:

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

Октава, 24 байта, 9 цифр, от 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))%

Октава, 24 байта 9 10 цифр

Примечание. Этот треск относится к первой версии поста полицейского (размещен неправильный фрагмент), в котором раскрытый код выглядит следующим образом: ___a__repmat(__one__),__) . Правильная версия выше.

Оригинальный код:

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

Модифицированные версии, которые печатают 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 байтов, 10 чисел, ETHProductions

Оригинальный код:

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

Программы:

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

Октава, 21 байт, 9 цифр, от flawr

Мне очень понравилось это ... Умный :)

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)

Точность !! , 10 байтов, 9 чисел, DLosc

Оригинальный код:

Write 49+_

Чтобы произвести числа от 1 до 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 является кодом ASCII 1. _содержит 0 по умолчанию (так 49+_ = 1). И Writeпечатает символ, соответствующий коду ascii своего аргумента. Довольно прямо вперед.

Python 2, 49 байтов, 10 номеров, AlexRacer

Может быть (просто может быть) предполагаемое решение, но если это так, множество байтов могло быть удалено:

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 байтов, 10 номеров, Джеймс Холдернесс

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

Попробуйте онлайн!

Вероятно, не предполагаемое решение.

Я избавился от надоедливых 25 ( 5:*), умножив их на 0. Если затем мы поместим a 9в начало, то выходные данные будут 9 - Nтам, где нужно генерировать Nодну команду. Единственная проблема состоит -1в том 10, чтобы получить , но попытка прочитать целое число, если нет ввода, удобно нажимает a -1.

05AB1E, 5 байтов, 10 номеров, от Adnan .

Оригинальный код:

…[==1

1-10:

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

Объяснение:

…[==   3 char string
    1  Push number

05AB1E, 6 байтов, 10 чисел, Аднан

Оригинальный код:

¼ [==q

Продолжайте добавлять ¼, чтобы вывести до 10:

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

Попробуйте онлайн

Как это работает:

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