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>
Respostas:
ArnoldC ,
299283 bytesIsso gera
1
(que é verdade) para entrada ímpar e0
(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.fonte
BULLSHIT
YOU HAVE NO RESPECT FOR LOGIC
GET TO THE CHOPPER
GET YOUR ASS TO MARS
...Não tenho palavras.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.
<.
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.
<
agora retrocede para uma célula que contém o byte / caractere 1 , que é.
impresso.fonte
Mathematica, 4 bytes
Dá
True
entradas estranhas eFalse
pares, quem sabia?Há também
EvenQ
, mas quem gostaria de digitar tudo isso?fonte
2∣#&
funciona também #Q
?Táxi ,
1.4821.2901.0631.0291.009 bytesEu 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
0
para par e1
ímpar.Experimente online!
Você está certo, é horrível ler sem quebras de linha. Aqui está uma versão formatada:
Aqui está minha melhor tentativa de explicar a lógica:
Não voltar para a Taxi Garage causa saída para a STDERR, mas estou bem com isso .
fonte
Retina , 8 bytes
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 imprime0
) 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
x
primeiro (porque os estágios de transliteração têm um built-in para dígitos pares / ímpares):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.fonte
Python,
1110 bytes-1 byte graças a Griffin
Experimente online!
Usando bit a bit
and
, retorna0
para pares e1
ímparesfonte
1 .__and__
é um caractere mais curtoLOLCODE, 67 bytes
Função que retorna
WIN
(verdadeiro) se o número for par; caso contrário, (ímpar) ele retornaráFAIL
(falso).Ligue com
C"123"
.fonte
MATL ,
53 bytesPorque builtins são chatos
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é é um
if-else
ramo para ilustrar a veracidade ou falsidade do resultado. A remoção desse rodapé exibirá implicitamente a matriz.Explicação
Considere a entrada
5
como um exemplofonte
Java 8, 8 bytes
Experimente aqui.
Java 7, 30 bytes
Experimente aqui.
Saídas
true
para númerosfalse
pares e números ímparesSe
1/0
fosse permitido em vez detrue/false
( não é, considerando o número de votos aqui ):n->n%2
int c(int n){return n%2;}
fonte
int o(int n){return java.util.stream.IntStream.of(n).map(n->n%2).filter(n==0).findAny().isPresent();}
Piet, 15 codels / 16 bytes
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.
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.
fonte
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!
fonte
JavaScript, 6 bytes
Uma função anônima:
Alternativamente com o mesmo comprimento:
Ambos retornarão, o
0|1
que deve atender ao requisito detruthy|falsey
valores.Experimente as duas versões online
fonte
0|1
são, certo? @TheLethalCoderJapt , 1 byte
Retorna
1
para números pares,0
para í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.
v
on numbers é uma função que aceita um argumento e retorna1
se o número é divisível pelo argumento, caso contrário0
. Por exemplo:Este programa será emitido
1
se a entrada for divisível por 3 e0
caso 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-h
bandeira retorna o último caractere da string.Experimente online!
fonte
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 .
fonte
Sinclair ZX81 BASIC
124 bytes114 bytes109 bytes5750 bytes BASIC tokenizadosDe acordo com os comentários de Adám abaixo, aqui está o último candidato a lançamento:
Será agora
PRINT
1
para mesmo e0
ímpar. Zero sai.Aqui estão as versões mais antigas da lista simbólica para fins de referência:
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:
E aqui está a v0.02 (usando as sub-strings do Sinclair):
fonte
PRINT (A-2*INT A/2)/A
?0
não deveria produzir umTRUE
ouFALSE
, portanto, como0
não deveria produzir um resultado, solicitei que eleSTOP
fizesse ping no programa. Provavelmente interpretei a pergunta original, pois ela foi postada por @SIGSEGV um pouco literalmente demais. Sim, pode-se otimizar e refatorar, você está correto.05AB1E , 1 byte
Bastante auto-explicativo. Devoluções
a % 2 == 0
Experimente online!
fonte
É
é uma escolha melhor, na minha opinião pessoal; brincando.É
retornosa % 2 == 1
.Retina, 3 bytes
A nova linha à direita é significativa. Recebe entrada em unário. Saídas 1 para números ímpares, nada para números pares. Experimente online!
fonte
C ++, 25 bytes
Isso define um modelo de variável ( uma construção semelhante à função ) com valor igual à operação bit a bit
input&1
.0
para valores pares,1
para valores ímpares. O valor é calculado em tempo de compilação.Requer C ++ 14.
Experimente online!
fonte
int o(int v){return v&1;}
) levaria a mesma quantidade de bytes, com a diferença de que o valor seria calculado em tempo de execução.main()
construto semelhante, o programa também seria compilado em umreturn 0
, ou até falharia em compilar. Isso contradiz o meta post ao qual vinculei nesta resposta.[](int x){return x%2;}
Experimente on-linePyth,
32 bytesEu fiz isso. Eu jogava golfe no ingovernável. Pela primeira vez, é uma solução não trivial que conseguiu obter o último byte!
Verdadeiramente em valores pares (sem incluir 0, mas isso não é positivo, então ...).
Explicação:
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:
Indexa na lista
[0,1]
modularmente, fornecendo valores verdadeiros em entradas ímpares.2 é a fatoração principal da entrada? (Verdade mesmo)
O GCD é 2 e a entrada 2? (Verdade mesmo)
XOR-ing a entrada com 1 não diminui? (Verdade mesmo)
Basicamente,
Q == Q*-1^Q
onde Q é a entrada, mas feito através de um loop. (Verdade mesmo)O mesmo que acima.
Traduz para
Q <= -Q^Q
(Truthy on even)Observe que qualquer uma das soluções acima envolve
g
trabalhará com<
falsidade de verdade invertida.)fonte
C #, 8 bytes
Compila para um
Func<int, bool>
.Ou, se uma função anônima não for permitida, este método para 21 bytes:
fonte
if (1)
, não compila.if (1)
no seu código?if (x)
avaliada como verdadeira, entãox
é um valor de verdade . Se avalia falso, então éfalse
. Assim, em pseudo-código:if x, disp(true), else disp(false)
. Se isso não for compilado,x
não poderá ser usado. Em MATLAB e várias outras línguas, qualquer coisa que não zero é considerado verdadeiro, enquanto0
efalse
são consideradas falsas. Portanto, a stringHello
é um valor verdadeiro em MATLAB. No entanto, alguns idiomas exigem que o valor seja um valor booleano (o caso aqui), portanto, ele deve ser convertido em um booleano usando<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:
ou
ou
fonte
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.
Explicação:
No pseudocódigo, seria algo como:
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.
fonte
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
Experimente online!
É muito curto sem o embutido também. (Isso é bit a bit-AND com 1.)
fonte
7 , 18 caracteres, 7 bytes
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 usa
1
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
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 de405
uma 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 total405
lá. (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
13
primeira coisa a ser executada); o segundo é o023
que seleciona o formato de saída e solicita entrada e é consumido por essa operação; o terceiro é consumido como efeito colateral da3
operação (é usado para descartar elementos de pilha, além de produzir saída); o quarto,,40
é o corpo do loop (e consumido pelo5
que 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
177
para17
(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.fonte
Flak cerebral ,
2220 bytesAqui 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
0
que 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)
fonte
BitCycle ,
19 1716 bytesExperimente 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:
fonte
Lote, 16 bytes
Saídas 1 para ímpar, 0 para par. A versão alternativa de 16 bytes também funciona em números negativos:
17 bytes para gerar 1 para par, 0 para ímpar:
fonte
(Input):(Output)
"Excel, 10 bytes
Ou:
Para saída de:
fonte
?[A1]mod 2
; uma função de janela imediatos anônima VBE que leva entrada de[A1]
e saídas para a janela imediatos do VBE com0
(Falsey) representando mesmo e1
(truthy) representando estranhoJSFuck ,
968593846420 bytesO 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!
fonte
alert(prompt()%2)
parece ser 9384 caracteres.[]["fill"]["constructor"]("return this%2")["call"]
.fill
foi escolhido porque isso custa apenas 81 caracteres, o menor de todos os métodos de matriz. Além disso, você pode argumentar que o JSFuck não é uma linguagem separada, mas um subconjunto de JavaScript.+
para salvar mais 77 bytes ;-) E eu pessoalmente acho que responder em JSF é bom; é basicamente um dialeto de JS.Bash + bc,
2114119 bytesLê 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:
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
fonte
$1
) em vez de gastar bytes lendo-o do stdin?bc<<<$1%2
.