Su tarea es simple: escriba un programa que recibe un número entero como entrada y lo emite si era extraño, y no hace nada diferente (no se permite detener). El desafío es que solo puedes usar bytes impares.

Opcionalmente, puede agregar una nueva línea final a la salida.

Este es el código de golf, gana la respuesta más corta en bytes (impares).

Las lagunas estándar están prohibidas. Además, no puede usar versiones de idiomas, que son más recientes que la publicación de este desafío.

Ejemplo de entrada> salida:

13 > 13

42 >

Japt -f , 1 byte

u

utiene un valor de código char de 117.

Intentalo

Lenguage , 645529908926937253684695788965635909332404360034079 9394157991500940492270727190763049448735 1174269748937617561533841898064735499551 2293382937520069758100171520289933829375200697581001715202899

Eso es aproximadamente igual a 2 duodecillones de bytes.

El archivo se traduce en el siguiente programa brainfuck:

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

Toma datos como un código ASCII, con un valor máximo de 256. Utiliza el ajuste.

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

Inspirado en la solución de Bruce Forte , pero ligeramente por debajo del 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

Se toma un único parámetro entero en el EDIregistro, siguiendo la convención de llamada System V AMD64.

Inicialmente, se realiza una copia de este valor y se coloca en EAXpara que pueda devolverse si corresponde. ( LEAse usa en lugar de lo normal MOVporque necesitamos una instrucción con bytes impares).

Luego, el valor en EDIse desplaza a la derecha por 1, lo que coloca el bit desplazado en la bandera de acarreo (CF). Este bit será 0 si el número fue par o 1 si fue impar.

Luego probamos CF utilizando la JNCinstrucción, que se ramificará solo si CF es 0 (es decir, el número fue par). Esto significa que entraremos en un bucle infinito para valores pares. Para valores impares, caemos y EAXse devuelve el valor original (in ).

Sin JNCembargo, hay un pequeño truco con la instrucción: ¡tiene un REPprefijo! Normalmente,REP prefijos solo se usan con instrucciones de cadena, pero como los manuales de Intel y AMD coinciden en que REPse ignoran los prefijos irrelevantes / superfluos / redundantes , arrojamos uno en la instrucción de bifurcación aquí para que tenga 3 bytes de longitud. De esa manera, el desplazamiento relativo que se codifica en la instrucción de salto también es impar. (Y, por supuesto, REPes en sí mismo un prefijo de byte impar).

Gracias a dios RET está codificado usando un byte extraño!

Pruébalo en línea!

En caso de que no piense que devolver el valor si es impar o entrar en un bucle infinito si es par (para que nunca regrese) satisfaga los requisitos de "salida" del desafío, o simplemente desea algo más interesante, aquí hay una función que genera el valor en un puerto serie (pero solo si es extraño, por supuesto).

Código de máquina x86-64 (salida al puerto serie), 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

Lo que hace que esto sea un poco más interesante es que el código hace más , lo que significa que fue más difícil hacerlo todo usando instrucciones que están codificadas usando solo bytes impares. Por supuesto, esto también significa que falla en el golf de código, por lo que es una especie de compensación: ¿desea interesante y desafiante, o quiere corto?

De todos modos, esto usa la OUTinstrucción x86 para escribir en el puerto de E / S 0x3F8, que es el puerto serie COM1 estándar en una PC. La parte divertida, por supuesto, es que todos los puertos de E / S estándar (serie y paralelo) tienen direcciones pares, por lo que no pueden codificarse como inmediatos para la OUTinstrucción o moverse directamente a un registro. Debe inicializar con uno menos que el valor real y luego incrementar el valor en el registro. También está limitado a usar ciertos registros para la manipulación porque necesita registros que están codificados usando bytes impares en la instrucción cuando se usan como operandos.

Además, tuve que inicializar el DXregistro (a través del CXregistro) en la parte superior del bucle, aunque esto solo es necesario si el valor es impar, para asegurar que la JNCinstrucción tenga un desplazamiento impar. Sin embargo, dado que lo que estamos omitiendo es la OUTinstrucción, todo lo que hace este código es desperdiciar ciclos y registrar registros de cero; en realidad no genera nada, por lo que no rompe las reglas.

Finalmente, esta función volverá (después de haber realizado o no la salida al puerto serie) con el valor de entrada restante EAX. Pero eso en realidad no rompe ninguna regla; todas las funciones en lenguaje ensamblador regresarán con un valor en EAX— la pregunta es si es un valor significativo o un valor basura . Eso está determinado por la documentación de la función (esencialmente, devuelve un valor o devuelve void), y en este caso, lo estoy documentando como no devuelve un valor. :-)

No hay un enlace TIO para este, ya que no implementa la salida a los puertos serie. Necesitarás hierro real o imaginación.

Jalea , 2 bytes

ẋḂ

Estos caracteres corresponden a los bytes 0xF7 y 0xBF en la página de códigos de Jelly .

Pruébalo en línea!

05AB1E , 3 bytes

Éi=

El código corresponde a los valores de bytes C9,69,3Do 201,105,61que son todos impares.

Pruébalo en línea!

Explicación

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

MATL , 3 bytes

o?G

MAT utiliza caracteres ASCII, por lo que o?Gse corresponde con bytes (en decimal) 111, 63, 71.

Pruébalo en línea!

Explicación

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]

Pruébalo en línea!

Uso: o 7yiedls 7, o 8entra en un bucle infinito.

El algoritmo real es

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

El primer problema que enfrenté fue la falta de espacio y (, porque una función oque toma un argumento mgeneralmente se define como o m=...o o(m)=.... Sin embargo, descubrí que un comentario en línea también {- some comment -}funciona como delimitador de tokens, por lo que o{--}m=...es posible una definición bajo las reglas dadas. Editar: Ørjan Johansen señaló que se puede usar un carácter de tabulación en lugar de un espacio, ahorrando tres bytes: o m=...

El segundo problema fue la llamada recursiva o(m-2). -2es justo -1-1, pero aquí el truco de comentarios no funciona porque los paréntesis son obligatorios. Solucioné esto dejando que la función funcionara en una lista única que contenía un número: o[m-2]sin embargo, como esta no es una forma estándar de proporcionar información, externalicé el cálculo a una función auxiliar cque funciona en listas y llamadas cdesde las ocuales tiene el formato correcto .

Python REPL, 38 bytes

Toma la entrada como el valor de la expresión anterior usando _. La salida será una cadena (la representación de cadena del entero para impar o la cadena vacía para par).

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

Pruébalo en línea

Para ejecutarlo en un shell real, puede probarlo aquí . Escriba la entrada, presione enter. Pegue el código, presione enter.

Explicación:

Esto tomó un tiempo para darse cuenta. No hay multiplicación, sin ramificación, sin segmentación, sin comas, sin puntos, sin importaciones, sin paréntesis, no exec, no eval, no printy sin funciones. Obtuve una solución trabajando esa salida usando stderr, pero luego me di cuenta de que teníamos que generar el entero real, no solo un valor verdadero / falso.

Uso paréntesis en lugar de paréntesis con [expression][-1]. Simplificando eso convierte el código anterior en '%s'%(['']+[_])[_%(1+1)].

Como no puede haber comas, utilicé la adición de listas para crear ['',_]. Usando el formato de cadena, se obtiene el resultado deseado.

CJam, 6 bytes

q_iY%%

113 95 105 89 37 37

Este programa toma el mod 2 de la entrada (llámelo r ) e imprime cada r ésimo carácter en la cadena de entrada. Si el número de entrada es impar, imprime la cadena completa, pero si se le pide que imprima cada carácter 0, el programa arroja un error.

Pruébalo aquí

Cubix , 23 19 17 bytes

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

¡Intentalo!

@, que finaliza un programa Cubix, es ascii 64, por lo que desafortunadamente esto solo entra en un bucle infinito después de probar la rareza. No hay enlace TIO ya que se agota el tiempo de espera.

= (ascii 61) es un no-op en Cubix.

Esta es una ligera modificación del algoritmo anterior (mismo número de bytes) que realmente funciona para enteros negativos.

Versión de cubo:

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

Algoritmo:

• I (73) : leer en la entrada como número
• 1 (49) : empuje 1
• ) (41) : incremento
• % (37) : toma el mod
• / (47) : girar a la izquierda
• ! (33) : omita la siguiente instrucción si es impar
  • 1;;/; ;es (59): prepara la pila para la salida
  • O (79) : Salida como un número.
  • Luego vuelve a ingresar el algoritmo pero Ilee un 0final de entrada, por lo que tenemos la garantía de ingresar la rama par
• u (117) : giro a la derecha
• ;;;!I : bucle, efectivamente no hacer nada.

Carbón de leña , 9 bytes

¿﹪Ｉθ÷χ⁵→θ

Pruébalo en línea!

Básicamente imprime hacia la derecha la entrada si no es un múltiplo de 10/5 (el ²carácter está incluso en la página de códigos de carbón ). Los caracteres utilizados son:

• ¿: 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 hecho, →casi al final es redundante, pero luego vi que la respuesta tenía que tener una longitud extraña ...

Explicación:

¿      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

Lamentablemente 0x80es par, pero aún funcionó (suponiendo que "no hace nada" significa no volver):

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

Pruébalo en línea!

Mathematica, 20 bytes

Parece ser la primera solución en un lenguaje que no es de golf.

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

En MacintoshChineseTraditionalcodificación de caracteres. \[Divides]es {161, 253}(2 bytes)

Versión alternativa (23 bytes)

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

o (se muestra en Unicode)

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

en Symbolcodificación de caracteres. (use solo caracteres de 1 byte)

La solución define una función g(o Γ) que evalúa la entrada cuando la entrada es impar y literalmente "no hacer nada" (no evalúa) cuando la entrada es par.

Perl, 54 bytes

Requiere -E.

Realmente disfruté este desafío, creo que me gustaría intentar mejorar esta respuesta, pero creo que es lo más corto que puedo hacer por ahora. He estado jugando con estas respuestas por unos días, ¡pero siento que estoy contento con la solución de 54 bytes!

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

Pruébalo en línea!

Explicación

Por defecto, la mayoría de las funciones de cadena de Perl funcionan $_, que está vacía para comenzar.

Primero, s//A_=Y[;A_=A_%O?A_W''/reemplaza la cadena vacía $_con A_=Y[;A_=A_%O?A_W'', luego y/#A-_/#-A/reemplaza los caracteres según la siguiente lista (char arriba se convierte en char debajo):

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

qué actualizaciones $_contener $_=<>;$_=$_%2?$_:''. Luego s/[#-}]+/uc/eereemplaza todos los caracteres [#-}]+con uc. Sin /eeesto, solo sería la cadena uc, pero /eeevalúa el contenido de la cadena dos veces. La primera evaluación devuelve el resultado de uc, que es una versión en mayúscula de, $_pero dado que $_no contiene caracteres alfabéticos, solo devuelve la cadena completa, luego la segunda /eevalúa la cadena nuevamente, que se establece $_en $_(el número de entrada) o'' dependiendo de si No el número es par o impar.

Finalmente, dado que $_ahora contiene lo que queremos, llamamos say(que es lo que requiere en -Elugar de -e) qué impresiones $_seguidas de una nueva línea.

Perl alternativo, 93 bytes

Código de 92 bytes + 1 para -p, que creo que lo haría no competitivo.

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

Contiene una pestaña y una pestaña vertical en el y///, indicado como \x09y \x0b.

Pruébalo en línea!

LOGOTIPO , 390 46 52 50 bytes

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

Esa es una lista de plantillas que devuelve la entrada si la entrada es impar, y causa un error si la entrada es par.

Uso:

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

salida

5

ya que 5 es impar, y

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

causará un error porque 6 es par.

TI-BASIC, 14 bytes

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

Esto arroja un error de dominio (no imprime nada en la pantalla de inicio) en un 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.

Pyth , 14 11 10 9 bytes

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

Banco de pruebas .

Japt , 4 bytes

u)çU

Japt usa ISO / IEC 8859-1 , por lo que corresponde a (en decimal) 117 41 231 85.

¡Pruébelo en línea!

Explicación

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

Primero probé soluciones usando p, que es básicamente çcon argumentos invertidos. Sin embargo, prealiza exponenciación si su argumento izquierdo es un número, por lo que tendríamos que convertirlo explícitamente en una cadena. Esta solución resulta ser en realidad un byte más corto, además de no contener bytes impares.

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

Según este valor predeterminado de IO, este programa deja la entrada en la pila principal si es impar y vacía la pila de lo contrario. Esto se puede confirmar agregando elf comando de depuración al final del programa como es el caso en la página TIO.

Pruébalo en línea!

Explicación

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

Guardado 2 bytes gracias a lirtosiast

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

en bytes (+2 líneas nuevas = 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

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

MathGolf , 3 bytes

¥{k

Pruébalo en línea!

Los bytes utilizados son 157, 123, 107.

Explicación

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

Bash , 31 bytes

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

Pruébalo en línea!

Explicación:

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