Nota: Todavía no ha habido un desafío de prueba de paridad de vainilla (hay uno de C / C ++ pero no permite la posibilidad de usar lenguajes que no sean C / C ++, y otros que no son de vainilla también están en su mayoría cerrados), así que estoy publicando uno.

Dado un número entero positivo, genera su paridad (es decir, si el número es par o impar) en valores verdadero / falso. Puede elegir si los resultados verdaderos corresponden a entradas pares o impares.

Ejemplos

Asumiendo Verdadero / Falso como par e impar (Esto no es obligatorio, puede usar otros valores de Verdad / Falsificación para cada uno), en respuesta:

(Input):(Output)
1:False
2:True
16384:True
99999999:False

Tabla de clasificación

var QUESTION_ID=113448,OVERRIDE_USER=64499;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){var F=function(a){return a.lang.replace(/<\/?a.*?>/g,"").toLowerCase()},el=F(e),sl=F(s);return el>sl?1:el<sl?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

ArnoldC , 299 283 bytes

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0
GET YOUR ASS TO MARS i
DO IT NOW
I WANT TO ASK YOU A BUNCH OF QUESTIONS AND I WANT TO HAVE THEM ANSWERED IMMEDIATELY
GET TO THE CHOPPER i
HERE IS MY INVITATION i
I LET HIM GO 2
ENOUGH TALK
TALK TO THE HAND i
YOU HAVE BEEN TERMINATED

Esto genera 1(que es verdadero) para entradas impares y 0(que es falso) para entradas pares.

Pruébalo en línea!

" Ahora este es el plan " (un intento de explicación)

El código lee la entrada en variable i, la reemplaza con el resultado del módulo 2 y luego la imprime.

IT'S SHOWTIME                                    # BeginMain
HEY CHRISTMAS TREE i                             #   Declare i
YOU SET US UP 0                                  #   SetInitialValue 0
GET YOUR ASS TO MARS i                           #   AssignVariableFromMethodCall i
DO IT NOW                                        #   CallMethod
I WANT TO ASK YOU ... ANSWERED IMMEDIATELY       #   ReadInteger
GET TO THE CHOPPER i                             #   AssignVariable i
HERE IS MY INVITATION i                          #     SetValue i (push i on the stack)
I LET HIM GO 2                                   #     ModuloOperator 2
ENOUGH TALK                                      #   EndAssignVariable
TALK TO THE HAND i                               #   Print i
YOU HAVE BEEN TERMINATED                         # EndMain

brainfuck , 8 bytes

+[,>,]<.

La entrada está en unario. La salida es el 1 (verdadero) para números impares y NUL (falso) para números pares.

Pruébalo en línea!

Cómo funciona

Comenzamos incrementando la celda actual +para poder ingresar al ciclo while [,>,].

En cada iteración, ,lee un byte de STDIN, >avanza a la celda a la derecha y luego ,lee otro byte de STDIN. Cuando se agota la entrada, el intérprete (el que está en TIO, de todos modos) establecerá la celda en NUL . Una vez que eso sucede, la condición del ciclo while ya no se cumple y salimos de ella.

Sea n el entero de entrada. Si hay una cantidad par de bytes de entrada, es decir, si n es par, las primeras n / 2 iteraciones leerán dos 1 's, y la siguiente iteración leerá dos NUL ' s, dejando la cinta de la siguiente manera.

...   1  NUL  NUL
...  49    0    0
                ^

<.retrocede una celda e imprime su contenido, enviando un byte NUL a STDOUT.

Sin embargo, si hay una cantidad impar de bytes de entrada, las primeras (n - 1) / 2 iteraciones leerán dos 1 's, y la siguiente iteración leerá un 1 y un NUL , dejando la cinta de la siguiente manera.

...   1    1  NUL
...  49   49    0
                ^

<ahora retrocederá a una celda que contiene el byte / carácter 1 , que se .imprime.

Mathematica, 4 bytes

OddQ

Da Truepor entradas impares y Falsepor entradas pares, ¿quién sabe?

También hay EvenQ, pero ¿quién querría escribir todo eso?

Taxi , 1,482 1,290 1,063 1,029 1,009 bytes

_{^{Nunca antes había escrito un programa en Taxi y soy un novato en programación en general, por lo que probablemente haya mejores maneras de hacerlo. He comprobado los errores y he logrado jugar un poco al golf probando diferentes rutas que tienen el mismo resultado. Agradezco cualquier y toda revisión.}}

Devuelve 0para pares e 1impares.

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Divide and Conquer.2 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 l 1 l 1 l 2 l.Pickup a passenger going to Divide and Conquer.Go to Divide and Conquer:e 1 l 2 r 3 r 2 r 1 r.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 l 1 l 2 l.Pickup a passenger going to Trunkers.Pickup a passenger going to Equal's Corner.Go to Trunkers:s 1 l.Pickup a passenger going to Equal's Corner.Go to Equal's Corner:w 1 l.Switch to plan "b" if no one is waiting.Pickup a passenger going to Knots Landing.Go to Knots Landing:n 4 r 1 r 2 r 1 l.[a]Pickup a passenger going to The Babelfishery.Go to The Babelfishery:w 1 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 l 1 r.[b]0 is waiting at Starchild Numerology.Go to Starchild Numerology:n 1 r.Pickup a passenger going to Knots Landing.Go to Knots Landing:w 1 r 2 r 1 r 2 l 5 r.Switch to plan "a".

Pruébalo en línea!

Tienes razón, es horrible de leer sin saltos de línea. Aquí hay una versión formateada:

Go to Post Office:w 1 l 1 r 1 l.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:s 1 l 1 r.
Pickup a passenger going to Divide and Conquer.
2 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 l 1 l 1 l 2 l.
Pickup a passenger going to Divide and Conquer.
Go to Divide and Conquer:e 1 l 2 r 3 r 2 r 1 r.
Pickup a passenger going to Cyclone.
Go to Cyclone:e 1 l 1 l 2 l.
Pickup a passenger going to Trunkers.
Pickup a passenger going to Equal's Corner.
Go to Trunkers:s 1 l.
Pickup a passenger going to Equal's Corner.
Go to Equal's Corner:w 1 l.
Switch to plan "b" if no one is waiting.
Pickup a passenger going to Knots Landing.
Go to Knots Landing:n 4 r 1 r 2 r 1 l.
[a]Pickup a passenger going to The Babelfishery.
Go to The Babelfishery:w 1 l.
Pickup a passenger going to Post Office.
Go to Post Office:n 1 l 1 r.
[b]0 is waiting at Starchild Numerology.
Go to Starchild Numerology:n 1 r.
Pickup a passenger going to Knots Landing.
Go to Knots Landing:w 1 r 2 r 1 r 2 l 5 r.
Switch to plan "a".

Aquí está mi mejor intento de explicar la lógica:

Go to Post Office to pick up the stdin value in a string format.
Go to The Babelfishery to convert the string to a number.
Go to Starchild Numerology to pickup the numerical input 2.
Go to Divide and Conquer to divide the two passengers (stdin & 2).
Go to Cyclone to create a copy of the result.
Go to Trunkers to truncate the original to an integer.
Go to Equal's Corner to see if the two passengers are the same.
Equal's Corner returns the first passenger if they're the same (no .5 removal so the stdin was even) or nothing if they're not.
If nothing was returned, it was odd, so go pick up a 0 from Starchild Numerology.
Go to Knots Landing to convert any 0s to 1s and all other numbers to 0s.
Go to The Babelfishery to convert the passenger (either a 1 or 0 at this point) to a string.
Go to Post Office to print that string.
Try and fail to go to Starchild Numerology because the directions are wrong so the program terminates.

No volver al Taxi Garage causa la salida a STDERR, pero estoy de acuerdo con eso .

Retina , 8 bytes

[02468]$

Una respuesta de Retina para entrada decimal. Esta también es una solución simple de expresiones regulares que funciona en casi cualquier sabor de expresión regular. Coincide (e imprime 1) para entradas pares y no coincide (e imprime 0) para entradas impares.

Pruébalo en línea!

Una alternativa, también para 8 bytes, utiliza una etapa de transliteración para convertir todos los dígitos pares a xprimero (porque las etapas de transliteración tienen una función incorporada para los dígitos pares / impares):

T`E`x
x$

Por supuesto, el formato de entrada más corto (incluso más corto que unario ) sería binario en este caso, donde 0$sería suficiente una simple expresión regular de . Pero dado que el desafío es esencialmente encontrar el dígito binario menos significativo, la entrada binaria parece sortear el desafío real.

Python, 11 10 bytes

^{-1 byte gracias a Griffin}

1 .__and__

Pruébalo en línea!
Usando bit a bit and, regresa 0para pares e 1impares

LOLCODE, 67 bytes

HOW DUZ I C YR N
  VISIBLE BOTH SAEM MOD OF N AN 2 AN 0
IF U SAY SO

Función que devuelve WIN(verdadero) si el número es par, de lo contrario (impar) devolveráFAIL (falso).

Llamada con C"123".

MATL , 5 3 bytes

Porque las construcciones son aburridas

:He

Esto genera una matriz de valores distintos de cero (que es verdadero) para entradas pares, y una matriz con un cero en su entrada inferior derecha (que es falsa) para entradas impares.

Pruébalo en línea! El código de pie de página es unif-else rama para ilustrar la veracidad o falsedad del resultado. Eliminar ese pie de página mostrará implícitamente la matriz.

Explicación

Considere la entrada 5como un ejemplo

:     % Implicitly input n. Push row vector [1 2 ... n]
      % STACK: [1 2 3 4 5]
He    % Reshape into a 2-row matrix, padding with zeros if needed
      % STACK: [1 3 5;
                2 4 0]

Java 8, 8 bytes

n->n%2<1

Pruébalo aquí.

Java 7, 30 bytes

Object c(int n){return n%2<1;}

Pruébalo aquí.

Salidas truepara números pares y falsepara números impares

Si 1/0se permitiera en lugar de true/false( no lo es, considerando los números de votos aquí ):

• Java 8 (6 bytes): n->n%2
• Java 7 (25 bytes): int c(int n){return n%2;}

Piet, 15 codeles / 16 bytes

5njaampjhompppam

Intérprete en línea disponible aquí.

Este programa devuelve 0 si la entrada es par y 1 si la entrada es impar.

El texto de arriba representa la imagen. Puede generar la imagen pegándola en el cuadro de texto en la página del intérprete. Por conveniencia, he proporcionado la imagen a continuación donde el tamaño del códel es de 31 píxeles. La cuadrícula está ahí para facilitar la lectura y no forma parte del programa.

Explicación

Este programa utiliza el módulo integrado para determinar si la entrada es par o impar.

Instruction    Δ Hue   Δ Lightness   Stack
------------   -----   -----------   -------
In (Number)    4       2             n
Push [2]       0       1             2, n
Modulo         2       1             n % 2
Out (Number)   5       1             [Empty]
[Exit]         [N/A]   [N/A]         [Empty]

Los códeles azul oscuro en la parte inferior izquierda nunca se visitan y se pueden cambiar a cualquier color que no sea el color de un códec vecino. Elegí el azul oscuro porque creo que se ve bien con el resto del programa. El códec negro superior izquierdo también podría ser blanco, pero no cualquier otro color. Elegí el negro porque creo que se ve mejor.

He proporcionado el programa en forma de imagen y texto, ya que no hay un consenso claro sobre cómo calificar los programas de Piet. Siéntase libre de opinar sobre la meta discusión.

brainfuck , 14 bytes

La entrada y la salida se toman como códigos de caracteres según este meta .
El valor de byte 1 corresponde a números impares y 0 a pares.

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

Pruébalo en línea!

JavaScript, 6 bytes

Una función anónima:

n=>n&1

Alternativamente con la misma longitud:

n=>n%2

Ambos volverán, lo 0|1que debería cumplir el requisito detruthy|falsey valores.

Prueba ambas versiones en línea

Japt , 1 byte

v

Devuelve 1para números pares, 0para impares.

Pruébalo en línea!

Explicación

Una de las características definitorias de Japt es que, a diferencia de la mayoría de los lenguajes de golf, las funciones no tienen aridad fija; es decir, cualquier función puede aceptar cualquier número de argumentos. Esto significa que a veces puedes omitir argumentos y Japt adivinará lo que quieres. ven números es una función que acepta un argumento y devuelve 1si el número es divisible por el argumento, de lo contrario 0. Por ejemplo:

v3

Este programa dará salida 1si la entrada es divisible por 3, y de lo 0contrario. Sucede que el argumento predeterminado es 2, resolviendo así este desafío en un solo byte.

Solución alternativa de 1 byte:

¢

¢convierte la entrada en una cadena de base 2. La -hbandera devuelve el último carácter de la cadena.

Pruébalo en línea!

brainfuck , 12 bytes

,++[>++]>++.

Esto requiere un intérprete con una cinta circular y celdas que se envuelvan. El del TIO tiene 65.536 celdas de 8 bits y cumple los requisitos.

La E / S está en bytes. Las entradas impares se asignan a 0x00 (falso), las entradas pares a un byte distinto de cero (verdad).

Pruébalo en línea!

Cómo funciona

Comenzamos leyendo un byte de entrada con ,y sumando 2 a su valor con ++. Más adelante veremos por qué es necesario incrementar.

Luego, ingresamos un bucle que avanza a la celda de la derecha, le agregamos 2 y repite el proceso a menos que esto establezca el valor de la celda a 0 .

Inicialmente, todas las celdas excepto la celda de entrada mantienen 0 . Si la entrada es impar, agregarle 2 nunca la pondrá a cero. Sin embargo, después de recorrer la cinta 127 veces, la siguiente iteración del ciclo establecerá la celda a la derecha de la celda de entrada en 128 × 2 = 0 (mod 256) , haciendo que el ciclo finalice. >++repite el cuerpo del bucle una vez más, por lo que la siguiente celda también se pone a cero y luego se imprime con ..

Por otro lado, si la entrada es n y n es par, el código antes del bucle establece la celda de entrada a n + 2 . Después de recorrer la cinta (256 - (n - 2)) / 2 = (254 - n) / 2 veces, la celda de entrada alcanzará 0 , y la celda a su derecha mantendrá el valor (254 - n) / 2 × 2 = 254 - n . Después de agregar 2 con >++, .imprimirá 256 - n = -n (mod 256) , que no es cero ya que n no es cero.

Finalmente, tenga en cuenta que el segundo caso imprimiría 258 - n = 2 - n (mod n) si no incrementamos la entrada antes del bucle, ya que se requeriría un bucle más alrededor de la cinta para poner a cero la celda de entrada. Por lo tanto, el programa fallaría para la entrada 2 .

Sinclair ZX81 BASIC 124 bytes 114 bytes 109 bytes 57 50 bytes BASIC tokenizados

Según los comentarios de Adám a continuación, aquí está el último candidato de lanzamiento:

 1 INPUT A
 2 IF NOT A THEN STOP
 3 PRINT A;":";NOT INT A-(INT (INT A/VAL "2")*VAL "2")

Ahora será PRINT 1para pares e 0impares. Cero salidas.

Aquí hay versiones anteriores de la lista simbólica para fines de referencia:

 1 INPUT A
 2 IF NOT A THEN STOP
 3 LET B=INT (INT A/2)
 4 PRINT A;":";NOT INT A-B*2
 5 RUN

Aquí está la lista anterior (v0.01) para que pueda ver las mejoras que he realizado, ya que esta nueva lista no solo es más pequeña, sino que es más rápida:

 1 INPUT A
 2 IF A<1 THEN STOP
 3 LET B=INT (INT A/2)
 4 LET M=1+INT A-B*2
 5 PRINT A;":";
 6 GOSUB M*10
 7 RUN
10 PRINT "TRUE"
11 RETURN
20 PRINT "FALSE"
21 RETURN

Y aquí está v0.02 (usando subcadenas Sinclair):

 1 INPUT A
 2 IF NOT A THEN STOP
 3 LET B=INT (INT A/2)
 4 LET M=1+INT A-B*2
 5 LET C=4*(M=2)
 6 PRINT A;":";"TRUE FALSE"(M+C TO 5+C+(M=2))
 7 RUN

05AB1E , 1 byte

È

Bastante autoexplicativo. Devolucionesa % 2 == 0

Pruébalo en línea!

Retina, 3 bytes

11

La nueva línea final es significativa. Toma entrada en unario. Salidas 1 para números impares, nada para números pares. Pruébalo en línea!

C ++, 25 bytes

template<int v>int o=v&1;

Esto define una plantilla variable ( una construcción similar a una función ) con un valor igual a la operación bit a bit input&1. 0para valores pares, 1para valores impares. El valor se calcula en tiempo de compilación.

Requiere C ++ 14.

Pruébalo en línea!

Pyth, 3 2 bytes

Lo hice. Jugué al golf lo ingobernable. ¡Por una vez, es una solución no trivial que logró obtener ese último byte!

!F

Verdad en valores pares (sin incluir 0, pero eso no es positivo, así que ...).

Explicación:

!    Not
 FQQ Applied to the input (first Q) Q times

Por ejemplo !!2 = !0 = 1, y!!!3 = !!0 = !1 = 0

Mantendré mi biblioteca de soluciones de 3 bytes aquí abajo.

"Hay otra respuesta con múltiples soluciones de 3 bytes, pero está lejos de ser completa. Agreguemos un par más:

@U2

Índices en la lista de forma [0,1]modular, dando valores verdaderos en entradas impares.

}2P

¿Es 2 en la factorización prima de la entrada? (Verdad incluso)

ti2

¿Es el MCD de 2 y la entrada 2? (Verdad incluso)

gx1

¿XOR-ing la entrada con 1 no lo disminuye? (Verdad incluso)

q_F

Básicamente, Q == Q*-1^Qdonde Q es la entrada, pero se realiza a través de un bucle. (Verdad incluso)

_FI

Lo mismo que arriba.

g^_

Se traduce en Q <= -Q^Q(Verdad incluso)

Tenga en cuenta que cualquiera de las soluciones anteriores involucradas gfuncionará <para la verdad falsa).

C #, 8 bytes

n=>n%2<1

Compila a a Func<int, bool>.

O si no se permite una función anónima, este método para 21 bytes:

bool p(int n)=>n%2<1;

Pyth, 3

Esperaba que Pyth tuviera un byte de 1 o 2 bytes incorporado para esto. En cambio, aquí están las mejores soluciones que pude encontrar:

%Q2

o

.&1

o

e.B

TIS-100, 39 bytes

Por supuesto, este es, más precisamente, un programa para la arquitectura del nodo de ejecución básico T21, emulado por el emulador TIS-100.

Le remitiré a esta respuesta para obtener una explicación fantásticamente profunda de la calificación de los programas TIS-100, así como su estructura.

@0
ADD UP
G:SUB 2
JGZ G
MOV ACC ANY

Explicación:

@0          # Indicates that this is node 0
ADD UP      # Gets input and adds it to ACC, the only addressable register in a T-21
G:          # Defines a label called "G"
SUB 2       # Subtracts 2 from ACC
JGZ G       # If ACC is greater than 0, jumps to G
MOV ACC ANY # Sends the value of ACC to the first available neighbor; in this case, output.
            # Implicitly jumps back to the first line

En pseudocódigo, se vería algo así como:

while (true) {
    acc = getIntInput()
    do {
        acc -= 2
    } while (acc > 0)
    print(acc)
}

El T21 no tiene tipos booleanos o valores de verdad / falsedad, por lo que el programa devuelve -1 para números impares y 0 para números pares, a menos que la entrada anterior fuera impar, en cuyo caso devuelve -1 para números pares y 0 para números impares números: si ese hecho lo perturba, esta es una respuesta completa del programa, por lo que puede reiniciar su T21 entre usos.

Jalea , 1 byte

Ḃ

Pruébalo en línea!

Solo otro incorporado.

Para las personas que no conocen Jelly: tiene bastante capacidad para inferir fragmentos de código faltantes, por lo tanto, no hay mucha diferencia sintáctica entre un fragmento, una función y un programa completo; el intérprete agregará automáticamente código para ingresar argumentos apropiados y generar el resultado. Eso es bastante útil cuando se trata de reglas PPCG, que permiten funciones y programas pero no permiten fragmentos. En el enlace TIO, trato esto como una función y lo ejecuto en cada número entero del 1 al 20 inclusive, pero también funciona como un programa completo.

Jalea , 2 bytes

&1

Pruébalo en línea!

También es bastante corto sin el incorporado. (Esto es bit a bit Y con 1.)

7 , 18 caracteres, 7 bytes

177407770236713353

Pruébalo en línea!

7 no tiene nada parecido a una declaración if normal, y tiene más de una forma idiomática de representar un booleano. Como tal, es difícil saber qué cuenta como verdadero y falso, pero este programa utiliza1 para la cadena impar y nula para par (los valores verdadero y falso para Perl, en el que está escrito el 7 intérprete). (Es bastante fácil cambiar esto; la salida impar se especifica antes de los primeros 7, la salida par se especifica entre los primeros dos 7s. Sin embargo, podría necesitar un cambio de formato de salida para manejar otros tipos de salida; utilicé los dos salidas distintas más cortas aquí.)

7 utiliza una codificación octal comprimida en la que tres bytes de origen representan ocho bytes de programa, por lo que 18 caracteres de origen se representan en 7 bytes en el disco.

Explicación

177407770236713353
 77  77     7       Separate the initial stack into six pieces (between the 7s)

        023         Output format string for "output integers; input one integer"
       7   6        Escape the format string, so that it's interpreted as is
             13     Suppress implicit looping
               3    Output the format string (produces input)
                5   Run the following code a number of times equal to the input:
   40                 Swap the top two stack elements, escaping the top one
                 3  Output the top stack element

Al igual que muchos formatos de salida, los "enteros de salida" deshacen cualquier cantidad de niveles de escape antes de la salida; por lo tanto 40, que combinados hacen una operación de intercambio y escape, se pueden usar en lugar de 405una operación de intercambio (que es un intercambio y escape seguido de un escape). Si estaba utilizando un formato de salida que no es estable con respecto al escape, necesitaría el formato completo405 allí. (Por cierto, la razón por la que necesitábamos escapar de la cadena de formato originalmente es que si la primera salida contiene caracteres no representables, automáticamente fuerza el formato de salida 7. Al escapar elimina los caracteres no representables y permite seleccionar el formato 0).

De los seis elementos iniciales de la pila, el más alto es el programa principal (y lo consume 13lo primero que se ejecuta); el segundo es el 023que selecciona el formato de salida y solicita entrada, y es consumido por esa operación; el tercero se consume como un efecto secundario de la 3operación (se usa para descartar elementos de la pila además de producir resultados); el cuarto, 40es el cuerpo del bucle (y consumido por el5 que ejecuta el bucle); y el quinto y sexto se intercambian varias veces igual a la entrada (por lo tanto, terminan en sus posiciones originales si la entrada es par, o en las posiciones de los demás si la entrada es impar).

Puede jugar golf con un personaje cambiando el líder 177a 17(y confiando en un sexto elemento de pila vacío implícito), pero eso cambiaría la paridad de las salidas a un método menos idiomático que impar-es-verdadero, y no guarda un byte completo (la fuente aún tiene siete bytes de longitud). Como tal, decidí usar la forma más natural de salida, ya que no tiene peor puntaje.

Brain-Flak , 22 20 bytes

Aquí hay otra respuesta genial en Brain-Flak que también deberías consultar

(({})){({}[()]<>)}<>

Pruébalo en línea!

Explicación

Para comenzar, haremos una copia de nuestra entrada con (({})).

La copia inferior servirá como un valor verdadero, mientras que la superior se utilizará para el procesamiento real. Esto se hace porque necesitamos que la entrada esté en la parte superior y es bastante engorroso (¡dos bytes adicionales!) Poner un 1 debajo de la entrada.

Entonces comenzamos un ciclo {({}[()]<>)} . Esta es una modificación simple en el ciclo de cuenta regresiva estándar que cambia las pilas cada vez que disminuye.

Como hay dos pilas, un número par terminará en la parte superior de la pila en la que comenzó, mientras que un número impar terminará en la pila opuesta. El valor copiado permanecerá en su lugar y, por lo tanto, actuará como un marcador de dónde comenzamos.

Una vez que hayamos terminado con el bucle, tenemos un 0 (originalmente la entrada) sentado encima de un valor verdadero (la copia de la entrada) o falso (pila vacía). También tenemos el valor opuesto en la otra pila.

Necesitamos deshacernos de lo 0que puede eliminarse con {}o <>. Sin embargo, ambos parecen funcionar y dan resultados opuestos.{} causa un valor falso para cero, cuando debería devolver la verdad. Esto se debe a que nuestro valor "verdadero" es una copia de la entrada y cero es la única entrada que puede ser falsa.

Este problema se resuelve al finalizar el programa con <>.

(Por supuesto, de acuerdo con la especificación, técnicamente no tengo que admitir cero, pero doy dos opciones, preferiría admitirlo)

BitCycle , 19 17 16 bytes

?ABv
 / \ <
!+ <

Pruébalo en línea!

Argh, siento que hay una solución de 18 bytes flotando fuera del alcance :( ¡Jaja! -2 bytes usando a +para redirigir bits que provienen de diferentes direcciones.

Esto todavía parece que hay demasiado espacio en blanco (¡un total de 6 bytes!)

Explicación:

?ABv    Feed unary input into the main loop
 / \    Every loop, two bits will be removed from the input
 + <

 / \ <  When we reach the point where there is either one or no bits of input left
!+      If one, it will reflect off both /\s and turn left at the +
        And output, otherwise the program ends since no more bits are moving

Lote, 16 bytes

@cmd/cset/a%1%%2

Salidas 1 para impar, 0 para par. La versión alternativa de 16 bytes también funciona en números negativos:

@cmd/cset/a"%1&1

17 bytes a la salida 1 para pares, 0 para impares:

@cmd/cset/a"~%1&1

Excel, 10 bytes

=MOD(A1,2)

O:

=ISODD(A1)

Para salida de:

JSFuck , 9685 9384 6420 bytes

JSFuck es un estilo de programación educativo y esotérico basado en las partes atómicas de JavaScript. Utiliza solo seis caracteres diferentes para escribir y ejecutar código.

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+[!+[]+!+[]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]]

Salidas 1 para impar y 0 para par.

Pruébalo en línea!

alert([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+(+!+[]+(!+[]+[])[!+[]+!+[]+!+[]]+[+!+[]]+[+[]]+[+[]])+[])[!+[]+!+[]]+(!![]+[])[+[]]+(+(+!+[]+[+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+!+[]])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]+!+[]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+[!+[]+!+[]])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[!+[]+!+[]]](prompt()))

Bash + bc, 21 14 11 9 bytes

bc<<<$1%2

Lee la entrada de la línea de comandos, expande el valor en la cadena con la operación mod y canaliza la cadena a bc para el cálculo. Salidas 1 para impar, 0 para par.

Casos de prueba:

(Input):(Output)
1:1
2:0
16384:0
99999999:1

Edición: ahorró 7 bytes gracias a @ ais523
Edición 2: guardó otros 3 bytes gracias a @Dennis
Edición 3: guardó otros dos gracias a @Dennis