Nota: Ainda não houve um desafio no teste de paridade de baunilha (existe um de C / C ++, mas que desabilita a capacidade de usar idiomas que não sejam C / C ++ e outros que não são de baunilha também estão fechados também), por isso estou postando 1.

Dado um número inteiro positivo, mostre sua paridade (ou seja, se o número for ímpar ou par) em valores de verdade / falsidade. Você pode escolher se os resultados verdadeiros correspondem a entradas ímpares ou pares.

Exemplos

Assumindo Verdadeiro / Falso como par e ímpar (Isso não é necessário, você pode usar outros valores de Truthy / Falsy para cada um), responsivamente:

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

Entre os melhores

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

Isso gera 1(que é verdade) para entrada ímpar e 0(que é falso) para entrada par.

Experimente online!

“ Agora este é o plano ” (uma tentativa de explicação)

O código lê a entrada na variável i, a substitui pelo resultado do módulo 2 e a 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

+[,>,]<.

A entrada está unária. A saída é o 1 (verdade) para números ímpares e NUL (falso) para números pares.

Experimente online!

Como funciona

Começamos incrementando a célula atual +para poder inserir o loop while [,>,].

Em cada iteração, ,lê um byte de STDIN, >avança para a célula à direita e depois ,lê outro byte de STDIN. Quando a entrada estiver esgotada, o intérprete (o TIO, de qualquer maneira) definirá a célula para NUL . Quando isso acontece, a condição do loop while não é mais preenchida e nós a rompemos.

Seja n o número inteiro de entrada. Se houver um montante de bytes de entrada - por exemplo, se n é o mesmo - o primeiro n / 2 iterações lerá dois 1 's, e a iteração seguinte irá ler dois NUL ' s, deixando a fita como se segue.

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

<.retrocede uma célula e imprime seu conteúdo, enviando um byte NUL para STDOUT.

No entanto, se houver uma quantidade ímpar de bytes de entrada, o primeiro (N - 1) / 2 iterações lerá dois 1 's, e a iteração seguinte irá ler um 1 e um NUL , deixando a fita como se segue.

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

<agora retrocede para uma célula que contém o byte / caractere 1 , que é .impresso.

Mathematica, 4 bytes

OddQ

Dá Trueentradas estranhas e Falsepares, quem sabia?

Há também EvenQ, mas quem gostaria de digitar tudo isso?

Táxi , 1.482 1.290 1.063 1.029 1.009 bytes

_{^{Eu nunca escrevi um programa em Taxi antes e sou um novato em programação para geral, então provavelmente existem maneiras melhores de fazer isso. Eu verifiquei os erros e consegui jogar um pouco de golfe, tentando rotas diferentes com o mesmo resultado. Congratulo-me com toda e qualquer revisão.}}

Retorna 0para par e 1ímpar.

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

Experimente online!

Você está certo, é horrível ler sem quebras de linha. Aqui está uma versão formatada:

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

Aqui está minha melhor tentativa de explicar a 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.

Não voltar para a Taxi Garage causa saída para a STDERR, mas estou bem com isso .

Retina , 8 bytes

[02468]$

Uma resposta de retina para entrada decimal. Essa também é uma solução simples de regex que funciona em praticamente qualquer sabor de regex. Corresponde (e imprime 1) para entradas pares e não corresponde (e imprime 0) para entradas ímpares.

Experimente online!

Uma alternativa, também para 8 bytes, usa um estágio de transliteração para converter todos os dígitos pares para o xprimeiro (porque os estágios de transliteração têm um built-in para dígitos pares / ímpares):

T`E`x
x$

Obviamente, o formato de entrada mais curto (ainda mais curto que o unário ) seria binário nesse caso, onde uma simples expressão regular 0$seria suficiente. Mas como o desafio é essencialmente encontrar o dígito binário menos significativo, a entrada binária parece contornar o desafio real.

Python, 11 10 bytes

^{-1 byte graças a Griffin}

1 .__and__

Experimente online!
Usando bit a bit and, retorna 0para pares e 1ímpares

LOLCODE, 67 bytes

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

Função que retorna WIN(verdadeiro) se o número for par; caso contrário, (ímpar) ele retornará FAIL(falso).

Ligue com C"123".

MATL , 5 3 bytes

Porque builtins são chatos

:He

Isso gera uma matriz de valores diferentes de zero (que é verdade) para entrada par e uma matriz com um zero na entrada inferior direita (que é falsa) para entrada ímpar.

Experimente online! O código do rodapé é umif-elseramo para ilustrar a veracidade ou falsidade do resultado. A remoção desse rodapé exibirá implicitamente a matriz.

Explicação

Considere a entrada 5como um exemplo

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

Experimente aqui.

Java 7, 30 bytes

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

Experimente aqui.

Saídas truepara números falsepares e números ímpares

Se 1/0fosse permitido em vez de true/false( não é, considerando o número de votos aqui ):

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

Piet, 15 codels / 16 bytes

5njaampjhompppam

Intérprete online disponível aqui.

Este programa retorna 0 se a entrada for par e 1 se a entrada for ímpar.

O texto acima representa a imagem. Você pode gerar a imagem colando-a na caixa de texto na página do intérprete. Por conveniência, forneci a imagem abaixo, onde o tamanho do codel é 31 pixels. A grade existe para facilitar a leitura e não faz parte do programa.

Explicação

Este programa usa o módulo interno para determinar se a entrada é par ou ímpar.

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]

Os codels azuis escuros no canto inferior esquerdo nunca são visitados e podem ser alterados para qualquer cor diferente da cor de um codel vizinho. Eu escolhi o azul escuro porque acho que fica bem com o resto do programa. O codel preto superior esquerdo também pode ser branco, mas não qualquer outra cor. Eu escolhi o preto como acho melhor.

Forneci o programa na forma de imagem e texto, pois não há um consenso claro sobre como classificar os programas Piet. Sinta-se à vontade para comentar a meta discussão.

cérebro , 14 bytes

A entrada e a saída são tomadas como códigos de caracteres, de acordo com esta meta .
O valor do byte 1 corresponde a números ímpares e 0 a par.

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

Experimente online!

JavaScript, 6 bytes

Uma função anônima:

n=>n&1

Alternativamente com o mesmo comprimento:

n=>n%2

Ambos retornarão, o 0|1que deve atender ao requisito de truthy|falseyvalores.

Experimente as duas versões online

Japt , 1 byte

v

Retorna 1para números pares, 0para ímpares.

Experimente online!

Explicação

Uma das características definidoras de Japt é que, diferentemente da maioria das linguagens de golfe, as funções não têm aridade fixa; isto é, qualquer função pode aceitar qualquer número de argumentos. Isso significa que às vezes você pode deixar de lado os argumentos e o Japt adivinhará o que deseja. von numbers é uma função que aceita um argumento e retorna 1se o número é divisível pelo argumento, caso contrário 0. Por exemplo:

v3

Este programa será emitido 1se a entrada for divisível por 3 e 0caso contrário. Acontece que o argumento padrão é 2, resolvendo esse desafio em um único byte.

Solução alternativa de 1 byte:

¢

¢converte a entrada em uma string de base 2. A -hbandeira retorna o último caractere da string.

Experimente online!

brainfuck , 12 bytes

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

Isso requer um intérprete com uma fita circular e células que envolvem. A do TIO possui 65.536 células de 8 bits e atende aos requisitos.

A E / S está em bytes. As entradas ímpares são mapeadas para 0x00 (falsy), até as entradas para um byte diferente de zero (verdade).

Experimente online!

Como funciona

Começamos lendo um byte de entrada ,e adicionando 2 ao seu valor com++ . Veremos mais adiante por que o incremento é necessário.

Em seguida, inserimos um loop que avança para a célula à direita, adiciona 2 a ela e repete o processo, a menos que isso defina o valor da célula como 0 .

Inicialmente, todas as células, exceto a célula de entrada, retêm 0 . Se a entrada for ímpar, adicionar 2 a ela nunca a zerará. No entanto, depois de fazer um loop em torno da fita 127 vezes, a próxima iteração do loop definirá a célula à direita da célula de entrada como 128 × 2 = 0 (mod 256) , fazendo com que o loop termine. >++repete o corpo do loop mais uma vez, para que a próxima célula também seja zerada e impressa com ..

Por outro lado, se a entrada é n e n é par, o código antes do loop define a célula de entrada como n + 2 . Depois de fazer um loop pela fita (256 - (n - 2)) / 2 = (254 - n) / 2 vezes, a célula de entrada alcançará 0 e a célula à direita manterá o valor (254 - n) / 2 × 2 = 254 - n . Depois de adicionar 2 com >++, .imprimirá 256 - n = -n (mod 256) , que é diferente de zero, pois n é diferente de zero.

Finalmente, observe que o segundo caso imprimiria 258 - n = 2 - n (mod n) se não incrementássemos a entrada antes do loop, pois seria necessário mais um loop ao redor da fita para zerar a célula de entrada. O programa falharia, assim, na entrada 2 .

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

De acordo com os comentários de Adám abaixo, aqui está o último candidato a lançamento:

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

Será agora PRINT 1para mesmo e0 ímpar. Zero sai.

Aqui estão as versões mais antigas da lista simbólica para fins de referência:

 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

Aqui está a listagem antiga (v0.01), para que você possa ver as melhorias que eu fiz, além de essa nova listagem ser menor, mas é mais 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

E aqui está a v0.02 (usando as sub-strings do 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 auto-explicativo. Devoluçõesa % 2 == 0

Experimente online!

Retina, 3 bytes

11

A nova linha à direita é significativa. Recebe entrada em unário. Saídas 1 para números ímpares, nada para números pares. Experimente online!

C ++, 25 bytes

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

Isso define um modelo de variável ( uma construção semelhante à função ) com valor igual à operação bit a bit input&1. 0para valores pares, 1para valores ímpares. O valor é calculado em tempo de compilação.

Requer C ++ 14.

Experimente online!

Pyth, 3 2 bytes

Eu fiz isso. Eu jogava golfe no ingovernável. Pela primeira vez, é uma solução não trivial que conseguiu obter o último byte!

!F

Verdadeiramente em valores pares (sem incluir 0, mas isso não é positivo, então ...).

Explicação:

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

Por exemplo !!2 = !0 = 1, e!!!3 = !!0 = !1 = 0

Vou manter minha biblioteca de soluções de 3 bytes aqui abaixo.

"Há outra resposta com várias soluções de 3 bytes, mas está longe de ser completa. Vamos adicionar mais algumas:

@U2

Indexa na lista [0,1]modularmente, fornecendo valores verdadeiros em entradas ímpares.

}2P

2 é a fatoração principal da entrada? (Verdade mesmo)

ti2

O GCD é 2 e a entrada 2? (Verdade mesmo)

gx1

XOR-ing a entrada com 1 não diminui? (Verdade mesmo)

q_F

Basicamente, Q == Q*-1^Qonde Q é a entrada, mas feito através de um loop. (Verdade mesmo)

_FI

O mesmo que acima.

g^_

Traduz para Q <= -Q^Q(Truthy on even)

Observe que qualquer uma das soluções acima envolve gtrabalhará com <falsidade de verdade invertida.)

C #, 8 bytes

n=>n%2<1

Compila para um Func<int, bool>.

Ou, se uma função anônima não for permitida, este método para 21 bytes:

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

Pitão, 3

Eu estava esperando que pyth tivesse um byte de 1 ou 2 bytes embutido para isso. Em vez disso, aqui estão as melhores soluções que eu poderia encontrar:

%Q2

ou

.&1

ou

e.B

TIS-100, 39 bytes

Obviamente, este é, mais precisamente, um programa para a arquitetura do Nó de Execução Básica T21, conforme emulado pelo emulador TIS-100.

Vou encaminhá-lo a esta resposta para obter uma explicação incrivelmente detalhada da pontuação dos programas TIS-100, bem como de sua estrutura.

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

Explicação:

@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

No pseudocódigo, seria algo como:

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

O T21 não possui tipos booleanos ou valores de verdade / falsidade; portanto, o programa retorna -1 para números ímpares e 0 para números pares, a menos que a entrada anterior seja ímpar; nesse caso, retorna -1 para números pares e 0 para ímpares números - se esse fato o incomodar, esta é uma resposta completa do programa, para que você possa reiniciar o seu T21 entre os usos.

Geléia , 1 byte

Ḃ

Experimente online!

Apenas mais um builtin.

Para pessoas que não conhecem o Jelly: ele tem bastante capacidade de inferir bits de código ausentes, portanto, não há muita diferença sintática entre um snippet, uma função e um programa completo; o intérprete adicionará automaticamente o código para inserir argumentos apropriados e produzirá o resultado. Isso é bastante útil quando se lida com regras PPCG, que permitem funções e programas, mas não permitem trechos. No link TIO, estou tratando isso como uma função e executando-o em cada número inteiro de 1 a 20, inclusive, mas funciona como um programa completo também.

Geléia , 2 bytes

&1

Experimente online!

É muito curto sem o embutido também. (Isso é bit a bit-AND com 1.)

7 , 18 caracteres, 7 bytes

177407770236713353

Experimente online!

7 não possui nada parecido com uma instrução if normal e possui mais de uma maneira idiomática para representar um booleano. Como tal, é difícil saber o que conta como verdade e falsey, mas este programa usa1 para a sequência ímpar e nula para o par (os valores de truthy e falsey para Perl, nos quais o intérprete 7 está escrito). (É fácil mudar isso; a saída ímpar é especificada antes dos 7 primeiros, a saída par é especificada entre os dois primeiros 7s. No entanto, pode ser necessário alterar o formato de saída para lidar com outros tipos de saída; usei os dois saídas distintas mais curtas aqui.)

7 usa uma codificação octal compactada na qual três bytes da fonte representam oito bytes do programa, de modo que 18 caracteres da fonte são representados em 7 bytes no disco.

Explicação

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

Como muitos formatos de saída, "números inteiros de saída" desfaz qualquer número de níveis de escape antes da saída; portanto 40, que combinadas fazem uma operação de troca e escape, podem ser usadas no lugar de 405uma operação de troca (que é uma troca e fuga seguida de uma retirada). Se você estiver usando um formato de saída que não é estável em relação à fuga, precisará do total 405lá. (Aliás, a razão pela qual precisávamos escapar da cadeia de formatação originalmente é que, se a primeira saída contiver caracteres não representáveis, ela automaticamente força o formato de saída 7. Ao sair, remove os caracteres não representáveis ​​e permite que o formato 0 seja selecionado.)

Dos seis elementos iniciais da pilha, o mais alto é o programa principal (e é consumido pela 13primeira coisa a ser executada); o segundo é o 023que seleciona o formato de saída e solicita entrada e é consumido por essa operação; o terceiro é consumido como efeito colateral da 3operação (é usado para descartar elementos de pilha, além de produzir saída); o quarto,, 40é o corpo do loop (e consumido pelo 5que executa o loop); e o quinto e o sexto são trocados um número de vezes igual à entrada (assim terminam em suas posições originais se a entrada for par ou nas posições um do outro se a entrada for ímpar).

Você pode jogar fora um personagem alterando o líder 177para 17(e confiando em um sexto elemento vazio implícito da pilha), mas isso mudaria a paridade das saídas para um método menos idiomático do que o estranho é verdadeiro, e ele não salva um byte inteiro (a fonte ainda tem sete bytes). Como tal, decidi usar a forma mais natural de produção, pois ela não é pior.

Flak cerebral , 22 20 bytes

Aqui está outra resposta interessante no Brain-Flak, você também deve conferir

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

Experimente online!

Explicação

Para começar, faremos uma cópia de nossa entrada com (({})).

A cópia inferior servirá como um valor verdadeiro, enquanto a cópia superior será usada para o processamento real. Isso é feito porque precisamos que a entrada esteja no topo e é bastante complicado (dois bytes extras!) Colocar 1 abaixo da entrada.

Então começamos um loop {({}[()]<>)}. Essa é uma modificação simples no loop de contagem regressiva padrão que alterna as pilhas cada vez que diminui.

Como existem duas pilhas, um número par terminará no topo da pilha em que começou, enquanto um número ímpar terminará na pilha oposta. O valor copiado permanecerá no local e, portanto, atuará como um marcador de onde começamos.

Quando terminamos o loop, temos um 0(originalmente a entrada) em cima de um valor de verdade (a cópia da entrada) ou falso (pilha vazia). Também temos o valor oposto na outra pilha.

Precisamos nos livrar do 0que pode ser removido por {}ou <>. Ambos parecem funcionar e dão resultados opostos, no entanto{} causa um valor falso para zero, quando deve retornar a verdade. Isso ocorre porque nosso valor "verdade" é uma cópia da entrada e zero é a única entrada que pode ser falsa.

Esse problema é resolvido encerrando o programa <>.

(Obviamente, de acordo com a especificação, tecnicamente não tenho que suportar zero, mas dê duas opções que eu preferiria)

BitCycle , 19 17 16 bytes

?ABv
 / \ <
!+ <

Experimente online!

Argh, eu sinto que há uma solução de 18 bytes flutuando fora do alcance :( Haha! -2 bytes usando a +para redirecionar bits provenientes de diferentes direções.

Parece que ainda há muito espaço em branco (um total de 6 bytes!)

Explicação:

?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

Saídas 1 para ímpar, 0 para par. A versão alternativa de 16 bytes também funciona em números negativos:

@cmd/cset/a"%1&1

17 bytes para gerar 1 para par, 0 para ímpar:

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

Excel, 10 bytes

=MOD(A1,2)

Ou:

=ISODD(A1)

Para saída de:

JSFuck , 9685 9384 6420 bytes

O JSFuck é um estilo de programação esotérico e educacional baseado nas partes atômicas do JavaScript. Ele usa apenas seis caracteres diferentes para escrever e executar código.

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

Saídas 1 para ímpar e 0 para par.

Experimente online!

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

Bash + bc, 21 14 11 9 bytes

bc<<<$1%2

Lê a entrada da linha de comando, expande o valor para a sequência com a operação mod e canaliza a sequência para bc para cálculo. Saídas 1 para ímpar, 0 para par.

Casos de teste:

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

Edit: salvou 7 bytes graças a @ ais523
Edit 2: salvou outros 3 bytes graças a @Dennis
Edit 3: salvou mais dois graças a @Dennis