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

При желании вы можете добавить завершающий символ новой строки к выводу.

Это код-гольф, самый короткий ответ в (нечетных) байтах выигрывает.

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

Пример ввода> вывод:

13 > 13

42 >

Japt -f , 1 байт

u

uимеет значение кодового символа 117.

Попытайся

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 229338293752006975899311592859961592895993115928599615928

Это примерно равно 2 duodecillion байтов.

Файл переводится в следующую программу brainfuck:

,[<<+>+>-]<[>>+<<-]+>>[-[->]<]<[<[<]>.<]

Принимает ввод в виде кода ASCII с максимальным значением 256. Использует перенос.

Машинный код x86-64, 8 байт

Вдохновленный решением Брюса Форте , но немного под пар. :-)

8D 07          lea      eax, [rdi]    ; put copy of input parameter in EAX
D1 EF          shr      edi, 1        ; shift LSB into CF
             InfiniteLoop:
F3 73 FD       rep jnc  InfiniteLoop  ; test CF; infinite loop back here if input was even
C3             ret                    ; return with original input in EAX if it was odd

В EDIрегистр берется единственный целочисленный параметр в соответствии с соглашением о вызовах System V AMD64.

Изначально создается копия этого значения и помещается в EAXнее, чтобы при необходимости ее можно было вернуть. ( LEAиспользуется вместо обычного, MOVпотому что нам нужна инструкция с нечетными байтами.)

Затем значение in EDIсдвигается вправо на 1, что помещает сдвинутый бит в флаг переноса (CF). Этот бит будет 0, если число было четным, или 1, если оно было нечетным.

Затем мы проверяем CF, используя JNCинструкцию, которая будет разветвляться, только если CF равен 0 (т. Е. Число было четным). Это означает, что мы войдем в бесконечный цикл для четных значений. Для нечетных значений мы проваливаемся и EAXвозвращаем исходное значение (in ).

Однако с JNCинструкцией есть небольшая хитрость - у нее есть REPпрефикс! Обычно REPпрефиксы используются только со строковыми инструкциями, но поскольку оба руководства Intel и AMD согласны с тем, что нерелевантные / лишние / избыточные REPпрефиксы игнорируются, мы добавляем один из них в инструкцию перехода, чтобы сделать ее длиной 3 байта. Таким образом, относительное смещение, которое кодируется в инструкции перехода, также является нечетным. (И, конечно, REPсам по себе префикс нечетного байта.)

Слава Богу RET, кодируется нечетным байтом!

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

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

Машинный код x86-64 (вывод на последовательный порт), 17 байт

8D 07         lea   eax, [rdi]   ; put copy of input parameter (EDI) in EAX

B1 F7         mov   cl, 0xf7     ; put 0xF7 into low-order bits of CX
B5 03         mov   ch, 0x03     ; put 0x03 into high-order bits of CX
FE C1         inc   cl           ; increment low-order bits of CX to 0xF8 (so all together it's now 0x3F8)
0F B7 D1      movzx edx, cx      ; move CX to DX ("MOV DX, CX" would have a 16-bit prefix of 0x66)

D1 EF         shr   edi, 1       ; shift LSB of input parameter into CF
73 01         jnc   IsEven       ; test CF: branch if 0 (even), fall through if 1 (odd)
EF            out   dx, eax      ; output EAX (original input) to I/O port 0x3F8 (in DX)
            IsEven:
C3            ret                ; return

Что делает это немного более интересным, так это то, что код делает больше , а это значит, что было сложнее сделать все это, используя инструкции, которые кодируются с использованием нечетных байтов. Конечно, это также означает, что в коде гольф это терпит неудачу, так что это своего рода компромисс: хотите интересного и сложного или короткого?

В любом случае, для записи в порт ввода-вывода 0x3F8, который является стандартным последовательным портом COM1 на ПК , используется OUTинструкция x86 . Самое интересное, конечно, в том, что все стандартные порты ввода / вывода (последовательные и параллельные) имеют четные адреса, поэтому их нельзя просто закодировать как непосредственные для инструкции или перенести непосредственно в регистр. Вы должны инициализировать на единицу меньше действительного значения, а затем увеличить значение в регистре. Вы также ограничены использованием определенных регистров для манипуляции, потому что вам нужны регистры, которые кодируются с использованием нечетных байтов в инструкции, когда используются в качестве операндов.OUT

Кроме того, мне пришлось инициализировать DXрегистр (через CXрегистр) в верхней части цикла, хотя это необходимо только в том случае, если значение нечетное, чтобы JNCкоманда имела нечетное смещение. Тем не менее, поскольку мы пропускаем OUTинструкцию, все, что делает этот код - это пустые циклы и пустые регистры; на самом деле ничего не выводится , поэтому не нарушает правила.

Наконец, эта функция вернет (после того, как вы сделали или не сделали вывод на последовательный порт) с оставленным входным значением EAX. Но это на самом деле не нарушает никаких правил; все функции на ассемблере будут возвращаться со значением в EAX- вопрос только в том, является ли это значительным значением или значением мусора . Это определяется документацией функции (по сути, возвращает ли она значение или возвращает void), и в этом случае я документирую ее как не возвращающую значение. :-)

Нет ссылки TIO для этого, поскольку он не реализует вывод на последовательные порты. Вам понадобится настоящее железо или воображение.

Желе , 2 байта

ẋḂ

Эти символы соответствуют байтам 0xF7 и 0xBF в кодовой странице Jelly .

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

05AB1E , 3 байта

Éi=

Код соответствует байтовым значениям C9,69,3Dили 201,105,61которые являются нечетными.

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

объяснение

É     # input % 2 == 1
 i    # if true
  =   # print without popping

MATL , 3 байта

o?G

MATL использует ASCII - символов, так что o?Gсоответствует байт (в десятичной системе ) 111, 63, 71.

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

объяснение

o     % Push (implicit) input modulo 2
?     % If nonzero
  G   %   Push input
      % End (implicit)
      % Display stack contents (implicit)

Haskell , 36 33 байта

c[1]=1;c[m]=1+1+c[m-1-1];o	m=c[m]

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

Использование: o 7yiedls 7, o 8входит в бесконечный цикл.

Фактический алгоритм

o 1 = 1
o m = 2 + o(m-2)

Первая проблема, с которой я столкнулся, была нехватка места и (, потому что функция, oкоторая принимает аргумент m, обычно определяется как o m=...или o(m)=.... Однако я обнаружил, что встроенный комментарий также {- some comment -}работает как разделитель токенов, поэтому определение o{--}m=...возможно по заданным правилам. Редактировать: Орджан Йохансен отметил, что вместо пробела можно использовать символ табуляции, сохраняя три байта: o m=...

Второй проблемой был рекурсивный вызов o(m-2). -2это просто -1-1, но здесь трюк с комментариями не работает, потому что скобки обязательны. Я исправил это, позволив функции работать с одноэлементным списком, содержащим число: o[m-2]однако, поскольку это не стандартный способ ввода данных, я передал вычисление вспомогательной функции, cкоторая работает со списками, и вызов cиз oкоторой имеет правильный формат. ,

Python REPL, 38 байт

Принимает ввод как значение предыдущего выражения, используя _. Выходными данными будет строка (строковое представление целого числа для нечетного или пустая строка для четного).

'%s'%[['']+[_]][-1][[_%[1+1][-1]][-1]]

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

Чтобы запустить его в реальной оболочке, вы можете попробовать это здесь . Введите ввод, нажмите ввод. Вставьте код, нажмите Enter.

Объяснение:

Это заняло некоторое время, чтобы выяснить. Там нет ни умножения, ни разветвления, ни среза, ни запятых, ни точек, ни импорта, ни скобок, ни execнет eval, ни нетprint , ни функций. Я получил одно решение, работающее с этим выводом, используя stderr, но потом я понял, что нам нужно вывести фактическое целое число, а не просто значение truey / falsey.

Я использую скобки вместо скобок с [expression][-1]. Упрощение превращает приведенный выше код в '%s'%(['']+[_])[_%(1+1)].

Поскольку не может быть запятых, я использовал добавление списка для создания ['',_]. Используя форматирование строки, вы получите желаемый результат.

CJam, 6 байтов

q_iY%%

113 95 105 89 37 37

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

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

Cubix , 23 19 17 байт

;;u!I1)%/;O=!;;/;

Попытайся!

@, которая завершает программу Cubix, является ascii 64, так что, к сожалению, это фактически просто входит в бесконечный цикл после проверки на странность. Нет ссылки TIO, поскольку время ожидания истекло.

= (ASCII 61) не является опцией в Cubix.

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

Куб версия:

    ; ;
    u !
I 1 ) % / ; O =
! ; ; / ; . . .
    . .
    . .

Алгоритм:

• I (73) : читать на входе как число
• 1 (49) : нажать 1
• ) (41) : приращение
• % (37) : возьми мод
• / (47) : повернуть налево
• ! (33) : пропустить следующую инструкцию, если нечетный
  • 1;;/; ;is (59): готовит стек к выводу
  • O (79) : Вывод в виде числа.
  • Затем он повторно вводит алгоритм, но Iчитает 0для конца ввода, поэтому мы гарантированно войдем в четную ветвь
• u (117) : разворот с правой стороны
• ;;;!I : loop, эффективно ничего не делая.

Древесный уголь , 9 байт

¿﹪Ｉθ÷χ⁵→θ

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

По сути, он печатает ввод справа, если он не кратен 10/5 ( ²символ даже на кодовой странице древесного угля ). Используемые символы:

• ¿: Код BF.
• ﹪: Код A5.
• Ｉ: Код C9.
• θ: Код F1.
• ÷: Код AF.
• χ: Код E3.
• ⁵: Код B5.
• →: Код 13.

На самом деле →ближний конец избыточен, но потом я увидел, что ответ должен был иметь нечетную длину ...

Объяснение:

¿      if (
 ﹪      Modulo (
  Ｉθ      the input as number,
  ÷χ⁵      χ (predefined value: 10) divided by 5 = 2 ) [is 1])
 →θ      then print rightwards the input as string

машинный код x86_64 (Linux), 12 11 байт

К сожалению 0x80, даже, но это все-таки сработало (предполагая, что «ничего не делает» означает не возвращаться):

0000000000000000 <odd>:
   0:   8d 07                   lea  (%rdi), %eax
   2:   83 e7 01                and    $0x1, %edi
   5:   83 ff 01                cmp    $0x1, %edi
   8:   75 fb                   jne       5  <odd+0x5>
   a:   c3                      retq

-1 байт, спасибо @CodyGray!

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

Mathematica, 20 байтов

Похоже, что это первое решение на неигровом языке.

a=1+1;g[i_/;!a\[Divides]i]=i

В MacintoshChineseTraditionalкодировке символов. \[Divides]есть {161, 253}(2 байта)

Альтернативная версия (23 байта)

\[CapitalAlpha]=1+1;\[CapitalGamma][\[CapitalChi]_/;\[CapitalAlpha]\[LeftFloor]\[CapitalChi]/\[CapitalAlpha]\[RightFloor]\[NotEqual]\[CapitalChi]]=\[CapitalChi]

или (показано в Юникоде)

Α=1+1;Γ[Χ_/;Α⌊Χ/Α⌋≠Χ]=Χ

в Symbolкодировке символов. (используйте только 1-байтовые символы)

Решение определяет функцию g(или Γ), которая оценивает ввод, когда ввод нечетный, и буквально «ничего не делает» (не оценивает), когда ввод четный.

Perl, 54 байта

Требуется -E.

Мне действительно очень понравился этот вызов, я думаю, что хотел бы попытаться улучшить этот ответ, но я думаю, что это может быть самый короткий, который я могу сделать на данный момент. Я уже несколько дней играю с этими ответами, но чувствую, что доволен 54-байтовым решением!

s//A_=Y[;A_=A_%O?A_W''/;y/#A-_/#-A/;s/[#-}]+/uc/ee;say

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

объяснение

По умолчанию большинство строковых функций Perl работают $_, что пусто для запуска.

Сначала s//A_=Y[;A_=A_%O?A_W''/заменяет пустую строку на $_with A_=Y[;A_=A_%O?A_W'', затем y/#A-_/#-A/заменяет символы на основе следующего списка (char выше становится char ниже):

#ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_
#$%&'()*+,-./0123456789:;<=>?@A

какие обновления $_содержать $_=<>;$_=$_%2?$_:''. Далее s/[#-}]+/uc/eeзаменяет все символы [#-}]+с uc. Без этого /eeэто будет просто строка uc, но она /eeоценивает содержимое строки дважды. Первая оценка возвращает результат uc, который является заглавной версией, $_но так как не $_содержит буквенных символов, он просто возвращает всю строку, а затем вторая /eснова оценивает строку, которая устанавливает $_либо $_(входное число), либо в ''зависимости от того, или не число нечетное или четное.

Наконец, так как $_теперь содержит то, что мы хотим, мы называем say(что требуется, -Eа не -e), который печатает $_после новой строки.

Альтернативный Perl, 93 байта

Код 92 байта + 1 для -p, который, я чувствую, сделал бы его неконкурентным.

s//_/g;s//uc/e;y/\x09-\x0b/_/;s/____/}[/;s/___/%C]/;s/_/{''H/;y/'{}1CDGH/'-)1-3+--/;s/[#-}]+/uc/ee

Содержит вкладку и вертикальную вкладку в y///, обозначенную как \x09и \x0b.

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

LOGO , 390 46 52 50 байт

[ask    1   se[make]iseq    1-3 cos ?/ask   1[1/sum 1   179]?]

Это список шаблонов, который возвращает входные данные, если входные данные нечетные, и вызывает ошибку, если входные данные четные.

Использование:

show invoke [ask ... (paste code here) ... ] 5

выход

5

так как 5 странно, и

invoke [ask ... (paste code here) ... ] 6

вызовет ошибку, потому что 6 четное.

TI-BASIC, 14 байтов

Input Q
sinֿ¹(gcd(Q²,int(e
Q

Это приводит к ошибке домена (ничего не печатая на домашний экран) на четном числе.

Input Q             Q is a variable with an odd code. We cannot use "Ans" as it's even.

            int(e   floor(e) = 2; "2" is even.
         Q²         Q may be negative, so we square it which preserves parity.
     gcd(Q²,int(e   1 if Q is odd; 2 if Q is even.
sinֿ¹(gcd(Q²,int(e   Error iff Q is even.

Q                   If there was no error, print Q.

Pyth , 14 11 10 9 байт

I + Q_ + K / Q + 3_1KQ 
I! SIcQ + 3_1Q 
I! U + 1_GQ1Q
? И + 1_GQ1k

Тестовый пакет .

Japt , 4 байта

u)çU

Japt использует ISO / IEC 8859-1 , так что это соответствует (в десятичном формате ) 117 41 231 85.

Проверьте это онлайн!

объяснение

Uu)çU   Implicit: U = input integer
Uu)     Return Python-style U % (missing argument = 2). This gives 1 if U is odd, 0 if even.
   çU   Implicitly convert U to a string and repeat it that many times.
        Implicit: output result of last expression

Сначала я попробовал использовать решения p, в основном çс обратными аргументами. Однако, pвыполняет возведение в степень, если его левый аргумент является числом, поэтому нам нужно явно преобразовать его в строку. Это решение оказывается на самом деле короче байта, в дополнение к отсутствию каких-либо нечетных байтов.

постоянный ток , 21 байт

[c]sa?kKKCI-1;1k%1!=a

Десятичный: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

Согласно этому стандартному вводу-выводу, эта программа оставляет ввод в главном стеке, если он нечетный, и в противном случае очищает стек. Это можно подтвердить, добавив команду fотладки в конец программы, как на странице TIO.

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

объяснение

[    # Begin macro definition.
 c   # Clear the main stack.
]sa  # End macro definition and push the macro into register "a".
?k   # Prompt for input and store it into precision parameter "k".
KK   # Push two copies of the input to the main stack.
CI-  # Push C-I = 12-10 = 2 to the main stack  
1;1  # Push the value stored in the first index of array "1" (0 by default) 
     # to the main stack. 
k    # Push 0 into parameter "k" to reset the precision (otherwise the modulus 
     # function will not work correctly).
%    # Push the input (mod 2) to the main stack.
1!=a # If the input (mod 2) does not equal 1, execute the macro in register "a".
f    # OPTIONAL: Output the contents of the main stack.

TI-Basic, 18 байтов

Сохранено 2 байта благодаря lirtosiast

:Prompt Q
:While 5Q/ᴇ1-int(5Q/ᴇ1
:Q

в байтах (+2 новых строки = 3F)

:Prompt Q
 DD     51
:While 5Q/ᴇ1-int(5Q/ᴇ1
 D1    35 3B B1  35 3B  
        51 31     51 31
         83 71     83
:Q
 51

Смотрите http://tibasicdev.wikidot.com/one-byte-tokens

MathGolf , 3 байта

¥{k

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

Используемые байты есть 157, 123, 107.

объяснение

¥     Input modulo 2
 {    Loop that many times
  k   Push input

Баш , 31 байт

read a
[ $[a%2] = 0 ] ||echo $a

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

Объяснение:

read a                   reading the input and define it on the variable a
[ $[a%2] = 0 ]      outputs exit status 0 when a/2 is 0 and exit status 1 if not.
||                           evaluates only when the exit status left of it is 1
echo $a                displays the variable a