Nota: non esiste ancora una sfida del test di parità alla vaniglia (ce n'è una C / C ++ ma che non consente di usare lingue diverse da C / C ++, e anche altre non-vanilla sono per lo più chiuse), quindi sto postando uno.

Dato un numero intero positivo, emette la sua parità (cioè se il numero è pari o dispari) in valori di verità / falsa. Puoi scegliere se i risultati veritieri corrispondono a input pari o dispari.

Esempi

Supponendo Vero / Falso come pari e dispari (ciò non è necessario, è possibile utilizzare altri valori di Verità / Falsia per ciascuno), in modo reattivo:

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

Classifica

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 byte

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

Questo produce 1(che è vero) per input dispari e 0(che è falso) per input pari.

Provalo online!

" Ora questo è il piano " (Un tentativo di spiegazione)

Il codice legge l'input in variabile i, lo sostituisce con il risultato di modulo 2 e quindi lo stampa.

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 byte

+[,>,]<.

L'input è in unario. L'output è 1 (verità) per i numeri dispari e NUL (falsa) per i numeri pari.

Provalo online!

Come funziona

Iniziamo incrementando la cella corrente con +per poter entrare nel ciclo while [,>,].

In ogni iterazione, ,legge un byte da STDIN, >avanza alla cella a destra, quindi ,legge un altro byte da STDIN. Quando l'input è esaurito, l'interprete (quello su TIO, comunque) imposterà invece la cella su NUL . Una volta che ciò accade, la condizione del ciclo while non è più soddisfatta e ne usciamo.

Sia n il numero intero di input. Se esiste una quantità pari di byte di input, ovvero se n è pari, le prime n / 2 iterazioni leggeranno due 1 e la successiva iterazione leggerà due NUL , lasciando il nastro come segue.

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

<.retrocede di una cella e ne stampa il contenuto, inviando un byte NUL a STDOUT.

Tuttavia, se esiste una quantità dispari di byte di input, la prima (n - 1) / 2 iterazioni leggerà due 1 ', e la successiva iterazione leggerà uno 1 e uno NUL , lasciando il nastro come segue.

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

<ora retrocede in una cella che contiene il byte / carattere 1 , che .stampa.

Mathematica, 4 byte

OddQ

Dà Trueper input dispari e Falseper input pari, chi lo sapeva?

C'è anche EvenQ, ma chi vorrebbe scrivere tutto questo?

Taxi , 1.482 1.290 1.063 1.029 1.009 byte

_{^{Non ho mai scritto un programma in Taxi prima e sono un novizio in programmazione per generale, quindi probabilmente ci sono modi migliori per farlo. Ho controllato gli errori e sono riuscito a giocarci un po 'provando percorsi diversi che hanno lo stesso risultato. Accolgo con favore qualsiasi revisione.}}

Restituisce 0per pari e 1dispari.

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".

Provalo online!

Hai ragione, è terribile da leggere senza interruzioni di riga. Ecco una versione formattata:

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".

Ecco il mio miglior tentativo di spiegare la logica:

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.

Non tornare al Taxi Garage provoca l'output a STDERR, ma sto bene .

Retina , 8 byte

[02468]$

Una risposta Retina per l'input decimale. Questa è anche una semplice soluzione regex che funziona in quasi tutti i gusti regex. Corrisponde (e stampa 1) per input pari e non corrisponde (e stampa 0) per input dispari.

Provalo online!

Un'alternativa, anche per 8 byte, utilizza una fase di traslitterazione per trasformare in xprimo piano tutte le cifre pari (poiché le fasi di traslitterazione hanno un built-in per le cifre pari / dispari):

T`E`x
x$

Naturalmente, il formato di input più breve (anche più breve di quello unario ) sarebbe binario in questo caso, dove 0$sarebbe sufficiente una semplice regex di . Ma poiché la sfida consiste essenzialmente nel trovare la cifra binaria meno significativa, l'input binario sembra eludere la sfida effettiva.

Python, 11 10 byte

^{-1 byte grazie a Griffin}

1 .__and__

Provalo online!
Usando bit a bit and, ritorna 0per pari e 1dispari

LOLCODE, 67 byte

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

Funzione che restituisce WIN(vero) se il numero è pari, altrimenti (dispari) restituirà FAIL(falso).

Chiama con C"123".

MATL , 5 3 byte

Perché i builtin sono noiosi

:He

Questo genera una matrice di valori diversi da zero (che è veritiero) per un input pari e una matrice con uno zero nella sua voce in basso a destra (che è falsa) per un input dispari.

Provalo online! Il codice piè di pagina è unif-elseramo per illustrare la veridicità o la falsità del risultato. La rimozione di quel piè di pagina mostrerà implicitamente la matrice.

Spiegazione

Considera l'input 5come esempio

:     % 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 byte

n->n%2<1

Provalo qui.

Java 7, 30 byte

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

Provalo qui.

Uscite trueper numeri pari e falseper numeri dispari

Se 1/0fosse consentito invece di true/false( non lo è, considerando il numero di voti qui ):

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

Piet, 15 codici / 16 byte

5njaampjhompppam

Interprete online disponibile qui.

Questo programma restituisce 0 se l'ingresso è pari e 1 se l'ingresso è dispari.

Il testo sopra rappresenta l'immagine. È possibile generare l'immagine incollandola nella casella di testo nella pagina dell'interprete. Per comodità, ho fornito l'immagine qui sotto in cui la dimensione del codice è di 31 pixel. La griglia è lì per la leggibilità e non fa parte del programma.

Spiegazione

Questo programma utilizza il modulo incorporato per determinare se l'input è pari o dispari.

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]

I codici blu scuro in basso a sinistra non sono mai visitati e possono essere cambiati in qualsiasi colore diverso da un colore di un codice vicino. Ho scelto il blu scuro perché penso che sia bello con il resto del programma. Il codice nero in alto a sinistra potrebbe anche essere bianco, ma non di qualsiasi altro colore. Ho scelto il nero perché penso che sia più bello.

Ho fornito il programma sia in forma di immagine che in forma di testo in quanto non esiste un chiaro consenso su come assegnare un punteggio ai programmi Piet. Sentiti libero di approfondire la meta discussione.

Brainfuck , 14 byte

L'input e l'output sono presi come codici carattere secondo questo meta .
Il valore byte 1 corrisponde a numeri dispari e 0 a pari.

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

Provalo online!

JavaScript, 6 byte

Una funzione anonima:

n=>n&1

In alternativa con la stessa lunghezza:

n=>n%2

Entrambi restituiranno 0|1che dovrebbe soddisfare il requisito per i truthy|falseyvalori.

Prova entrambe le versioni online

Japt , 1 byte

v

Restituisce 1per numeri pari, 0per dispari.

Provalo online!

Spiegazione

Una delle caratteristiche distintive di Japt è che, diversamente dalla maggior parte dei linguaggi del golf, le funzioni non hanno un'arità fissa; vale a dire, qualsiasi funzione può accettare qualsiasi numero di argomenti. Ciò significa che a volte puoi tralasciare gli argomenti e Japt indovinerà ciò che desideri. vsui numeri è una funzione che accetta un argomento e restituisce 1se il numero è divisibile per l'argomento, altrimenti 0. Per esempio:

v3

Questo programma verrà emesso 1se l'ingresso è divisibile per 3 e in caso 0contrario. Accade così che l'argomento predefinito sia 2, risolvendo così questa sfida in un singolo byte.

Soluzione alternativa a 1 byte:

¢

¢converte l'input in una stringa base-2. Il -hflag restituisce l'ultimo carattere della stringa.

Provalo online!

Brainfuck , 12 byte

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

Ciò richiede un interprete con un nastro circolare e celle che si avvolgono. Quello su TIO ha 65.536 celle a 8 bit e soddisfa i requisiti.

L'I / O è in byte. Gli input dispari vengono mappati su 0x00 (falsy), gli input pari su un byte diverso da zero (verità).

Provalo online!

Come funziona

Iniziamo leggendo un byte di input con ,e aggiungendo 2 al suo valore con ++. Vedremo in seguito perché è necessario l'incremento.

Quindi, inseriamo un ciclo che avanza alla cella a destra, ne aggiungiamo 2 e ripete il processo a meno che questo non imposti il ​​valore della cella su 0 .

Inizialmente, tutte le celle tranne la cella di input contengono 0 . Se l'ingresso è dispari, aggiungendo 2 ad esso non si azzererà mai. Tuttavia, dopo aver eseguito il loop attorno al nastro 127 volte, la successiva iterazione del loop imposterà la cella a destra della cella di input su 128 × 2 = 0 (mod 256) , causando la fine del loop. >++ripete il corpo del loop ancora una volta, quindi anche la cella successiva viene azzerata e quindi stampata con ..

D'altra parte, se l'ingresso è n e n è pari, il codice prima del ciclo imposta la cella di ingresso su n + 2 . Dopo aver fatto il giro del nastro (256 - (n - 2)) / 2 = (254 - n) / 2 volte, la cella di input raggiungerà 0 e la cella alla sua destra manterrà il valore (254 - n) / 2 × 2 = 254 - n . Dopo aver aggiunto 2 con >++, .stamperà 256 - n = -n (mod 256) , che è diverso da zero poiché n è diverso da zero.

Infine, nota che il secondo caso stamperebbe 258 - n = 2 - n (mod n) se non incrementassimo l'input prima del loop, poiché sarebbe necessario un altro loop attorno al nastro per azzerare la cella di input. Il programma fallirebbe quindi per l'ingresso 2 .

Sinclair ZX81 BASIC 124 byte 114 byte 109 byte 57 50 byte BASIC tokenizzati

Secondo i commenti di Adám di seguito, ecco l'ultima candidata al rilascio:

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

Ora lo sarà PRINT 1anche e0 dispari. Zero uscite.

Ecco le versioni precedenti dell'elenco simbolico a scopo di riferimento:

 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

Ecco il vecchio elenco (v0.01) in modo che tu possa vedere i miglioramenti che ho apportato poiché non solo questo nuovo elenco è più piccolo, ma è più veloce:

 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

Ed ecco la v0.02 (usando le stringhe secondarie di 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

È

Abbastanza auto-esplicativo. ritornaa % 2 == 0

Provalo online!

Retina, 3 byte

11

La nuova riga finale è significativa. Riceve input in unario. Emette 1 per numeri dispari, niente per numeri pari. Provalo online!

C ++, 25 byte

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

Questo definisce un modello di variabile ( un costrutto simile a una funzione ) con valore uguale all'operazione bit a bit input&1. 0per valori pari,1 per valori dispari. Il valore viene calcolato in fase di compilazione.

Richiede C ++ 14.

Provalo online!

Pyth, 3 2 byte

L'ho fatto. Ho giocato a golf con il non golfista. Per una volta, è una soluzione non banale che è riuscita a ottenere l'ultimo byte!

!F

Verità su valori pari (escluso 0, ma non è positivo quindi ...).

Spiegazione:

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

Ad esempio !!2 = !0 = 1, e!!!3 = !!0 = !1 = 0

Terrò la mia libreria di soluzioni a 3 byte qui sotto.

"C'è un'altra risposta con più soluzioni a 3 byte, ma è tutt'altro che completa. Aggiungiamo un altro paio:

@U2

[0,1]Indica l'elenco in modo modulare, fornendo valori veritieri su input dispari.

}2P

2 è nella scomposizione in fattori primi dell'input? (Veramente su pari)

ti2

Il GCD è 2 e l'ingresso 2? (Veramente su pari)

gx1

XOR-ing l'ingresso con 1 non lo diminuisce? (Veramente su pari)

q_F

Fondamentalmente Q == Q*-1^Qdove Q è l'input, ma fatto attraverso un ciclo. (Veramente su pari)

_FI

Come sopra.

g^_

Si traduce in Q <= -Q^Q(Verità in pareggio)

Nota che una qualsiasi delle soluzioni di cui sopra gfunzionerà con la <verità falsa capovolta.)

C #, 8 byte

n=>n%2<1

Compila per a Func<int, bool>.

O se una funzione anonima è vietata, questo metodo per 21 byte:

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

Pyth, 3

Mi aspettavo che Pyth avesse un built-in da 1 o 2 byte per questo. Invece ecco le migliori soluzioni che ho potuto trovare:

%Q2

o

.&1

o

e.B

TIS-100, 39 byte

Naturalmente, questo è, più precisamente, un programma per l'architettura del nodo di esecuzione di base T21, emulato dall'emulatore TIS-100.

Ti farò riferimento a questa risposta per una spiegazione straordinariamente approfondita del punteggio per i programmi TIS-100, nonché della loro struttura.

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

Spiegazione:

@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

In pseudocodice, sarebbe simile a:

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

Il T21 non ha tipi booleani o valori di verità / falsa, quindi il programma restituisce -1 per i numeri dispari e 0 per i numeri pari, a meno che l'input precedente non sia dispari, nel qual caso restituisce -1 per i numeri pari e 0 per i numeri dispari numeri - se questo fatto ti disturba, questa è una risposta a programma completo, quindi puoi semplicemente riavviare il T21 tra gli usi.

Gelatina , 1 byte

Ḃ

Provalo online!

Solo un altro built-in.

Per le persone che non conoscono Jelly: ha abbastanza capacità di dedurre frammenti di codice mancanti, quindi non c'è molta differenza sintattica tra uno snippet, una funzione e un programma completo; l'interprete aggiungerà automaticamente il codice per inserire argomenti appropriati e produrre il risultato. È abbastanza utile quando si ha a che fare con le regole PPCG, che consentono funzioni e programmi ma non consentono gli snippet. Nel collegamento TIO, lo sto trattando come una funzione e lo eseguo su ogni numero intero compreso tra 1 e 20 inclusi, ma funziona anche come un programma completo.

Gelatina , 2 byte

&1

Provalo online!

È piuttosto corto senza anche incorporato. (Questo è bit-AND con 1.)

7 , 18 caratteri, 7 byte

177407770236713353

Provalo online!

7 non ha nulla che assomigli a un'istruzione if normale e ha più di un modo idiomatico per rappresentare un valore booleano. Come tale, è difficile sapere cosa conta come verità e falsità, ma questo programma usa1 per pari e la stringa nulla per pari (i valori di verità e falsità per Perl, in cui è scritto l'interprete 7). (È abbastanza facile cambiarlo; l'output dispari è specificato prima dei primi 7, l'output pari è specificato tra i primi due 7. Potenzialmente potrebbe essere necessario un cambio di formato di output per gestire altri tipi di output; Ho usato i due uscite distinte più brevi qui.)

7 utilizza una codifica ottale compressa in cui tre byte di origine rappresentano otto byte di programma, quindi 18 caratteri di origine sono rappresentati in 7 byte su disco.

Spiegazione

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

Come molti formati di output, gli "interi di output" annullano qualsiasi numero di livelli di escape prima dell'output; così 40, che combinano un'operazione di scambio-e-fuga, possono essere usate al posto di 405un'operazione di scambio (che è un cambio-e-fuga seguito da un unescape). Se si stesse utilizzando un formato di output non stabile rispetto all'evasione, sarebbe necessario il pieno405 lì. (Per inciso, il motivo per cui inizialmente dovevamo sfuggire alla stringa di formato è che se il primo output contiene caratteri non rappresentabili, forza automaticamente il formato di output 7. L'escaping rimuove i caratteri non rappresentabili e consente di selezionare il formato 0).

Dei sei elementi iniziali dello stack, il più in alto è il programma principale (ed è consumato dalla 13prima cosa da eseguire); il secondo è quello 023che seleziona il formato di output e richiede input e viene consumato da quell'operazione; il terzo viene consumato come effetto collaterale 3dell'operazione (viene utilizzato per scartare gli elementi dello stack oltre a produrre output); il quarto, 40è il corpo del ciclo (e consumato dal5 che esegue il loop); e il quinto e il sesto vengono scambiati un numero di volte uguale all'input (finendo così nelle loro posizioni originali se l'input è pari, o nelle posizioni reciproche se l'input è dispari).

Si potrebbe golf fuori un personaggio cambiando il leader 177a 17(e contando su un sesto elemento dello stack vuoto implicita), ma che avrebbe cambiato la parità delle uscite per un metodo meno idiomatica di strano è vero, e non salva un intero byte (la fonte è ancora lunga sette byte). In quanto tale, ho deciso di utilizzare la forma più naturale di output, poiché non ha un punteggio peggiore.

Brain-Flak , 22 20 byte

Ecco un'altra bella risposta in Brain-Flak che dovresti anche dare un'occhiata

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

Provalo online!

Spiegazione

Per iniziare faremo una copia del nostro contributo con (({})).

La copia in basso servirà come valore di verità mentre quella in alto verrà utilizzata per l'elaborazione effettiva. Questo perché abbiamo bisogno che l'input sia in cima ed è piuttosto ingombrante (due byte extra!) Mettere un 1 sotto l'input.

Quindi iniziamo un ciclo {({}[()]<>)} . Questa è una semplice modifica sul ciclo di conto alla rovescia standard che cambia stack ogni volta che diminuisce.

Poiché ci sono due pile, un numero pari finirà nella parte superiore della pila su cui è iniziato mentre un numero dispari finirà sulla pila opposta. Il valore copiato rimarrà al suo posto e fungerà quindi da indicatore del punto di partenza.

Una volta terminato il ciclo, abbiamo un 0 (originariamente l'input) seduto sopra un valore di verità (la copia dell'input) o falso (pila vuota). Abbiamo anche il valore opposto sull'altro stack.

Dobbiamo sbarazzarci di ciò 0che può essere rimosso da {}o <>. Entrambi sembrano funzionare e dare risultati opposti, tuttavia{} causa un valore errato per zero, quando dovrebbe restituire la verità. Questo perché il nostro valore "verità" è una copia dell'input e zero è l'unico input che può essere falso.

Questo problema viene risolto chiudendo invece il programma con <>.

(Naturalmente secondo le specifiche non devo tecnicamente supportare zero ma dare due opzioni preferirei supportarlo)

BitCycle , 19 17 16 byte

?ABv
 / \ <
!+ <

Provalo online!

Argh, mi sento come se ci fosse una soluzione a 18 byte fluttuante appena fuori portata :( Haha! -2 byte usando un +per reindirizzare i bit provenienti da direzioni diverse.

Sembra ancora che ci sia troppo spazio bianco (un intero 6 byte!)

Spiegazione:

?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

Lotto, 16 byte

@cmd/cset/a%1%%2

Uscite 1 per dispari, 0 per pari. La versione alternativa a 16 byte funziona anche su numeri negativi:

@cmd/cset/a"%1&1

17 byte all'uscita 1 per pari, 0 per dispari:

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

Excel, 10 byte

=MOD(A1,2)

O:

=ISODD(A1)

Per uscita di:

JSFuck , 9685 9384 6420 byte

JSFuck è uno stile di programmazione esoterico ed educativo basato sulle parti atomiche di JavaScript. Utilizza solo sei caratteri diversi per scrivere ed eseguire il codice.

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

Uscite 1 per pari e 0 per pari.

Provalo online!

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

Bash + bc, 21 14 11 9 byte

bc<<<$1%2

Legge l'input della riga di comando, espande il valore nella stringa con l'operazione mod e invia la stringa a bc per il calcolo. Uscite 1 per dispari, 0 per pari.

Casi test:

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

Modifica: salvato 7 byte grazie a @ ais523
Modifica 2: salvato altri 3 byte grazie a @Dennis
Modifica 3: salvato altri due grazie a @Dennis