Это сопутствующий поток к основной задаче Unscramble the Source Code . Если вы думаете, что вам удалось расшифровать один из ответов полицейского, вы должны опубликовать свое решение в качестве ответа в этой теме.

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

Грабитель с наибольшим количеством очков (успешных трещин) побеждает.

Leaderboard

Слишком много решает

• Мартин Бюттнер: (Python 3, 16, matsjoyce) , (CJam, 15, Ypnypn) , (Mathematica, 29, Fox Wilson) , (JavaScript, 15, Caridorc) , (CJam, 52, user23013) , (Pyth, 11, isaacg) , (PHP, 22, kenorb) , (PHP, 13, kenorb) , (Ruby, 17, Doorknob) , (PHP, 49, bwoebi) , (Mathematica, 35, Tally) , (GolfScript, 13, Питер Тейлор ) , (JavaScript, 25, Cris) , (JavaScript, 29, Cris) , (JavaScript, 26, Cris) , (Bash, 33, Debasis) , (JavaScript, 10, Cris), (Луа, 28, ChipperNickel) , (Mathematica, 18, Arcinde) , (JavaScript, 30, Qwertiy) , (CJam, 13, user23013) , (JavaScript, 41, Исмаэль Miguel) , (Рубин, 38, Дверная ручка) , (Marbelous, 36, es1024) , (PHP, 33, Исмаэль Мигель) , (JavaScript, 29, Джо) , (JavaScript, 28, Шон Хольцворт) , (Ruby, 35, гистократ) , (CJam, 19, Ypnypn) , (Ruby, 17, Stephen Touset) , (JavaScript, 36, MegaTom) , (JavaScript, 24, fogcityben) , (Python 3, 21, Reticality) ,(JavaScript, 10, Джейми Баркер) , (JavaScript, 15, Джейми Баркер)

20 решает

• feersum: (Python 3, 44, Sp3000) , (C, 70, es1024) , (MATLAB, 41, COTO) , (Brainfuck, 118, Sp3000) , (C, 30, Ethiraric) , (C, 28, Mig) , (Python 3, 46, hosch250) , (Java, 70, Rodolvertice) , (C, 29, imallett) , (Java, 226, nhahtdh) , (Little Man Computer, 63, The Wolf) , (Python 2, 89 , Beta Decay) , (Python 2, 41, мутная рыба) , (C, 63, es1024) , (C ++, 192, Arcinde) , (Java, 108, durron597) , (C #, 604, eshansingh1) ,(C, 44, Art) , (Java, 134, Olavi Mustanoja) , (Bash, 47, Vi.)

15 решает

• user23013: (CJam, 18, Ypnypn) , (JavaScript, 26, hsl) , (CJam, 12, COTO) , (PHP, 23, bwoebi) , (PHP, 54, Стив Роббинс) , (CJam, 32, Деннис) , (CJam, 19, Мартин Büttner) , (Бака, 23, Волк) , (Рубин, 33, Дверная ручка) , (CJam, 34, Dennis) , (JavaScript, 82, Исмаэль Miguel) , (РНР, 80, Исмаэль Мигель) , (QBasic, 43, DLosc) , (QBasic, 42, DLosc) , (ECMAScript, 90, Cris)

10 решает

• брезгливое ossifrage: (Python, 44, Caridorc) , (PHP, 52, PleaseStand) , (Befunge-93, 17, user23013) , (BBC BASIC, 187, Beta Decay) , (C, 43, Allbeert) , (Ruby, 58, Rodolvertice) , (JavaScript, 32, hsl) , (PHP, 33, kenorb) , (Python 2, 16, imallett) , (PHP, 53, PleaseStand)
• Sp3000: (Python, 154, Fox Wilson) , (Python, 48, kgull) , (Python, 68, рожки) , (Python 2, 38, FryAmTheEggman) , (Python 2, 57, FryAmTheEggman) , (Python, 74, xnor) , (JavaScript, 66, Cris) , (JavaScript, 70, Cris) , (Python 2, 37, мутная рыба) , (Python, 55, FireFly)

7 решает

• grc: (Python 2, 61, FryAmTheEggman) , (Perl 5, 47, chilemagic) , (Python, 69, Sp3000) , (Perl, 39, GentlePurpleRain) , (Perl, 36, брезгливое ossifrage) , (Python 3, 110 , Sp3000) , (C, 53, FireFly)

5 решает

• hsl: (CoffeeScript, 25, Мартин Бюттнер) , (Golfscript, 20, Джозия Уинслоу) , (Lua, 18, user3155415) , (Python, 54, kgull) , (Арифметика, 31, Cris)
• PleaseStand: (PHP, 14, Tryth) , (C ++, 56, hosch250) , (PHP, 21, kenorb) , (QBasic, 37, DLosc) , (JavaScript, 46, FireFly)

4 решает

• bwoebi: (PHP, 52, кенорб) , (PHP, 30, трит) , (PHP, 27, кенорб) , (PHP, 44, кенорб)
• FireFly: (JavaScript, 94, Шон Хольцворт) , (Python, 34, Sp3000) , (Brainfuck, 39, Mig) , (JavaScript, 69, Шон Хольцворт)

3 решает

• Оптимизатор: (JavaScript, 61, jsh) , (JavaScript, 47, palerdot) , (JavaScript, 42, Шон Холзворт)
• es1024: (PHP, 46, Ismael Miguel) , (оболочка Python, 15, xnor) , (оболочка Python, 21, xnor)
• DLosc: (Python, 41, Sp3000) , (Ruby, 37, Rodolvertice) , (CJam, 14, User23013)

2 решает

• xnor: (Python 3, 37, matsjoyce) , (Python 2, 29, Деннис)
• Даниэль Вагнер: (Хаскелл, размер 34, Петр Пудлак) , (Хаскелл, 42 года, гордый Хаскеллер)
• nneonneo: (Python, 41, Sp3000) , (C, 43, FryAmTheEggman)
• Art: (C, 51, es1024) , (C, 48, es1024)
• n̴̖̋h̷͉̃a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳: (Java 6+, 101, Rodolvertice) , (Java, 97, Олави Мустаноя)

1 решение

• Ypnypn: (Python 2, 50, Geobits)
• matsjoyce: (Python 3, 12, xnor)
• user1354557: (Python, 56, Фокс Уилсон)
• Деннис: (CJam, 20 лет, Мартин Бюттнер)
• isaacg: ( Pyth , 71, FryAmTheEggman)
• ConMan: (SAS, 17, user3490)
• Arcinde: (JavaScript, 285, Beta Decay)
• Шон Хотазворт: (Javascript, 82, TrungDQ)
• Нооодл: (Рубин, 49, Дверная ручка)
• Бханте Нандия: (Python 3, 37, Sp3000)
• Geobits: (APL, 17, user23013)
• гистократ: (Ruby, 23, MegaTom)
• ProgramFOX: (Python, 13, Reticality)

CJam, размер 20, автор Martin Büttner

Hi "petStorm!", mame

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

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

Hi                      "           int(17)                     ";
   "petStorm!",         "                    len('petStorm!')   ";
                ma      "     atan2(       ,                 )  ";
                  me    " exp(                                ) ";
                        " exp(atan2(int(17), len('petStorm!'))) ";

Взломать код

Желаемый результат 2.956177636986737- Double или Double, за которым следует Long.

Используя только символы "Stop, Hammer time!", есть четыре встроенных оператора, которые возвращают нецелые числа типа Double:

• mS, который asin
• ma, который atan2
• me, который exp
• mt, который tan

Все они содержат m, поэтому мы можем использовать не более трех из них. Есть только один Sи один a.

Все эти операторы нуждаются в вводе данных, и maтолько один использует два входа. У нас есть только три способа подтолкнуть Лонга:

• "...",, что увеличивает длину строки (строго меньше 18).
• H, который толкает 17.
• ...!, который выдвигает логическое НЕ ....

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

Вывод не начинается и не заканчивается на 17или 0. Так как 15 десятичных цифр - это обычное количество цифр для Double, казалось, что вывод был простым Double.

Предполагая это, код должен попасть в одну из следующих категорий:

• <Long> <mS|me|mt>{1,3}
• <Long> <mS|me|mt>{x} <Long> <mS|me|mt>{y} ma <mS|me|mt>{z},
• Любой из вышеперечисленных, с некоторым приведением к Long ( i) или округлению ( mo) к Double.

Во втором случае x + y + zэто либо 1, либо 2, а один из длинных - 0 или 17.

Остальное было в основном грубой силой. После нескольких попыток

18 , {H \ ma me 2.956177636986737 =} =

вернулся 9, что означает, что

H 9 ma me

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

Осталось только удалить из строки все символы, кроме 9. Пробелы - это noops и inoop для Longs, поэтому "petStorm!"это один из возможных вариантов.

Python 3, размер 12, от xnor

()and bciprt

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

Python, размер 74, xnor

any(print(set is
set)for i in oct(chr is
map))and aeeeeeggiilnnpprrrrrstvw

Ну, это было весело. Спасибо FryAmTheEggman, hosch250 и isaacg за предложения / помощь.

Python 2, размер 50, Geobits

print 2**2**2*2**2-22-2**2**2**2/2**2**2**2**2/2/2

Выходы 42.

GolfScript, размер 13, Питер Тейлор

,22,{.4&?+.}/

Проверьте это здесь.

Еще один, который я только взломал с большой помощью от Sp3000. Благодарность!

Так вот как мы туда попали. Sp3000 заметил кучу последовательных чисел в выводе:

1,2,3,4,[2608852181],4582,4583,4584,4585,4586,[253225388392299],
142924,142925,142926,142927,142928,[302928],497409,497409

Исходя из этого, мы сделали предположение, что это возрастающая последовательность, которая допускает только одно возможное разбиение оставшихся чисел:

1,2,3,4,260,885,2181,4582,4583,4584,4585,4586,25322,53883,92299,
142924,142925,142926,142927,142928,302928,497409,497409

Это 23 числа, что было сильным показателем для повторения блока 22 раза, а также для завершения блока .(дублирующий элемент верхнего стека), так что предыдущий результат остался в стеке и чтобы итоговая итерация появлялась на стек в два раза. Это22,{____.}/ .

Теперь, глядя на пробелы, они оказываются четвертыми силами (что хорошо, потому что у нас есть 4и ?). Точнее, они являются четвертой степенью индекса текущего числа. Итак, затем мы посмотрели, какие индексы создали разрыв:

4,5,6,7, 12,13,14,15, 20,21,..?

В двоичном те

00100
00101
00110
00111
01100
01101
01110
01111
10100
10101

Все они имеют третий установленный бит, что означает, что индекс, вероятно, просто побитовый - и имеет значение 4(опять же хорошо, потому что мы можем создать другой 4с .и иметь a &). Это работает особенно хорошо, потому что эта операция приводит либо к, 0либо 4, и если мы используем это как показатель степени, мы получаем либо 1четвертую степень, либо , что именно то, что нам нужно. Итак, давайте соберем это вместе:

22,{.4&?+.}/

Вот что делает блок:

.      # Duplicate current index
 4     # Push a 4
  &    # Bitwise and
   ?   # Raise index to resulting power
    +  # Add to previous result
     . # Duplicate for use in next iteration

Теперь осталось две проблемы: у нас был бланк, который ,мы еще не использовали, и первая итерация - это особый случай, в котором нет значения из предыдущей итерации, к которому мы могли бы добавить вещи при встрече +. Мы обнаружили это благодаря несвязанному комментарию пользователя 23013, который случайно упомянул, что GolfScript начинается с пустой строки в стеке (если в STDIN ничего нет). Таким образом, мы могли бы использовать эту другую ,в самом начале, чтобы превратить эту строку в a 0, что было именно тем, что нам было нужно в начале итерации.

Python 3, размер 16, от matsjoyce

import __hello__

Рубин, размер 17, от Doorknob

p 2,%r~n~i=~'*tN'

Это было очень весело. Спасибо Sp3000 за помощь в этом! И я узнал, что %r?...?литералы могут иметь любые разделители. :)

PHP, размер 49, от bwoebi

print@substr(new exception,+~$$a+=++$$m+$$i+2+n);

Это было абсолютно психически .

Это добралось до

print@substr(new exception,);

довольно быстро, после чего мне нужно что-то, что дает -6после запятой, $++$++$++$+=$~main$2оставив.

Основной улов в том , что $a, $mи $iвсе NULL, поэтому их использование косвенно в переменных величин , означает , что они указывают на один и тот же переменной. Тем не менее, PHP, кажется, делает некоторые странные вещи с разрешением переменных переменных. С обычными переменными вы можете делать такие вещи, как

echo $a+$a=2;

который печатает 4( 2назначается, $aа затем добавляется к себе). Но если я сделаю то же самое с переменными переменными:

echo $$a+$$a=2;

Я получаю 2, потому что теперь первый$$a оценка перед назначением.

В конце концов мне удалось навязать некоторый порядок, наложив некоторые значения на RHS, +=которые должны были быть оценены до этого добавления-назначения. Таким образом, я получил то, 5что я мог тогда просто дополнить. Тем не менее ... происходят некоторые загадочные вещи, и я понятия не имею, почему половина вещей, которые я пробовал, работала и не работала.

Рубин, размер 38, от Doorknob

[$><<(!$pece60).to_s[rand($win)].succ]

Я уверен, что это далеко не оригинал. Это детерминированный, несмотря на использование rand.

Вот как это работает. $><<это просто вывод. $pece60и $winявляются неопределенными глобальными переменными, которые поэтому являются справедливыми nil(и они позволили мне избавиться от некоторых посторонних символов). !$pece60делает trueи to_sдает строку"true" .

Целую вечность я пытался получить 2или -2получить доступ uк нему там, но потом я понял, что могу просто взять tи вызвать .succ(essor) для этого, чтобы сделать u.

randс nilпараметром возвращает случайное число с плавающей точкой в ​​интервале [0,1). При использовании чисел с плавающей точкой для индексации строк они усекаются до целых чисел, поэтому всегда будет возвращаться первый символ.

Наконец, у меня была запасная пара, []поэтому я просто завернул все в нее, потому что, к счастью, все это выражение в Ruby.

Спасибо Sp3000 за то, что он бросил некоторые идеи в чате.

C 51 по es1024

c=0xf.cp9,hhtaglfor;main() {;; printf("%d",(++c));}

После 20 лет программирования на C сегодня я узнал о шестнадцатеричных константах с плавающей точкой.

Руби, 45 (гистократ)

%q[zyfnhvjkwudebgmaclprs x].to_i(36)/51074892

Woohoo! Это моя первая попытка решить проблему с гольф-кодом, и у меня недостаточно представителей, чтобы прокомментировать исходное сообщение. Я сразу узнал использованный трюк, поскольку я часто нашел его применение в производственном коде. Потребовалось около 5 минут, чтобы выяснить большую часть структуры и несколько часов, чтобы придумать полный ответ.

Объяснение:

• %q[]альтернативный метод для создания строк Скобки и фигурные скобки также могут быть использованы.
• String#to_i в Ruby принимает числа в любой базе от 2 до 36. Он игнорирует первый символ в строке, который не является частью числа, поэтому любые лишние символы могут быть «выброшены» после пробела.

И вот код, который я использовал для взлома:

require 'set'

# return true if the string is made up of unique characters
def uniq(s)
  a = s.each_char.to_a
  return a == a.uniq
end

def uniq_while_same(a,b)
  s = Set.new
  a.each_char.zip(b.each_char).each do |ai, bi|
    return true if ai != bi
    return false if s.include? ai
    s << ai
  end
  return true
end

def ungolf(answer)
  # For each base that even makes sense
  [            36, 35, 34,     32, 31, 30,
   29, 28, 27, 26, 25, 24, 23,     21, 20,
   19, 18, 17, 16, 15, 14, 13, 12,     10].each do |base|
    # Ignore bases where it is not possible to create a unique-string number greater than answer
    next if answer > base ** base
    # Pick digits for the denominator that are not duplicates of the digits in base
    denominator_digits = ('1234567890'.each_char.to_a - base.to_s.each_char.to_a)
    # For each permutation of those digits for the denominator
    (1..10).each do |denominator_length|
      denominator_digits.permutation(denominator_length) do |denominator_s|
        # Maybe the denominator is in octal
        denominator_base = 10
        if denominator_s[0] == '0'
          next if denominator_s.include?('8') || denominator_s.include?('9')
          denominator_base = 8
        end
        denominator_s = denominator_s.join
        denominator = denominator_s.to_i denominator_base
        print "#{"\b"*64}(%q[#{(answer * denominator).to_s(base).ljust(36)}].to_i #{base})/#{denominator_s.ljust(10)}" if rand < 0.01
        # Ignore denominators that are definitely impossible to have answers for
        next unless uniq_while_same "qtoi#{base}#{denominator_s}#{(answer * denominator).to_s(base)}",
                                    "qtoi#{base}#{denominator_s}#{((answer + 1) * denominator).to_s(base)}"

        # For each numerator that gives answer when divided by the denominator
        (answer * denominator...(answer + 1) * denominator).each do |numerator|
          print "#{"\b"*64}%q[#{numerator.to_s(base).ljust(36)}].to_i(#{base})/#{denominator_s.ljust(10)}" if rand < 0.01
          # Remove any that are still not unique
          s = "#{numerator.to_s(base)}#{base}#{denominator_s}qtoi"
          next unless uniq s
          # Done. Compute which characters need to be thrown away to fill the remaining space
          remains = ('0123456789abcdefghijklmnopqrstuvwxyz'.each_char.to_a - s.each_char.to_a).join
          print "#{"\b"*64}#{" "*64}#{"\b"*64}"
          return "%q[#{numerator.to_s(base)} #{remains}].to_i(#{base})/#{denominator_s}"
        end
      end
    end
  end
  print "#{"\b"*64}"
  puts "\nnone"
  return nil
end


print ungolf 9410663329978946297999932

Путь встраивания проблемы NP в загадку. Я был полностью обнаженным ботаником. Отличная работа!

Оболочка Python [любая], размер 44, автор Caridorc

__name__[3]  or (enfin_____[42], manager[1])

Я уверен, что должно было быть что-то большее, чем это, но так как __name__приравнивается к __main__, выбирается 4-й символ «а», а остальная часть строки никогда не оценивается.

Perl, размер 36, от брезгливого оссиффража

$_=rof;for$i(1..2129<<7){$_++}print;

Еще один сложный.

CJam, размер 13, user23013

G,Cf#If/sE*K%

Проверьте это здесь.

Решается вручную, вот так:

Во-первых, некоторые предыстории для не-CJammers:

• CEGIKвсе переменные, которые предварительно инициализируется 12, 14, 16, 18, 20, соответственно.
• s преобразует верхний элемент стека в строку
• Строки технически являются просто массивами символов.
• fэто довольно волшебно. Для целей этого ответа упрощенная версия состоит в том, что для массива a, некоторого другого значения bи оператора gпоследовательность abfgотображается g(_,b)на a(где каждый элемент aвходит в_ слот).
• / это деление и разбиение массивов (среди прочего).
• * это умножение и повторение массива (среди прочего).
• %Это модуль и некоторая странная операция, которая в форме ad%для массива aи целого числа dпринимает каждый dэлемент a(как разрезание Python с шириной шага d).
• # это возведение в степень (среди прочего).
• ,превращает числа в диапазоны (от 0до n-1) и возвращает длину массива.

Хорошо, это с дороги ...

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

Сначала я предположил, что fs использовались с #и %, но это означало бы, что нам понадобится число около 90, чтобы получить правильное количество цифр в конце. А также, это не объясняло, что делать с этим s, и, поскольку ответ выглядел очень по-гольфистски, я сомневался, что user23013 только что добавилs в качестве эффективного где-то, чтобы отбросить людей.

Так что я подумал, может быть, он даже не держит маленькие числа с %, но вместо этого он строит массив из огромных чисел, объединяет их строковое представление с s, но затем только выбирает из них какой-то странный фрагмент %. Поэтому я немного поигрался со следующей структурой:

__*,_f#_f/s_%

(Вы не можете сделать _f/сначала, потому что это даст ноль по крайней мере для первых 12 элементов.)

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

В какой-то момент мне пришло в голову, что нам не нужен такой большой диапазон (то есть произведение двух чисел), если бы вместо этого мы использовали *для повторения полученную строку. Из-за несоответствия параметров *и %это не приведет к повторению в результате:

_,_f#_f/s_*_%

Это дало результаты длины, очень близкой к тому, что я искал. Я бы на самом деле попробовал все 240 из них, но довольно быстро (с третьей или четвертой попытки) я наткнулся на

E,Cf#If/sG*K%

который дает

03081942753650251594592190492275006661328850322159030034930530649722385533653290754678977

И я подумал, что совпадение первых шести цифр не будет совпадением. Таким образом, вопрос заключался в том, как переставить его, не нарушая фактические вычисления:

• Я не мог измениться, Kпотому что это выделило бы разные цифры.
• Я не мог измениться CилиI потому что это изменило бы числа, полученные в результате двух операций с картой.
• Если бы я изменил Gэто, это только изменило бы количество повторений, которое не сделало бы ничего, кроме изменения длины результата. (И это хорошо.)
• Если бы я изменил Eэто, это изменило бы диапазон массива, но диапазон все еще начинался бы с [0 1 2 3 ...], таким образом, это не повлияло бы на вычисление. Это будет влиять на длину базовой строки , возвращаемой s, что также означало бы , что K%бы выбрать различные цифры от дополнительных повторений.

Так что я просто попытался обменяться Eи Gи вуаля:

030819828850379075460427536222159187897761502517030034671154875945928930530907551421904962649729

Итак, вот что делает код:

G,            "Push [0 1 2 3 ... 13 14 15].";
  Cf#         "Raise each element to the 12th power.";
     If/      "Divide each element by 18.";
        s     "Concatenate all numbers into a string.";
         E*   "Repeat 14 times.";
           K% "Pick every 20th digit.";

APL, размер 17, user23013

+(3*3)3,(***)\3 3

Я провел далеко слишком долго пытаюсь взломать это. Вероятно, все прошло бы быстрее, если бы я знал, что APL входит.

Попробуй здесь

Pyth, размер 11, от isaacg

:\\w$ ",d,N

Это какая-то грубая ошибка прямо здесь. Это компилируется в:

Pprint("\n",at_slice("\",input(), ",d,N))

Соответствующая ошибка заключается в том, что вместо этого \\компилируется , что позволяет вам компилировать Pyth в строку."\""\\"

Питон, размер 69, Sp3000

print(sum(list(map(ord,str((dict(((str(dict()),list()),)),str()))))))

Это было сложно ...

Python 3, 37 байт, Sp3000

print(sum(b"a".zfill(len(str(...)))))

Смущающе, безусловно, самая сложная часть была в том, чтобы преобразовать строку в байты. Я должен был спать на нем, и ночью понял: "Да, это буквальный байтов!"

PHP, 53, от PleaseStand

Взломали это наконец:

for($d=57,$o=35;$o+$d<999;)$o+=printf("$d%o",$d+=$o);

Решение пришло довольно быстро, когда я заметил, что последовательность состоит из чередующихся десятичных и восьмеричных чисел:

Dec: 57...92...132...177...228...285...348...417...492....573....661....756....858....
     571349220413226117734422843528553434864141775449210755731225661136475615328581707
Oct: ..134..204...261...344...435...534...641...754...1075...1225...1364...1532...1707
==Dec:  92  132   177   228   285   348   417   492    573    661    756    858    967

Кроме того, интервалы между каждым набором чисел росли со скоростью, равной возвращаемому значению printf()(то есть количеству написанных символов).

Python 2, размер 132, автор Vi.

exec('from string import printable as e\nprint "cqance"\x2Ereplace("q",e[len("fgiillmmooprrsstt")])or ",,,\016:::S[]____tuuvyy" ""')

Спасибо за все обратные слеши и кавычки :)

Редактировать: обновленная версия с 96 символами:

exec "try:exec'from __future__ import braces\\nt(12)'\nexcept SyntaxError as q:print(q[0][6:])"

Это полностью взято из решения Алекса в https://codegolf.stackexchange.com/a/41451/32353

CJam, размер 15, Ypnypn

98,{7%}%{6+}%:+

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

__,{_%}%{_+}%:+
_,{_%}%{__+}%:+
__,{_+}%{_%}%:+

который создает двузначный диапазон, затем отображает операцию сложения и по модулю (в любом порядке) на диапазон, прежде чем его суммировать. Так что я только начал с первого, и систематически пробовал перестановки 6789в пробелах.

PHP, размер 52, от PleaseStand

for(mt_srand($i=46);$i--;)echo chr(mt_rand()%95+32);

В конце концов это оказалось довольно легко. Результат выглядит очень случайным, и символы m, t, _, r, a, nи dвсе оказалось в два раза ...

Python 2, размер 61, автор FryAmTheEggman

print(dir('~s]l.c:st_''-p_tp.l]-~.:o:Te[_u[.i_')[10][2:][:3])

Я был бы очень удивлен, если это соответствует оригиналу.

Python 3, Sp3000, размер 44

print(~(~(()<((),))<<(()<((),))))<<((()<()))

Python 3 помог мне здесь, так как я смог вызвать ошибку (сдвиг влево Noneна что-то) после печати ответа.

PHP, размер 52, от kenorb

_:@print_r(chr(@++$i+pow(3<<5,1)));if($i<2*4)goto _;

(Боже, как долго мне _rприходилось думать, что делать с оставшимся суффиксом. Пока я не заметил, что это не так print, но print_r...)

PHP, размер 54, Стив Роббинс

echo(21<<($$$$$$${$aaaabbbbbbehi==$l&$w^2}^1==1));;;;

Не оригинальное решение, я думаю.

C, es1024, длина 70

e='C',f;main(g){Chorkil:f=printf("40%.d",e+e-  -g);}hAx;*hotpoCkats();

Сложнее всего было отследить всех ненужных персонажей ... серьезно ... мне пришлось переделывать их примерно 10 раз. Единственное, что меня беспокоило, так это .то, что я как-то застрял в середине printfстроки формата, и он стал невидимым!

Python 3, размер 110, Sp3000

import sys,io
u=sys.stdout;sys.stdout=_=io.StringIO()
import this
u.write(" ".join(_.getvalue().split()[::9]))

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

Haskell, размер 34, Петр Пудлак

main=print(0xb2f3d5^0x7f1f27::Int)

Обратите внимание, что эта программа должна быть запущена на 32-битной машине. Если вы хотите проверить, что это правильная программа, и у вас есть 64-битный компьютер, вы можете использовать вместо этого:

import Data.Int
main=print(0xb2f3d5^0x7f1f27::Int32)

Было довольно легко угадать «рамку» программы main=print(0x<hex digits>^0x<hex digits>::Int). Вся магия заключалась в поиске правильного способа разбить и упорядочить цифры. Я не очень умный здесь, просто поиск грубой силы ... хотя я позаботился о том, чтобы злоупотреблять тем фактом, что некоторые цифры были дублированы, вероятно, было примерно равное количество цифр в базовой и экспоненте, и последняя цифра базы почти наверняка не была четной. Полный код поиска приведен ниже; он использует пакет multiset-comb . Полный поиск занимает около 10:33 на моей машине (и, конечно, дает только один правильный ответ).

{-# LANGUAGE NoMonomorphismRestriction #-}
import Control.Monad
import Data.Int
import Data.List (inits, tails, group)
import Numeric
import Math.Combinatorics.Multiset

main = print (searchFor (-1121766947))

searchFor n = do
    nl <- [6,5,7,4,8,3,9,2,10,1,11]
    (l_, r_)  <- chooseSubbag nl digits
    l <- perms l_
    guard (last l /= '2')
    r <- perms r_
    guard ((fromString l :: Int32) ^ (fromString r :: Integer) == n)
    return (l, r)

chooseSubbag n = chooseSubbag' n . group
chooseSubbag' n xss = go (drop (n-1) (concat xss)) n xss where
    go _  n xss | n < 0 = []
    go _  0 xss = [([],concat xss)]
    go [] n xss = []
    go m  n (xs:xss) = do
        (kx, tx) <- zip (tails xs) (inits xs)
        (k , t ) <- go (drop (length tx) m) (n-length kx) xss
        return (kx++k, tx++t)

digits = "1223577bdfff"
fromString = fst . head . readHex
perms = permutations . fromList

Javascript, 82, от TrungDQ

b=/v/[0]+' ';b[0]+b[9]+b[6]+b[7]+'v'+b[7]+((0==0)+b)[1]+b[9]+b[4]+b[5]+b[6]+b[2];

Взял навсегда, чтобы получить правильные индексы.