Я переворачиваю исходный код, вы отрицаете ввод!

36

Откровенная плагиат из рип-офф . Иди голосуй!

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

Примеры

Допустим, ваш исходный код есть ABCи его ввод 4. Если я пишу CBAвместо этого и запускаю, вывод должен быть -4.

Допустим, ваш исходный код есть ABCи его ввод -2. Если я пишу CBAвместо этого и запускаю, вывод должен быть 2.

Ввод 0может дать 0или -0, однако, если вы поддерживаете подписанный ноль, -0должен дать 0.

code-golf  math  number  source-layout 
— Адам
источник
5
Зачем нам нужна копия того же вопроса?
— Кристиан
5
@Christian Тот, кто выводит постоянное число (и его отрицание), тогда как этот должен принимать и возвращать / отменять его. Совсем другая работа на многих языках.
— Адам
5
А да, теперь я вижу разницу. Надо ОЧЕНЬ внимательно читать
— Кристиан
Если вы используете структурированный язык, такой как C #, вы просто меняете строки?
— PerpetualJ
@PerpetualJ Нет, посмотрите на источник как список символов, некоторые из которых являются переносами строк.
— Адам

Ответы:

11

машинный код x86, 3 байта

C3 D8 F7

Вышеуказанные байты кода определяют функцию, которая не работает: она просто возвращает управление вызывающей стороне. За этой функцией следуют два байта мусора, которые не будут выполнены, поскольку они приходят после возврата - они находятся в «ничейной стране». В мнемонике ассемблера:

ret                     ; C3    
fdiv  st(0), st(7)      ; D8 F7

Хорошо, теперь какой-то тролль приходит и меняет порядок байтов в обратном порядке:

F7 D8 C3

Эти байты теперь определяют функцию, которая принимает целочисленный аргумент в EAXрегистре, отрицает его и возвращает управление вызывающей стороне. В мнемонике ассемблера:

neg  eax     ; F7 D8
ret          ; C3

Итак ... это было просто. :-)

Обратите внимание, что мы можем сделать инструкцию «отрицание» тем, что хотим, поскольку она никогда не выполняется в «прямой» ориентации и выполняется только в «обратной» ориентации. Следовательно, мы можем следовать той же схеме, чтобы делать произвольно более сложные вещи. Например, здесь мы берем целочисленный аргумент в другом регистре (скажем, EDIчтобы следовать соглашению о вызовах System V, обычно используемом в системах * nix), отрицать его и возвращать в обычном EAXрегистре:

C3      ret
D8 F7   fdiv  st(0), st(7)      ;  \ garbage bytes that
F8      clc                     ;  | never get executed,
89      .byte 0x89              ;  / so nobody cares

  ↓ ↓

89 F8   mov  eax, edi
F7 D8   neg  eax
C3      ret
— Коди Грей
источник
7

Haskell , 8 байт

Функция анонимной идентичности, превращающаяся в вычитание из 0обратного.

id--)-0(

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

Перевернутый:

(0-)--di

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

— Орджан Йохансен
источник
2
Вам удалось сломать подсветку кода с помощью вашей обратной версии!
— Тим
@ Тим любопытно. Тестирование показывает, что оно заканчивается неудачей, когда комментарий начинается сразу после правильной скобки.
— Эрджан Йохансен
6

Пробел , 48 байт

S S S N
S N
S T N
T   T   T   T   T   T   N
S T N
N
N
T   S N
T   N
S S T   N
T   T   S S T   T   T   T   T   N
T   S N
S N
S S S

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.

Незначительная модификация моего ответа в Whitespace для обращения исходного кода, вы отрицаете вывод! вызов .

Попробуйте онлайн или попробуйте онлайн в обратном порядке (только с необработанными пробелами, вкладками и новыми строками).

Объяснение:

Использование программы выхода, встроенной в короткий палиндром NNN.
Обычная программа будет:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Обратная программа будет:

SSSN   # Push 0 to the stack
SNS    # Duplicate it
TNTT   # Read STDIN as integer, and store it at heap address 0
TTT    # Retrieve the input from heap address 0, and push it to the stack
SSTTN  # Push -1 to the stack
TSSN   # Multiply the top two values on the stack together
TNST   # Pop and print the top of the stack as number
NNN    # Exit the program, making everything after it no-ops

Небольшое дополнительное объяснение нажатия номера:

  • Первое S: включить манипуляцию стека
  • Второе S: толкнуть число в стек
  • Sили T: положительный / отрицательный соответственно
  • Некоторые S/ Tсопровождаемые трейлингом N: число в двоичном виде, где S=0иT=1

Т.е. SSTTSTSNтолкает -10. Для 0нас не нужно явное S=0, так просто SSSNили SSTNдостаточно.

— Кевин Круйссен
источник
5

Brain-Flak , 7 байтов

#)]}{[(

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

Перевернутый:

([{}])#

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

Примечание: работает только в интерпретаторах, поддерживающих комментарии (например, работает в Rain-Flak, но не в BrainHack)

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

({}[{}])

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

— Райли
источник
Это неопределенное злоупотребление поведением? Я не думаю, что спецификация Brain-Flak допускает такие скобки.
— ВысокоРадиоактивный
@TwilightSparkle The #запускает комментарий, поэтому круглые скобки в исходной версии игнорируются.
— Райли
Ах да, я забыл! Но тогда он работает только в Rain-Flak (хотя это официальный интерпретатор). Вам, вероятно, нужно будет упомянуть об этом?
— ВысокоРадиоактивный
@TwilightSparkle добавил примечание для уточнения. Спасибо.
— Райли
Забавный маленький вызов: можете ли вы сделать это без комментариев, если вы также поменяете местами открывающие / закрывающие скобки, а не просто перевернутые?
— DJMcMayhem
4

MarioLANG , 22 байта

;:
=#
:)!
--
<(
"
[>
;

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

Он просто вводит и выводит число, прежде чем он падает до EOF

наоборот:

;
>[
"
(<
--
!):
#=
:;

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

Он зацикливается до тех пор, пока входное значение не станет равным 0, а выходное значение будет равно -input, и он скажет число.

— Дориан
источник
4

р , 23 байта

Я решил попробовать без комментариев.

Вперед

`+`=scan;""+-0;nacs=`+`

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

Обратный

`+`=scan;0-+"";nacs=`+`

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

В прямой версии +действует бинарный оператор, и- является унарным оператором.

С другой стороны, оно +становится одинарным, а -двоичным. Таким образом, функция сканирования принимает аргументы: file=""это означает what=0, что стандартный ввод, и , которые также являются значениями по умолчанию. Таким образом, когда +унарный символ является первым, аргумент находится справа, а когда он является двоичным, первый аргумент находится слева.

;nacs=`+`

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

— Аарон Хейман
источник
1
Это очень умно (+1). Мы часто переопределяем R-операторы в байты гольфа, но я думаю, что это первый раз, когда я увидел +переопределение для использования как унарного, так и бинарного. Мне потребовалась минута, чтобы понять, как это было проанализировано ... Ни одно другое имя оператора не сделало бы эту работу.
— Робин Райдер
4

Perl 5 ( -p), 7 6 байт

-1 благодаря @primo

$_*=$#

TIO

Комментарий не меняет ввод

#1-=*_$

Отрицание ввода

$_*=-1#

TIO

— Науэль Фуйе
источник
-1: $_*=$# TIO . Обратите внимание, что #должен быть самый последний байт программы, иначе он будет интерпретироваться как переменная $#, а не как последний индекс массива с именем <empty>.
— Примо
1
однако я не понимаю, как это работает, потому что попытка печати $#дает либо ошибку (если # не последний символ), либо ничего
— Nahuel Fouilleul
Кажется, работает только с -pили -n. Я подозреваю, что шаблон имеет к этому какое-то отношение ...
— primo
2
@primo Это работает, потому что -p/-nдобавляет ;после кода. Что означает, что $#на самом деле $#;: размер массива @;. Если размер @;изменяется, результат больше не корректен ( TIO ). Во всяком случае, это супер умно, молодец! :)
— Дада
это объяснение можно увидеть perl -MO=Deparse -p <(echo -n '$_*=$#'), потому что, кажется, perl -MO=Deparse -pe '$_*=$#'добавляет новую
— строку
4

Backhand , 6 5 байт

I@-Ov

Попробуйте онлайн! Попробуй вдвое!

Сделано немного сложнее из-за природы указателя в Backhand. Я не думаю, что возможно получить что-то более короткое, ха-ха, оказывается, я был неправ. Это не дублирует никаких инструкций и повторно использует команды ввода, вывода и завершения между двумя программами. В настоящее время я думаю, что это оптимально, так как вам нужно всеIO-@ команды для работы, а в 4-байтовой программе вы можете выполнить только две из этих команд.

Объяснение:

Указатель в Backhand перемещается на три ячейки на галочку и отскакивает от границ ячейки, что означает, что общая логика перекрывается. Однако вы можете управлять этой скоростью с помощью vи^ командами.

Оригинальная программа выполняет инструкции IO-@, которые вводятся как число, выводятся как число, вычитаются, завершаются. Очевидно, что вычитание излишне. В коде это:

I@-Ov
^  ^    Reflect
  ^     Reflect again
 ^

Обращенная программа выполняется v-I-vO-@. vУменьшает шаги указателя между клещами и -вычитает в нижней части стека, которая неявно равна нулю. Дополнительные -команды ничего не делают. Программа выполняется как

vO-@I
v       Reduce pointer speed to 2
  -     Subtract zero from zero
    I   Get input as number and reflect off boundary
  -     Subtract input from zero
v       Reduce pointer speed to 1
 O      Output as number
  -     Subtract zero from zero
   @    Terminate
— Джо Кинг
источник
3

R , 14 байтов

scan()#)(nacs-

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

Полная программа, которая читает число, или читает и отрицает число. Обратная функциональность защищена встроенным комментарием

— Ник Кеннеди
источник
Ваши скобки неверны в комментируемой части.
— Аарон Хейман
@AaronHayman спасибо!
— Ник Кеннеди
3

Python 3 , 22 14 байт

int#__bus__. 0

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

Использует intконструктор класса и встроенный псевдоприватный метод.

— mypetlion
источник
Да. Почему пробел перед атрибутом обязателен?
— Джо Кинг
2
@JoKing 0.будет интерпретироваться как число, за которым следует символ
— attinat
2

05AB1E , 2 байта

(I

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

Перевернутый

(    negates nothing
  I  pushes input

I    pushes input
  (  negates input
— jasanborn
источник
Предполагается, что он отменяет ввод только в одном направлении, оставляя его как есть в другом. Ясно, что однозначное решение не может быть действительным.
— Адам
Мой плохой, я неправильно понял
— Ясанборн
2

APL (Dyalog Unicode) , 13 3 байта

-∘0

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

Тривиальный ответ. Возвращает argили ¯arg.

Сохранено 10 байтов, не будучи глупым (спасибо Адам).

Изменил полученный 3-байтовый код на более подходящую функцию.

— Ж. Салле
источник
Вау, это можно сделать тривиально!
— Адам
Интересно, что у вас уже есть 3-байтовый ответ, встроенный в качестве подстроки этого.
— Адам
@ Адам, да, я знал, что где-то там был простой ответ. Спасибо.
— Ж. Салле
2

Машинный язык Тьюринга , 39 байт

Положительный

1 r - _ 0
0 l * * 0
0 - _ l 0
0 _ _ r 0

Отрицательный

0 r _ _ 0
0 l _ - 0
0 * * l 0
0 _ - r 1

Этот был немного хитрее, чем я думал, в основном потому, что мне пришлось преодолеть свои предрассудки о наличии кода, который работает с ошибками «компиляции».

— ouflak
источник
2

> <> , 5 4 байта

n-r0

использует инициализацию стека с -vопцией, поместите туда свою входную переменную.

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

Или попробуйте разворот

объяснение

n       Prints whatever is on the stack as a number
 -      Subtract the top 2 elements on the stack.
        There aren't 2 elements, so it crashes.
  r0    Never gets executed

or reversed:

0       Push a 0 onto the stack
 r      reverse the stack (now 0, -v)
  -     Subtract top 2 elements and push result (0-v, ie negated)
   n    Print as number
        The code wraps around and executes again. 
        It crashes on the - as there is only one
        item on the stack: 0.
— steenbergh
источник
2

Стека кошек -mn , 2 байта

-X

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

Попробуйте наоборот!

объяснение

Оказывается, это на самом деле намного проще, чем предыдущая задача в Stack Cats. Полная программа (после подачи заявки -m) здесь есть -X-. Xиспользуется для смены стеков влево и вправо от ленточной головки, то есть не влияет на начальный стек, поэтому мы можем его игнорировать. Но тогда программа фактически просто --(отрицает вершину стека дважды), который ничего не делает.

Для обратной программы подачи -mдает X-X. Опять Xже ничего не делает, поэтому программа эффективно просто- , что сводит на нет вершину стека.

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

Но опять же, использование -mнемного похоже на читерство, поэтому ниже приведено решение, которое использует полностью зеркальную программу.

Стека кошек -n , 7 байт

:I<->I:

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

Попробуйте наоборот!

объяснение

Соображения из предыдущего ответа по-прежнему применимы : любое допустимое решение должно использовать парные символы и I. Шесть возможных решений (включенных в ссылку TIO) практически одинаковы. -и _эквивалентны в этой программе, и :могут быть заменены |илиT (которые делают то же самое для ненулевых входов и по совпадению также работают для нулевых входов). Я просто выбрал это, чтобы объяснить, потому что это проще всего.

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

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
<    Move another stack left (without taking the value).
-    Negate the zero on top of that stack (i.e. do nothing).

Поэтому вторая половина программы точно отменяет первую половину, и в итоге мы -1снова получаем ввод сверху .

Обратная программа есть :I>-<I:. Давайте посмотрим, как это меняет вещи:

:    Swap the input with the -1 below.
I    Move the -1 one stack to the left and turn it into +1.
>    Move one stack right, i.e. back onto the initial stack which still holds the input.
-    Negate the input.
<    Move back to the left where we've parked the 1.
I    Move that 1 back onto the initial stack and turn it back into a -1.
:    Swap the -1 below the negated input to act as an EOF marker.
— Мартин Эндер
источник
2

Пакет, 34 байта

@ECHO.%1 2>MER@
@REM>2 1%=-aa/TES@

Повторяет ( ECHO.) ввод ( %1). Остальная часть первой строки технически перенаправляет STDERRв файл с именем MER@, но это не имеет значения.
Вторая строка закомментирована ( REM...).

Перевернутый

@SET/aa-=%1 2>MER@
@REM>2 1%.OHCE@

Использует арифметический режим команды set ( SET /a) для вычитания ( -=) input ( %1) из неопределенной переменной ( a), которая эквивалентна 0 - input. Опять же, остальная часть первой строки технически перенаправляет STDERRв файл с именем MER@, но это не имеет значения.
Вторая строка закомментирована ( REM...).

— Οurous
источник
Это выглядит интересно. Хотите объяснить?
— Адам
@ Adám Добавил объяснение, а также понял, что у меня были программы назад.
— Οurous
2

Брахилог , 2 байта

&ṅ

Брахилог неявно вводит слева и выводит справа.
&игнорирует что-либо слева и передает ввод функции вправо.
ṅвынуждает каждую сторону этого быть отвергнутыми версиями друг друга.

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

— IFcoltransG
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.