Нитку копів можна знайти тут: The 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>

Цей конкурс зараз закритий.

Загальний переможець: кеннітм

Більшість матеріалів: 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, як T. ./Tнаводить повний перелік 42-х розділів числа 10, що здається, що це може стати в нагоді.

Тепер друк проводиться без роздільника, тому це натякає на використання p. Можливо, ми перебираємо кожен розділ, робимо щось з ним, а потім друкуємо p? Це дає нам такий шаблон:

V./Tp??N

де V- це цикл for, який перетинає ітерабельний файл, зберігаючи кожен елемент у змінній N.

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

u*GHd1

де dперелік, про який йдеться. Однак це занадто довго.

На жаль, саме тут мені довелося витягнути грубого форсера. Я не відставав від Pyth деякий час, тому не знав багатьох нових функцій. Залишилися лише два персонажі, які виглядали цілком виконаними.

Потім жорстокий форцер повернувся:

V./Tp*FN

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

Mathematica, alphalpha, ≤ 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

і використовуйте це для масштабування всіх елементів вниз, щоб min елемент був 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.

Равлики, ферум, ≤2 байти

z

Це насправді 2 байти; персонаж, zза яким слідує новий рядок \n.

Я поняття не маю, як це працює або що він робить, але після тестування всіх можливих входів, окрім ~+і ~,, це була єдина 2-байтна програма, яка видавалася 8як вихід.

І для отримання цього результату знадобилися віки . Недарма його називають "Равлики" :-D

^{Примітка до самостійного: наступного разу, коли ви невідомо перевірите невідоме програмне забезпечення, зробіть це всередині VM.}

Іржа, Ліам Норонха, ≤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". З цього випливає чітке вказівка ​​на те, що список складається з двох останніх символів усіх клавіш styleоб'єкта, що тест, показаний вище, дійсно є правильним.

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

Дуже багато користувачів схвилювались від цієї відповіді у чаті, тому я мушу позбавити їх від їхніх бід. Я не знаю Луа і не зміг її перевірити, але я був би дуже здивований, якщо це не працює.

4^~9

Це було б досить очевидно, але, мабуть, ніхто цього не отримав, оскільки побітні оператори додані лише у версії 5.3; ideone.com має лише версію 5.2.

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

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

Найбільший натяк - це обіцянка, що вона не працюватиме в Python 3. Що змінилося в Python 3 ? Найбільшим підозрюваним є те, що оператор поділу повертає a 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]

Python, spacemanjosh, ≤ 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 байт, але знайти повторювану послідовність було цікавою проблемою.

Чт, піпер, <= 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, Reto Koradi, ≤ 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елементи довгі. Тоді я здогадався, що його треба перетворити на рядок і надрукувати його довжину. Однак єдиний спосіб зробити це я міг придумати деякий час: ``, репр. Тоді я подумав j, що ідеально підходить.

C, tucuxi, ≤64

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

Вихідні дані 0 і 1, але C не може друкувати двійкові безпосередньо, тому дуже ймовірно, що це булі результати.

Є більше, ніж 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.

Dyalog APL, Dennis, ≤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:])

Ruby, Doorknob, ≤64

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

Matlab / Octave, Wauzl, ≤16

"234"'*"567"

Використовуючи ту саму ідею, що і відповідь Тома Карпентера

(Якщо нічого не вийшло, спробуйте це :)

[50;51;52]*'567'