Sua tarefa é simples: escreva um programa que receba um número inteiro como entrada e o produza se for ímpar e não faça nada de outra forma (não é permitido interromper). O desafio é que você só pode usar bytes ímpares.

Opcionalmente, você pode anexar uma nova linha à direita na saída.

Isso é código-golfe, a resposta mais curta em bytes (ímpares) vence.

Lacunas padrão são proibidas. Além disso, você não pode usar versões de idiomas mais recentes que a publicação deste desafio.

Exemplo de entrada> saída:

13 > 13

42 >

Japt -f , 1 byte

u

utem um valor de código de char de 117.

Tente

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069756300171520285993

Isso é aproximadamente igual a 2 duodecilhões de bytes.

O arquivo é traduzido para o seguinte programa brainfuck:

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

Recebe a entrada como um código ASCII, com um valor máximo de 256. Usa quebra automática.

Código da máquina x86-64, 8 bytes

Inspirado na solução de Bruce Forte , mas um pouco abaixo do par. :-)

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

Um único parâmetro inteiro é obtido no EDIregistro, seguindo a convenção de chamada do System V AMD64.

Uma cópia desse valor é feita inicialmente e inserida EAXpara que possa ser retornada, se apropriado. ( LEAé usado em vez do normal MOVporque precisamos de uma instrução com bytes ímpares.)

Em seguida, o valor in EDIé deslocado para a direita por 1, o que coloca o bit deslocado no sinalizador de transporte (CF). Este bit será 0 se o número for par ou 1 se for ímpar.

Em seguida, testamos CF usando a JNCinstrução, que será ramificada apenas se CF for 0 (ou seja, o número foi par). Isso significa que entraremos em um loop infinito para valores pares. Para valores ímpares, nós caímos e o valor original (in EAX) é retornado.

Há um pouco de truque com a JNCinstrução - ela tem um REPprefixo! Normalmente, os REPprefixos são usados ​​apenas com instruções de string, mas como os manuais da Intel e da AMD concordam que REPprefixos irrelevantes / supérfluos / redundantes são ignorados, lançamos um na instrução de ramificação aqui para torná-lo com 3 bytes de comprimento. Dessa forma, o deslocamento relativo que é codificado na instrução de salto também é ímpar. (E claro,REP é é um prefixo de bytes ímpares).

Graças a Deus RETé codificado usando um byte ímpar!

Experimente online!

Caso você não pense em retornar o valor se for ímpar ou entrar em um loop infinito se for par (para que você nunca retorne) satisfaça os requisitos de "saída" do desafio, ou apenas deseje algo mais interessante, aqui está uma função que gera o valor para uma porta serial (mas apenas se for ímpar, é claro).

Código da máquina x86-64 (saída para porta serial), 17 bytes

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

O que torna isso um pouco mais interessante é que o código faz mais , o que significa que foi mais desafiador fazer tudo isso usando instruções que são codificadas usando apenas bytes ímpares. Obviamente, isso também significa que ele falha no código de golfe, então é uma espécie de compensação - você quer ser interessante e desafiador ou quer ser breve?

De qualquer forma, isso usa a OUTinstrução x86 para gravar na porta de E / S 0x3F8, que é a porta serial COM1 padrão em um PC. A parte divertida, é claro, é que todas as portas de E / S padrão (serial e paralela) têm endereços pares, de modo que não podem simplesmente ser codificadas como imediatas para a OUTinstrução ou movidas diretamente para um registrador. Você precisa inicializar com um a menos que o valor real e depois incrementar o valor no registro. Você também está limitado ao uso de certos registradores para a manipulação, porque precisa de registradores codificados usando bytes ímpares na instrução quando usados ​​como operandos.

Além disso, tive que inicializar o DXregistrador (via CXregistrador) na parte superior do loop, mesmo que isso seja necessário apenas se o valor for ímpar, para garantir que a JNCinstrução tenha um deslocamento ímpar. No entanto, como o que estamos pulando é a OUTinstrução, todo esse código é desperdício de ciclos e registros de arranhões; Na verdade, não saída de qualquer coisa, para que ele não quebrar as regras.

Finalmente, esta função retornará (depois de ter feito ou não a saída para a porta serial) com o valor de entrada deixado em EAX. Mas isso realmente não quebra nenhuma regra; todas as funções na linguagem assembly retornam com um valor em EAX- a questão é apenas se é um valor significativo ou um valor de lixo . Isso é determinado pela documentação da função (essencialmente, ela retorna um valor ou retorna void) e, neste caso, estou documentando como não retornando um valor. :-)

Nenhum link TIO para este, pois ele não implementa saída para portas seriais. Você precisará de ferro de verdade ou imaginação.

Geléia , 2 bytes

ẋḂ

Esses caracteres correspondem aos bytes 0xF7 e 0xBF na página de código do Jelly .

Experimente online!

05AB1E , 3 bytes

Éi=

O código corresponde aos valores dos bytes C9,69,3Dou 201,105,61que são todos ímpares.

Experimente online!

Explicação

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

MATL , 3 bytes

o?G

MATL utiliza caracteres ASCII, de modo que o?Gcorresponde aos bytes (decimais) 111, 63, 71.

Experimente online!

Explicação

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

Haskell , 36 33 bytes

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

Experimente online!

Uso: o 7yiedls 7, o 8entra em um loop infinito.

O algoritmo real é

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

O primeiro problema que enfrentei foi a falta de espaço e (, porque uma função oque recebe um argumento mé geralmente definida como o m=...ou o(m)=.... No entanto, descobri que um comentário embutido também {- some comment -}funciona como delimitador de token, portanto, uma definição o{--}m=...é possível sob as regras fornecidas. Edit: Ørjan Johansen apontou que é possível usar um caractere de tabulação em vez de um espaço, economizando três bytes: o m=...

O segundo problema foi a chamada recursiva o(m-2). -2é justo -1-1, mas aqui o truque de comentário não funciona porque os parênteses são necessários. Corrigi isso deixando a função funcionar em uma lista singleton contendo um número: o[m-2]no entanto, como essa não é uma maneira padrão de fornecer entrada, terceirizei o cálculo para uma função auxiliar cque funciona em listas e chamadas a cpartir das oquais tem o formato correto .

Python REPL, 38 bytes

Recebe a entrada como o valor da expressão anterior usando _. A saída será uma sequência (a representação da sequência inteira para ímpar ou a sequência vazia para par).

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

Experimente online

Para executá-lo em um shell real, você pode experimentá-lo aqui . Digite a entrada, pressione enter. Cole o código, pressione enter.

Explicação:

Demorou um pouco para descobrir. Não há multiplicação, ramificação, fatias, vírgulas, nem pontos, nem importações, parênteses, não exec, não eval, não printe funções. Eu tenho uma solução trabalhando nessa saída usando stderr, mas então percebi que tínhamos que produzir o número inteiro real, não apenas um valor de verdade / falsey.

Eu uso colchetes no lugar de parênteses com [expression][-1]. Simplificando que transforma o código acima em '%s'%(['']+[_])[_%(1+1)].

Como não pode haver vírgulas, usei a adição de lista para criar ['',_]. Usando a formatação de string, o resultado desejado é obtido.

CJam, 6 bytes

q_iY%%

113 95 105 89 37 37

Este programa pega o mod 2 da entrada (chame-o de r ) e imprime cada r- ésimo caractere na string de entrada. Se o número de entrada for ímpar, ele imprime toda a string, mas, se solicitado a imprimir todos os caracteres 0, o programa gera um erro.

Experimente aqui

Cubix , 23 19 17 bytes

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

Tente!

@, que finaliza um programa Cubix, é ascii 64, então, infelizmente, isso realmente entra em um loop infinito após o teste de estranheza. Nenhum link TIO, pois o tempo limite será excedido.

= (ascii 61) é um no-op no Cubix.

Essa é uma pequena modificação do algoritmo anterior (mesmo número de bytes) que realmente funciona para números inteiros negativos.

Versão do cubo:

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

Algoritmo:

• I (73) : ler na entrada como número
• 1 (49) : push 1
• ) (41) : incremento
• % (37) : pegue o mod
• / (47) : vire a esquerda
• ! (33) : pula a próxima instrução se ímpar
  • 1;;/; ; é (59) : prepara a pilha para saída
  • O (79) : Saída como um número.
  • Em seguida, ele entra novamente no algoritmo, mas Ilê um 0para o final da entrada, por isso temos a garantia de inserir o ramo par
• u (117) : inversão de marcha à direita
• ;;;!I : loop, efetivamente não fazendo nada.

Carvão , 9 bytes

¿﹪Ｉθ÷χ⁵→θ

Experimente online!

Basicamente, imprime a entrada à direita, se não for um múltiplo de 10/5 (o ²caractere está na página de código do carvão vegetal ). Os caracteres usados ​​são:

• ¿: código BF.
• ﹪: código A5.
• Ｉ: código C9.
• θ: código F1.
• ÷: código AF.
• χ: código E3.
• ⁵: código B5.
• →: código 13.

De fato, o →fim do fim é redundante, mas então eu vi que a resposta tinha que ter um comprimento estranho ...

Explicação:

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

código de máquina x86_64 (Linux), 12 11 bytes

Infelizmente 0x80é par, mas ainda funcionou (supondo que "não faz nada" significa não retornar):

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 byte, obrigado @CodyGray!

Experimente online!

Mathematica, 20 bytes

Parece ser a primeira solução em linguagem não-golfe.

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

Na MacintoshChineseTraditionalcodificação de caracteres. \[Divides]é {161, 253}(2 bytes)

Versão alternativa (23 bytes)

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

ou (mostrado em Unicode)

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

na Symbolcodificação de caracteres. (use apenas caracteres de 1 byte)

A solução define uma função g(ou Γ) que é avaliada para entrada quando a entrada é ímpar e literalmente "não faz nada" (não avalia) quando a entrada é par.

Perl, 54 bytes

Requer -E.

Eu realmente gostei desse desafio, acho que gostaria de tentar melhorar essa resposta, mas acho que esse pode ser o mais curto que posso fazer por enquanto. Estou brincando com essas respostas há alguns dias, mas sinto que estou feliz com a solução de 54 bytes!

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

Experimente online!

Explicação

Por padrão, a maioria das funções de string do Perl funciona $_, que está vazia para iniciar.

Primeiro, s//A_=Y[;A_=A_%O?A_W''/substitui a sequência vazia por $_e A_=Y[;A_=A_%O?A_W'', em seguida, y/#A-_/#-A/substitui os caracteres com base na seguinte lista (o caractere acima se torna o caractere abaixo):

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

quais atualizações $_devem conter $_=<>;$_=$_%2?$_:''. Em seguida, s/[#-}]+/uc/eesubstitui todos os caracteres [#-}]+por uc. Sem /eeisso, seria apenas a string uc, mas /eeavalia o conteúdo da string duas vezes. A primeira avaliação retorna o resultado de uc, que é uma versão em maiúscula, $_mas como $_não contém caracteres alfabéticos, isso retorna a sequência inteira, então a segunda /eavalia a sequência novamente, que define $_como $_(o número de entrada) ou ''depende de se não o número é ímpar ou par.

Finalmente, como $_agora contém o que queremos, chamamos say(que é o que requer, em -Evez de -e) quais impressões são $_seguidas por uma nova linha.

Perl alternativo, 93 bytes

Código de 92 bytes + 1 para -p, o que acho que o tornaria não competitivo.

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

Contém uma guia e uma guia vertical na y///, indicada como \x09e \x0b.

Experimente online!

LOGO , 390 46 52 50 bytes

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

Essa é uma lista de modelos que retorna a entrada se a entrada for ímpar e causa um erro se a entrada for par.

Uso:

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

saída

5

já que 5 é ímpar e

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

causará um erro porque 6 é par.

TI-BASIC, 14 bytes

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

Isso gera um erro de domínio (imprimindo nada na tela inicial) em um número par.

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.

Pitão , 14 11 10 9 bytes

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

Conjunto de teste .

Japonês , 4 bytes

u)çU

Japt usa ISO / IEC 8859-1 , portanto, isso corresponde a (em decimal) 117 41 231 85.

Teste online!

Explicação

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

Primeiro tentei soluções usando p, que é basicamente çcom argumentos invertidos. No entanto, pexecuta exponenciação se o argumento esquerdo for um número, portanto, precisaríamos convertê-lo explicitamente em uma string. Essa solução acaba sendo um byte mais curto, além de não conter bytes ímpares.

dc , 21 bytes

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

Decimal: 91 99 93 115 97 63 107 75 75 67 73 45 49 59 49 107 37 49 33 61 97

Conforme esse padrão de E / S, este programa deixa a entrada na pilha principal se for ímpar e esvazia a pilha caso contrário. Isso pode ser confirmado adicionando o fcomando debug ao final do programa, como é o caso na página do TIO.

Experimente online!

Explicação

[    # 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 bytes

Economizou 2 bytes graças a lirtosiast

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

em bytes (+2 novas linhas = 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

Consulte http://tibasicdev.wikidot.com/one-byte-tokens

MathGolf , 3 bytes

¥{k

Experimente online!

Os bytes usados ​​são 157, 123, 107.

Explicação

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

Bash , 31 bytes

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

Experimente online!

Explicação:

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