Нить полицейских можно найти здесь: Mystery String Printer (Cops)

Ваш вызов

• Выберите представление из цепочки полицейских и распечатайте строку из ответа в этой ветке.
• Выбор, который вы выбираете, не должен быть безопасным (он должен быть не позднее 7 дней).

• Ваша программа, функция или сценарий REPL должны следовать тем же правилам, что и поток полицейских. Напомним:

  • Ваша программа должна быть ≤128 символов (если представление полицейского находится в меньшем диапазоне длин программы, ваша программа также должна быть в этом диапазоне длин. Например, если программа полицейского имеет ≤32 байта, ваша программа должна быть ≤32 байта ).
  • Программа должна выдавать один и тот же вывод при каждом запуске.
  • Нет криптографических функций.
  • Программа не должна принимать данные.
  • Нет стандартных лазеек.
• Все новые материалы должны использовать один и тот же язык. Представления до того, как это правило было сделано, хорошо, даже если они этого не делают.

счет

Скоринг работает аналогично для грабителей, но немного отличается:

• Взлом любой программы ≤8 байт дает 1 балл.
• Взлом программы ≤16 байт дает 2 балла. ≤32 байта дает 4 балла и так далее.
• Каждая дополнительная подача, независимо от длины, приносит +5 баллов
• Представление каждого полицейского может быть взломано только один раз - только первый человек, взломавший каждое представление, получает очки.

Материалы

Каждый ответ должен включать

• Ссылка на представление полицейского.
• Ваша программа и язык программирования.
• Также имейте длину программы полицейского (как степень 2) в качестве последнего числа в вашем заголовке.

Кроме того, пожалуйста, прокомментируйте представление полицейского со ссылкой на ваш ответ.

Вот фрагмент стека для создания списков лидеров. Пожалуйста, оставьте комментарий, если есть проблема с фрагментом. Если вы хотели бы видеть все представления открытых полицейских, посмотрите фрагмент в вызове полицейских.

/* Configuration */

var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";

/* App */

var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;

function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {

  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });

}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {

        answers_hash[c.post_id].comments.push(c);

      });

      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;


function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {

  var valid = [];
  var open = [];

  answers.forEach(function(a) {

    var body = a.body;
    var cracked = false;

    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);

    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;

      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints

      });
    }
  });

  var pointTotals = [];
  valid.forEach(function(a) {

    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });

    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }

  });

  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });

  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });

  pointTotals.forEach(function(a) {


    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);


  });

}

body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>

        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>

<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>

Этот конкурс сейчас закрыт.

Общий победитель: kennytm

Большинство представлений: Sp3000

(Обратите внимание, что количество заявок не переводится точно в баллы, так как длина взломанной программы учитывается при подсчете очков).

Пиф, Деннис, ≤ 8

V./Tp*FN

Чёрт, это было весело - самая сложная часть - выяснить, как сделать это достаточно коротко в Pyth.

Анализ

В 1234начале намекает, что мы, вероятно, имеем дело со списком чисел, напечатанным без разделителя. Давайте попробуем разделить числа так, чтобы это имело смысл:

1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10

Есть несколько подсказок, что мы на правильном пути:

• Все числа имеют простые множители менее 10
• Многие цифры довольно близки к их индексу в списке

Однако есть несколько особенностей. Число в индексе 23 равно 24, и это единственный случай, когда число в индексе больше, чем сам индекс. Тем не менее, большая подсказка в том, что некоторые числа явно меньше, чем у их соседей, особенно 7 в индексе 15, 8 в индексе 22 и 9 в индексе 30.

Отмечая, что это формирует шаблон 7-8-9, мы также можем видеть, что последнее число - 10 по индексу 42. Учитывая недавний вопрос @Dennis об абелевых группах , быстрая проверка OEIS показывает, что 15, 22, 30, 42это подпоследовательность раздела номера . Pyth имеет встроенную функцию для разделов, которая дает нам два из восьми символов:./

Но обратите внимание, что последнее число - 10, что является подозрительным, потому что 10 является преинициализированной переменной в Pyth, as T. ./Tдает полный список из 42 разделов из числа 10, что может пригодиться.

Теперь печать выполняется без разделителя, поэтому намекает на использование p. Возможно, мы перебираем каждый раздел, что-то с ним делаем, а затем печатаем p? Это дает нам следующий шаблон:

V./Tp??N

где Vцикл for, который циклически повторяется, сохраняя каждый элемент в переменной N.

Беглый взгляд на второй последний раздел (5, 5)должен показать, что мы хотим взять продукт. Наивный способ уменьшить список путем умножения

u*GHd1

где dсписок в вопросе. Однако это слишком долго.

К сожалению, именно здесь мне пришлось вытащить грубую силу. Я не поспевал за Pyth какое-то время, поэтому я не знал многих новых функций. Осталось только два персонажа, что выглядело вполне выполнимо.

Брутфорсер затем вернулся:

V./Tp*FN

где *Fскладывается *(умножение). Неудивительно, что я не нашел его в своем поиске - я искал ключевое слово «уменьшить», а не «свернуть»!

Mathematica, альфальфа, ≤ 32

GroupOrder[MonsterGroupM[]]

Ненавижу это говорить, но я сразу узнала номер.

> <>, VTCAKAVSMoACE, ≤ 64

'9?':?!;1-$:'@'+o'3'*'='%$30.

По иронии судьбы, он не только намного ниже предела диапазона, но и переносим и работает с онлайн-переводчиком .

Анализ

Давайте начнем с целевой строки:

yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[

> <> помещает символы в стек с помощью 'или "в строковом режиме, но с 63 символами для печати и только 64 байтами для работы, наличие заглавных букв (недопустимые инструкции в> <> для стандартного трюка с циклическим циклом) делает прямую печать невозможно. Следовательно, мы должны что-то делать с кодами.

Преобразование в кодовые точки дает (я использую Python здесь):

>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]

Обратите внимание, что последние три числа совпадают с первыми тремя. Это намекает на возможный цикл по модулю.

Давайте посмотрим, сколько у нас разных элементов:

>>> len(set(L))
60

У нас есть 63 элемента L, первые три из которых совпадают с последними тремя. Это означает, что, кроме этого столкновения, все остальные элементы являются уникальными. Теперь это намекает на что-то вроде взятия степеней по модулю простого числа. Действительно, 60 + 1 = 61простое, что является хорошим знаком.

Давайте попробуем найти самый маленький элемент

>>> min(L)
65

и используйте это, чтобы уменьшить все элементы так, чтобы минимальный элемент был 1:

>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]

Обратите внимание , как элемент после 1есть 51. Если происходит что-то вроде умножения / умножения, это хорошая догадка для нашего множителя.

Давайте попробуем:

>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True

Бинго! Теперь мы можем вернуться, дав следующий код:

x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61

который затем был переведен на> <>

Pyth, Maltysen, ≤4

C.ZG

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

Анализ

C(преобразовать строку в основание 256 int) - это самый простой способ создать большое число в Pyth, так что это, вероятно, первый символ. Если мы конвертируем из базы 256, мы получим:

xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 

Хм ... не очень освещает.

Теперь Gэто алфавитная строка "abc...z", которая выглядит как источник длинной строки для ввода C. Просматривая документы, я нахожу:

.Z    Compresses or decompresses a string.

Если мы имеем дело со сжатием здесь, было бы не удивительно получить все виды расширенных символов ASCII. Попытка C.ZGзатем дала ответ.

Фурье, бета-распад, ≤ 32

2~x1~y20(xoy~z*x~yz~xq^~q)

Или, в качестве альтернативы, в CJam:

X0I{_2$+}*]2\f#

Анализ

В начале мы можем видеть много сил 2:

2
1
2
2
4
8
32
256
8192
2097152
...

Если мы возьмем лог-базу 2 этих чисел, мы получим:

1 0 1 1 2 3 5 8 13 21 ...

который является серией Фибоначчи, начиная с 1, 0.

Улитки, feersum, ≤2 байта

z

На самом деле это 2 байта; символ, zза которым следует символ новой строки \n.

Я понятия не имею, как это работает или что делает, но после тестирования всех возможных входных данных, кроме ~+и ~,, это была единственная 2-байтовая программа, которая 8выводилась как выходная.

И он взял возрасты , чтобы получить этот результат. Не зря это называется "Улитки" :-D

^{Примечание для себя: в следующий раз, когда вы запустите тестирование неизвестного программного обеспечения, сделайте это внутри виртуальной машины.}

Руст, Лиам Норонья, ≤128 байт

fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}

Простая дословная печать строки составляет 120 байт ...

Макароны 0.0.2, дверная ручка, ≤64

set x "................................."print x print x print x

Python 2, четкий вопрос с примерами, <= 64

Одно из возможных решений:

print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])

( 9**2139, 27**1426А 729**713также дают тот же результат)

CoffeeScript, user2428118, ≤64

alert 0+(btoa k.substr -2 for k of document.body.style).join ''

(работает только на Chrome 46.0.2490.71, как описано коп.)

Вывод - это, очевидно, конкатенация коротких строк в кодировке base64 из-за всех "=". После их декодирования мы находим список 2-символьных строк, таких как

['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …

что, кажется, не имеет смысла. Но я нахожу в нем несколько странных вещей, как nXи tY. После фильтрации мы получаем

>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']

Эти X и Y, кажется, указывают на исходный исходный код, используемый свойства позиции, как offsetX/Y. Особенно интересным является nZпредмет. Чтобы проверить мое предположение, я искал все свойства, которые заканчиваются на «Z»:

// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window

который показывает тонны CSSStyleDeclaration, "webkitTransformOriginZ". Отсюда мы имеем четкое указание на то, что список состоит из последних 2 символов всех ключей styleобъекта, что, как показывает приведенный выше тест, действительно является правильным.

Луа <= 4, Егор Скриптунов

Многие пользователи были взволнованы этим ответом в чате, поэтому я должен избавить их от страданий. Я не знаю Луа и не смог проверить это, но я был бы очень удивлен, если бы это не сработало.

4^~9

Это было бы довольно очевидно, но, вероятно, никто не получил его, потому что побитовые операторы были добавлены только в версии 5.3; ideone.com имеет только версию 5.2.

Питон 2, гистократ, ≤16

[[[51002**3/6]]] 

Самым большим намеком является обещание, что оно не будет работать в Python 3. Что изменилось в Python 3 ? Самым большим подозрением является то, что оператор деления возвращает floatв Python 3.

Поэтому я предполагаю, что решение имеет вид ⌊α ^β / n⌋ = c = 22111101102001, так как возведение в степень - единственный короткий способ создания огромных чисел.

Если {α, β, n} действительно образует решение, то (cn) ^{1 / β} ≈ α должно быть очень близко к целому числу. Поэтому я использую следующее, чтобы попытаться перебором {α, β} для каждого n:

(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]

(* Output: {{0.00262542213622, 7}, ...}

   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.

*)

Фактический результат быстро получается, когда n = 6.

MATLAB, StewieGriffin, ≤ 16

[36;87]*' |'*5

Печать:

ans =
        5760       22320
       13920       53940

Матлаб, Луис Мендо, ≤16

Я нашел это, ура!

fix(peaks(9).^2)

Я не знал, что Октава тоже может это сделать.

Mathematica, LegionMammal978, ≤64

Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]

Питон, космонавт, ≤ 64

n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)

Славный обратный символьный калькулятор. Не очень хорошо, но эй это подходит.

Редактировать: я играл в гольф.

print([10/(100-n*n)**.5for n in range(10)])

JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 байт

var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;

Я сомневаюсь, что это совершенно верно, поскольку мне не нужно было где-то около 128 байтов, но найти повторяющуюся последовательность было забавным испытанием.

Чт, ppperry, <= 64

0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa

По существу, декомпозирует 2016 год на основные факторы. 62 символа, так что я думаю, это похоже на то, что вы собирались.

Python, DLosc, ≤32

(Это решение использует Python 2)

a=97
while a<4e31:a^=a*2;print a

> <>, Sp3000, <= 8

'l(?; o>

Указатель инструкций оборачивается и выполняются следующие шаги:

• 'l(?; o>'помещает значения ASCII l(?; o>в стек
• l толкает размер стека в стеке
• (сравните два верхних элемента стека: size of stackиord('>')
• ?; останавливает программу, если размер стека был больше
• oвывести верхний элемент стека как символ (это будет всегда o)
• > задает направление IP, здесь он не работает
• мы возвращаемся к первому шагу

Выход есть oooooooooooo.

Мы можем получить много разных выходных данных, изменив [space]что-то, что помещает или выталкивает в стек, и вместо него использует другой допустимый символ >, который также может выдвигать или выдвигать.

JavaScript, ev3commander, ≤ 32

console.log(0.1411200080598672)

ОК, это было легко.

CJam, Рето Коради, ≤ 4

HJK#

Толкает 17 , затем 19 ²⁰ = 37589973457545958193355601 .

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

Есть только так много вещей, которые вы можете сделать в четырех байтах. Это целое число должно было каким-то образом включать степени или факториалы, а у факториала были бы конечные нули.

Пиф <= 4, Деннис

ljyG

Это длина соединения на новых строках всех подмножеств алфавита.

Тестовый забег:

$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095

Я выяснил, что число 2^27 * 7 - 1является сильным намеком, на котором оно основано yG, которое состоит из 2^26элементов long. Я тогда предположил, что это должно было быть преобразовано в строку, и ее длина напечатана. Однако единственный способ сделать это, о котором я мог думать некоторое время, был ``, repr. Тогда я подумал j, что подходит идеально.

C, Tucuxi, ≤64

main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}

Все выходные значения равны 0 и 1, но C не может печатать двоичные данные напрямую, поэтому весьма вероятно, что это булевы результаты.

Здесь больше 1, чем 0, поэтому я записал позиции 0s ( 3, 9, 13, 19, …), что оказывается OEIS A075318 . Это не полезно, хотя, нет простой формулы, чтобы определить, где число находится в этой последовательности.

Но мы отмечаем, что есть все нечетные числа, поэтому, возможно, (x-1)/2 = {1, 4, 6, 9, 12, …}есть более полезная информация. И это A003622 .

A003622 можно определить как «позиции 1 в A003849 », и это именно то, что нам нужно взломать здесь. А A003849 определяется как « A003714 mod 2», где A003714 - это просто целые числа x & (2*x) == 0. Таким образом, мы получили решение.

OEIS rox.

Дьялог АПЛ, Деннис, №4

*⍨⍟8

Вычисляет ln (8) ^ ln (8). StackExchange перестанет конвертировать мои ответы? Я напишу кучу вещей здесь, чтобы они не превратились в комментарий.

Застрял, @quartata, ≤8

Следующая программа Pyth :

^33 9

производит желаемый результат

46411484401953

Метод взлома: искал в Google номер.

Pyth, xnor, ≤ 4

C`CG

CG(преобразовать строку алфавита "abc...z"из базы 256) - это типичный способ Pyth для генерации действительно большого числа. После этого он просто преобразуется в строку и снова конвертируется из базы.

Python 3, Mego, ≤128

(Использование Python 3.5.0, не тестировалось в предыдущих версиях. 105 98 байт.)

import sys
a=sys.stdout
sys.stdout=None
from this import*
a.write(s.translate(s.maketrans(d))[4:])

Рубин, дверная ручка, ≤64

'@@'=~/(.)(.)/
p$~
test 0 rescue p"#$!@@".gsub //,$!.inspect+$/

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Используя ту же идею, что и ответ Тома Карпентера

(Если это не сработало, попробуйте это :)

[50;51;52]*'567'