Расшифровка исходного кода [поток грабителя для попыток взлома]

44

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

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

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

Leaderboard

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

20 решает

15 решает

10 решает

7 решает

5 решает

4 решает

3 решает

2 решает

1 решение

PhiNotPi
источник
1
Perl 5, размер 27, Morot - print'pin '= ~ tr (a-za) (za-z) r
@ WumpusQ.Wumbley Мы все были там ...;)
Мартин Эндер
3
Я отказываюсь тратить свое время, пытаясь успокоить его.
Учитывая два вопроса тела, кажется, что зашифрованные / расшифрованные ответы поменялись местами
Mooing Duck
Ruby, 23 от MegaTom = p% ++. Method [80] [1 ..- 1]
гистократ

Ответы:

32

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!"это один из возможных вариантов.

Деннис
источник
1
Это безумие - как вы узнали, что это был за номер?
Sp3000
1
Я искал логарифм (и другие) этого числа, но не получил никакого результата. Теперь я обнаружил, что использовал слишком высокую точность.
jimmy23013
2
@ Sp3000: я отредактировал свой ответ.
Деннис
1
Очень хорошо! Я должен был вынуть еще два символа из строки, я думаю. В моем оригинале у меня фактически были пробелы, все еще находящиеся внутри строки, но mrдо того, как взять длину Не то чтобы вы не поняли это в какой-то момент. ;)
Мартин Эндер
25

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

()and bciprt

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

matsjoyce
источник
1
В Python 3 IDLE это выводит ().
Hosch250
@ hosch250 Поскольку он находится в программе (файл python), ничего не выводится, так как его нет print.
matsjoyce
Понимаю. Я бегал из командной строки.
Hosch250
47
.... "вещь" ....
TheDoctor
4
@Imray Из-за короткого замыкания - Python загружает кортеж и проверяет, является ли значение кортежа истинным, поскольку оно пустое, оно ложно. Код для загрузки переменной bciprtникогда не выполняется, поэтому он никогда не генерирует NameError.
Mateon1
20

Python, размер 74, xnor

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

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

Sp3000
источник
1
Хорошая работа! Мое решение было очень похоже: list(\nprint(range is range)for aacdeeeeehmppprrrrssvwy in\noct(int is int)).
xnor
@xnor LOL это имя переменной. Разве это плохо, что я бы никогда не подумал об этом? :П
FryAmTheEggman
2
@FryAmTheEggman Я думаю, все ожидали, что я воспользуюсь уловкой моего первого полицейского .
xnor
@FryAmTheEggman Не беспокойся, ты не единственный: P
Sp3000
13

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

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

Выходы 42.

Ypnypn
источник
1
Имейте точку зрения :) Для справки, оригинал был print 2**2**2**2/2**2**2/2**2**2/2-2**2**2*2**2-22, но это не удивительно, что более одного варианта является правильным.
Geobits
13

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, что было именно тем, что нам было нужно в начале итерации.

Мартин Эндер
источник
Пятно на. Это было вдохновлено последовательностью в OEIS, которую я не могу найти сейчас.
Питер Тейлор
3
И именно поэтому наличие отдельной темы для грабителей - хорошая идея. Хорошая работа!
Деннис
11

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

import __hello__
Мартин Эндер
источник
1
Бах,
разбитый
Правильно, одно замечание к вам (у нас тоже должен быть список с этой информацией?)
matsjoyce
11

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

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

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

Мартин Эндер
источник
10
Придерживается Doorknob за то, что он безумно вводит в заблуждение print, только для того, чтобы разделить его на pпечать, %rрегулярные выражения и iсопоставление регулярных выражений без учета регистра.
Sp3000
11

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что я мог тогда просто дополнить. Тем не менее ... происходят некоторые загадочные вещи, и я понятия не имею, почему половина вещей, которые я пробовал, работала и не работала.

Мартин Эндер
источник
Для справки, мой оригинал:print@substr(new exception,~$$mn+=2+$$a+++$$i++);
bwoebi
Btw. Я надеюсь, что все знаки доллара и тот факт, что все буквы mainбыли в строке, вводят вас в заблуждение. Кроме того, довольно необычный метод извлечения {main}, я думаю ;-)
bwoebi
@bwoebi Это mainне вводило меня в заблуждение, после обнаружения exception, newи substr. Я думал, что они будут просто именами переменных. Мне потребовалось немного времени, чтобы придумать, как использовать переменные переменные, а затем я потратил большую часть времени на выяснение порядка операций, которые фактически могли бы привести к операции, 5которую я мог бы дополнить, не используя другой набор скобок.
Мартин Эндер
Что ж, в следующий раз, если долларов больше, чем символов, обычно это переменные переменные. (В этом случае я также использовал варвары для принудительной оценки слева направо.) Сколько времени вам потребовалось, чтобы найти новое исключение для подстроки? Кстати, у меня есть более глубокие познания в движке Zend, поэтому я могу прекрасно объяснить себе, почему все оценивается в каком порядке, и это хорошо для этих задач ;-) Если есть конкретная вещь, которую вы не получаете, я ' Я с удовольствием объясню это вам.
Bwoebi
@bwoebi Приходи завтра в чат , и мы сможем поговорить об этом, но я потратил достаточно времени на это сегодня. ;) Что касается вашего первого вопроса, exceptionбыл очевиден, который оставил бездомных персонажей substrи newваляется. Это было буквально первое, что я увидел, когда начал работать над этим.
Мартин Эндер
9

Рубин, размер 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 за то, что он бросил некоторые идеи в чате.

Мартин Эндер
источник
8
Ruby - страшно выглядящий язык.
feersum
8

C 51 по es1024

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

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

Искусство
источник
8

Руби, 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 в загадку. Я был полностью обнаженным ботаником. Отличная работа!

charredUtensil
источник
Я добавил комментарий к оригинальному ответу для вас.
FireFly
Это удивительно (и близко к предполагаемому ответу), но технически недопустимо, потому что у него нет вывода.
гистократ
* facepalm Ну, я все еще веселилась.
charredUtensil
2
@charredUtensil, если вы не возражаете запустить свой сценарий еще немного, я думаю, что печать просто перемещает курсор pперед выражением. Предположительно, оставшиеся символы можно использовать для формирования констант, как вы сделали.
FireFly
Мне на самом деле не нужно запускать его снова. Последние несколько символов строки можно переставить без изменения результата - p %q[zyfnhvjkwudebgmaclrsx].to_i(36)/51074892хотя я знаю, что я сломал свою настоящую попытку взлома :)
charredUtensil
7

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

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

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

брезгливый оссифраж
источник
Просто для справки оригинальная программа[__name__ for ___name__ in range(1,4)][2][3]
Caridorc
7

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.";
Мартин Эндер
источник
6

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

:\\w$ ",d,N

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

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

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

Мартин Эндер
источник
Должно Pprintбыть printили хотя бы pprint?
FireFly
@FireFly Это то, что указано в отладочном выводе. Может, интерпретатор Pyth определяет свой собственный Pprint?
Мартин Эндер
Ох, ладно, неважно тогда.
FireFly
6

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

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

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

GRC
источник
1
Ницца! Для справки, оригинал был print(sum(map(ord,str((dict(list(((str(),str(dict())),))),list()))))), но, очевидно, много разных комбинаций ключевых слов будет работать.
Sp3000
2
Это LISP-уровень паренов там!
xnor
6

Python 3, 37 байт, Sp3000

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

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

Блейк Уолш
источник
Ахаха, хорошо сделано, я думал, что Ellipsis может
сбить людей с толку,
Я видел многоточие и zfill, но не знал об объектах байтов. Они могут быть полезны в массивах целых чисел!
Feersum
Отличная работа! Я видел только распечатки и .zfill, и я знал, что сумма может быть частью этого, но я не мог решить это. Есть +1.
Hosch250
6

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()(то есть количеству написанных символов).

брезгливый оссифраж
источник
3
Ух, хорошая детективная работа!
Sp3000
6

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

kennytm
источник
Хех, мило. Хотите знать, что было решение с отступом ...
FireFly
Это не намеченное решение. Оригинальное решение не имеет каких-либо «отбрасывающих» вещей, таких как fgiillmmooprrssttили ,,,\016:::S[]____tuuvyy.
Ви.
exec? Мой код должен быть короче ... Я эмулировал его с compile+, evalпотому что я забыл о exec...
Ви.
Реализована более короткая версия. Попробуйте выяснить оригинальный трюк.
Ви.
5

CJam, размер 15, Ypnypn

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

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

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

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

Мартин Эндер
источник
Черт возьми, я тоже решил это: /
Оптимизатор
5

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

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

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

брезгливый оссифраж
источник
5

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

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

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

GRC
источник
Это не так, но в любом случае поздравляю! Мой код был:print''.__doc__[::2][::3].split()[1].split('.')[0][:-~-~True]
FryAmTheEggman
Оглядываясь назад, я не должен был включать кавычки ...;)
FryAmTheEggman
@FryAmTheEggman Ух ты - хорошая программа! Я был убежден, что вы, по крайней мере, использовали, dir()чтобы найти «получить». И да, было бы очень сложно без кавычек.
grc
5

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

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

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

feersum
источник
Хм ... похоже, я был довольно расточительным со своими паренами. Было print(~(~(()<())<<((()<((),))<<(()<((),)))))изначально.
Sp3000
5

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

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

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

bwoebi
источник
И я не знаю , как вы понять это :) Оригинал: _:print_r(chr(3*pow(2,5)+@++$i));if(@$i<4<<1)goto _;.
kenorb
3
@kenorb а) вам нужно что-то напечатать, поэтому echoневозможно; printостались; б) вам нужен какой-то цикл, но для forцикла не хватило точек с запятой, и, ну, в общем, есть двоеточие ... так что, вероятно, есть метка в сочетании с goto; в) тогда нужно прервать цикл goto. Имея сейчас X:print($Y);if($Y)goto X;(X и Y являются заполнителями); г) есть ++, но нет =, поэтому, вероятно, ++$Zот 1 до 8; д) чтобы получить буквы из целого числа, нам нужно chr()(обычно) - оно было там; е) теперь мне просто нужно было найти номера 96 и 8 для chr и if. Затем заполните заполнители и volià.
Bwoebi
5

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

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

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

jimmy23013
источник
2
Ха-ха, это мило. Я начал с того, что выловил « echoи» while, но потом не смог найти петлю, которая выдает 42.
Мартин Эндер
Был whileв моем оригинале.
Стив Роббинс
5

C, es1024, длина 70

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

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

feersum
источник
5

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
Даниэль Вагнер
источник
5

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

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

SLuck49
источник