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

44

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

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

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

Leaderboard

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

20 решает

15 решает

10 решает

7 решает

5 решает

4 решает

3 решает

2 решает

1 решение

cops-and-robbers 
— 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

Рубин, размер 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

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

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
— Даниэль Вагнер
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.