Na matemática, um ponto de exclamação !
geralmente significa fatorial e vem depois da discussão.
Na programação, um ponto de exclamação !
geralmente significa negação e vem antes do argumento.
Para esse desafio, aplicaremos essas operações apenas a zero e um.
Factorial
0! = 1
1! = 1
Negation
!0 = 1
!1 = 0
Pegue uma sequência de zero ou mais !
's, seguida por 0
ou 1
, seguida de zero ou mais !
' s ( /!*[01]!*/
).
Por exemplo, a entrada pode ser !!!0!!!!
ou !!!1
ou !0!!
ou 0!
ou 1
.
O !
antes 0
ou depois das 1
negações e o !
depois são fatoriais.
O fatorial tem maior precedência do que a negação, portanto, os fatoriais são sempre aplicados primeiro.
Por exemplo, !!!0!!!!
realmente significa !!!(0!!!!)
, ou melhor ainda !(!(!((((0!)!)!)!)))
.
Saída da aplicação resultante de todos os fatoriais e negações. A saída será sempre 0
ou 1
.
Casos de teste
0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0
O código mais curto em bytes vence.
Respostas:
Mathematica,
2517 bytesRecebe entrada de um prompt do usuário. Assume o ambiente de notebook do Mathematica para impressão implícita. Para torná-lo um script de linha de comando, envolvê-lo
Print[...]
ou torná-lo uma função sem argumentos (que então recebe entrada do prompt), acrescente&
.O Mathematica possui os dois operadores necessários (com a precedência necessária), para que possamos "avaliar" a entrada (o que é feito automaticamente por
Input[]
), mas o operador de negação lógica não funciona em números inteiros (portanto, ele não será avaliado). Se!x
sobrar um resultado, substituí-lo por1-x
.Alguns fatos interessantes sobre a avaliação:
!!
, que calculan*(n-2)*(n-4)*...
, mas é aplicado a0
ou1
ainda fornece1
, portanto, não importa que0!!!!!
seja realmente analisado((0!!)!!)!
.!0
e!1
não seja avaliado, ele sabe que!
é auto-inverso e, por isso, cancela automaticamente todos os pares de liderança!
. Depois doToExpression
que estamos sempre deixou com um dos0
,1
,!0
,!1
.fonte
x=${x/[01]!*/1};echo $(($x))
- não tem permissão para postar uma resposta adequada :([Bash] + Utilitários Unix,
2117 bytesIsso deve ser salvo em um arquivo e executado como um programa. Se você tentar digitar o comando diretamente da linha de comando, não funcionará porque !! é expandido devido à substituição do histórico ser ativada no modo interativo do bash. (Como alternativa, você pode desativar a substituição do histórico com
set +H
.)O caso de teste é executado:
fonte
mkdir -p 's/.!!'{bunch,of,different,directories}\$/1
? Então você receberá o Pathname Expansion e o Sed tentará ler os diretórios como se fossem arquivos, em vez de ler a entrada padrão, e ela não produzirá nada! :)Retina ,
201514 bytesAgradecemos a Leo por economizar 1 byte.
Experimente online!
Explicação
Transformar
0!
em1
. Não nos importamos com nenhum outro!
s final , o número resultante é o mesmo como se tivéssemos aplicado todos os fatoriais.Cancele pares de negações. Isso também pode cancelar alguns fatoriais, mas isso é irrelevante.
Conte o número de correspondências dessa regex, que é ou
1
ou0
e fornece o resultado desejado.fonte
\d.+
...^
anterior!0
Grime ,
14 129 bytesExperimente online!
Explicação
Isso corresponde à entrada em relação a um padrão, imprimindo
1
para correspondência e0
sem correspondência.A ideia é essa. Se a entrada começa com um dígito, a parte recursiva
\!_
sempre falha e\0!
é bem - sucedida, a menos que tenhamos um único0
. O xor deles é bem-sucedido, a menos que a entrada seja única0
. Se a entrada começar com a!
,\0!
sempre será bem-\!_
sucedida e se a correspondência recursiva for bem-sucedida. O xor deles é bem-sucedido exatamente quando a correspondência recursiva falha, negando-a.fonte
Brainfuck,
8572 (84) bytespara retornar numericamente ou
para texto ASCII. > também pode ser prefixado para evitar quebra de memória.
Experimente online!
Ou, para resposta em texto, substitua a última linha por
fonte
Brainfuck - caminho para muitos bytes (232 bytes)
Claramente o idioma errado para ganhar no código de golfe. Notei principalmente a falta de alguém usando esse esolang. Existe um bom interpretador on-line bf interpeter ou você pode realmente assistir ao que o programa faz usando esse visualizador bf .
fonte
Python,
-44-42 bytesEconomizou 2 bytes graças ao Zgarb!
Passo a passo:
x[-1]!='0'
se
x
termina com1
ou!
⇔x
não termina com0
, a parte fatorial deve ter valor1
, caso contrário0
^len(x.rstrip('!'))%2
explorar a propriedade do xor como um "não condicional". A condição nesse caso é se o comprimento de
!
s inicial for ímpar. No entanto,.rstrip
não remove o número da sequência, portanto o comprimento calculado é compensado por 1; portanto, a condição é invertida!=
para a==
etapa 1. O Zgarb sugeriu o uso de um operador de comparação de diferenças em vez de aplicar outra inversão, economizando 2 bytes.Experimente online!
fonte
!!0
; está retornando no momento1
.lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2
evita a inversão extra.JavaScript (ES6),
434129 bytesMétodo não regex (
4131 bytes)Abaixo está minha abordagem inicial. É um pouco mais interessante, mas
significativamente mais longoainda mais após uma otimização significativa do Neil (10 bytes salvos) .Casos de teste
Mostrar snippet de código
fonte
f=([c,...s])=>1/c?c|s>'':1-f(s)
.Geléia , 5 bytes
Experimente online!
Função monádica esperando uma string. Entradas com
!
s iniciais fazem com que1
a seja impressa em STDOUT ao longo do caminho, de modo que o link TIO fornecido é um equipamento de teste que imprime os pares de entrada e saída abaixo da primeira linha de saída.Quão?
fonte
05AB1E , 9 bytes
Código:
Usa a codificação CP-1252 . Experimente online! ou Verifique todos os casos de teste!
Explicação:
fonte
Retina , 13 bytes
Uma abordagem um pouco estranha, mas é curta e funciona.
Nas duas primeiras linhas, substituímos um final
0
por!1
: com essa substituição, sabemos agora que a parte da nossa string do dígito em diante é igual a 1.Nas próximas duas linhas, remova os pares de
!
: dupla negação se apaga e já contabilizamos o fatorial na etapa anterior.Última linha, combine um dígito no início da string e retorne o número de correspondências: se todas as negações tiverem sido eliminadas, encontraremos uma correspondência (e, como dissemos antes, sabemos que isso é igual a 1), se ainda houver uma negação que não corresponde.
Experimente online!
fonte
1
vez de\d
.0!
permanecerá inalterada até a última linha #Ruby, 12 + 1 =
39241513 bytesUsa a
-n
bandeira. Graças a @GB por -9 bytes!fonte
0
ou o fim de linha!*$
é mais curto por dois!Perl , 20 bytes
19 bytes de código +
-p
sinalizador.Experimente online!
A negação de Perl retorna
undef
ou1
, então eu uso0+
para numerar os0+undef
retornos do resultado0
. Além disso, não há muito a dizer sobre o código.fonte
C,
68626153 bytesEspremido mais alguns bytes com algum abuso
Experimente online!
fonte
int
da função e você pode alterar o*a==33
para*a<34
.*a%2
é mais curto do que*a-48
for(;*a<34;a++)
pode ser encurtado parafor(;*a++<34;)
salvar 1 bytePerl 6 ,
322823 bytesComo funciona
fonte
Haskell , 39 bytes
Define uma função
f
, que pega uma string e retorna um caractere. Experimente online!Explicação
Existem três casos: a entrada começa com
!
, a entrada tem comprimento 1 e tudo mais.fonte
f('!':b)=[1,0]!!f b;f"0"=0;f _=1
.Befunge, 24 bytes
Experimente online!
Isso começa contando o número de
!
caracteres lidos no stdin. O primeiro caractere que não é a!
será0
ou1
, mas, no processo de teste!
, teremos subtraído 33, tornando-o em 15 ou 16. Em seguida, lemos mais um caractere, que será um!
ou EOF, e compare se isso é menor que 0 (ou seja, EOF).Tomando esses três pontos de dados - a contagem de exclamação ( c ), o valor do dígito ( d ) e a condição de fim de arquivo ( e ) - podemos calcular o resultado da seguinte forma:
Multiplicar o valor do dígito pela condição de final do arquivo significa que ele será convertido para zero se o dígito for seguido por a
!
, fornecendo, assim, o mesmo valor do módulo 2 que um1
(que lembra que foi convertido em 16). Porém, antes de aplicar o módulo 2, adicionamos a contagem de exclamação inicial, que efetivamente alterna o resultado do módulo 2 quantas vezes forem os!
prefixos. E, finalmente, não somos o resultado, já que nossos valores de linha de base são0
e1
são o oposto do que precisamos.Observando o código com mais detalhes:
fonte
Haskell , 27 bytes
Experimente online!
Cada líder
!
complementa a saída para o restante da expressão, feita como1-
. Continuamos lançando até atingir um dígito. Se o restante for justo"0"
, o resultado será 0. Caso contrário, é um1
ou é seguido por um ou mais!
, portanto, o resultado é 1.fonte
Ruby,
22 2120 bytesExplicação:
(-1 byte roubando a idéia da @Value Ink)
fonte
Gelatina , 8 bytes
Experimente online!
Esta é uma função (link monádico) que recebe um argumento e retorna por seu valor de retorno. (Também costuma gravar lixo na saída padrão como efeito colateral, mas não nos importamos com isso.)
Explicação
Primeiro, observe que, como a entrada sempre consiste em algum número de
!
, seguido por um dígito, seguido por mais!
, que, se excluirmos o final!
e o comprimento, terminaremos com um mais o número de líderes!
no programa. Tomar a paridade disso retornará 0 se houver um número ímpar de!
, ou 1 se houver um número par de!
. Comparar com 0 é uma função "não", enquanto comparar com 1 é a função de identidade; assim,œr”!LḂ=
efetivamente implementa a parte "tratar líderes!
como NÃO operadores" da questão.Quanto ao segundo semestre, manipular fatoriais,
!
é uma operação fatorial em Jelly; portanto, se o programa não tiver liderança!
, podemos resolver o problema diretamente com um simpleseval
(V
). Se o programa não tem que conduz!
, aqueles será interpretada como tendo o factorial de 0 (possivelmente várias vezes), produzindo um valor de retorno 1, o qual vai ser impressa na saída padrão e descartado uma vez um dígito é visto; portanto, eles não têm impacto no valor de retorno da função que é minha submissão à pergunta.fonte
Python, 38 bytes
TryItOnline!
Uma função sem nome que pega uma sequência de entrada
s
e retorna um número inteiro0
ou1
.s[1::2]
é uma fatia da sequência de entrada que começa no índice 1 e tem um tamanho de etapa de dois:'Like this' -> 'ieti'
s[::2]
é semelhante, mas inicia no índice padrão 0:'Like this' -> 'Lk hs'
O teste
(s[1::2]>s[::2])
verifica se o índice baseado em 0 do'0'
ou'1'
é ímpar, ou seja, se precisamos complementar.Isso funciona porque a ordem das cadeias é verificada lexicograficamente com qualquer cadeia não vazia maior que a cadeia vazia e com a ordenação ASCII
'1'>'0'>'!'
. Este é um byte mais curto que o mais simpless.index(max(s))%2
.As
ord(s[-1])%2
verificações para ver se o último caractere não é um'0'
(para a entrada válida), e resulta em um inteiro (ao passo que o mesmo comprimento(s[-1]!='0')
retornaria um boolean).Isso funciona porque o último caractere da entrada,,
s[-1]
será a'0'
,'1'
ou'!'
que possui os pontos de código ASCII 48, 49 e 33, respectivamente, que são 0, 1 e 1 módulo 2.Em
^
seguida, executa uma operação ou exclusiva bit a bit nos dois valores acima, retornando um número inteiro, pois uma entrada, a correta, é um número inteiro. Se a esquerda for True, o complemento da direita será retornado; se a esquerda for False, a direita será retornada, conforme necessário.fonte
Java 7,
1058281 bytesExperimente online!
Solução antiga regex-ish
fonte
c^=1
é super inteligente. Esse é um operador não utilizado, se eu já vi um.CJam ,
1211 bytesExperimente online! Conjunto de testes (imprime a
1
para cada caso de teste correto).fonte
Haskell ,
6765 bytesExperimente online! Uso:
f "!!!0!!!!"
Salvou dois bytes graças a @nimi.
fonte
Brainfuck, 115 bytes
Experimente online!
Ungolfed:
fonte
Lote, 62 bytes
Recebe entrada em STDIN. O lote realmente entende os principais
!
s corretamente para esse desafio, mas os últimos!
precisam ser tratados, o que leva três etapas:0!
para1
!!
(isso também é seguro para os!!
s antes do dígito)!
(que agora só pode ser após a1
)fonte
Fórmula IBM / Lotus Notes - 77 bytes
Não há TIO para a Fórmula do Notes, portanto, uma captura de tela de todos os casos de teste é mostrada abaixo:
Como funciona
@Eval()
avalia uma string como uma expressãoPrimeiro, verificamos se a sequência de entrada no campo (entrada)
a
contém1
ou0
levamos todos os caracteres à esquerda de qualquer que seja, que será uma sequência de!
caracteres. Nós não nos importamos com quantos.@Eval()
vai cuidar disso.A seguir, veremos se existe um
!
no final da string. Se houver, anexamos1
à!
string (0!
e1!
somos ambos 1 - não importa quantos!
caracteres existem no final), caso contrário, anexamos o último caractere inalterado porque não é um!
e pode ser um1
ou a0
.Agora, temos uma sequência contendo as inversões iniciais mais um número definido pela existência de caracteres fatoriais para que possamos alimentar isso
@Eval()
e obter os resultados acima.fonte
sed,
363331 bytesSed puro, sem utilitários bc / shell. Trabalhos em GNU sed <4.3; 33 bytes no BSD e GNU 4.3+.
Simples o suficiente se você estiver familiarizado
sed
; comentou para quem não é:Teste:
fonte
sed
permitem usar a cadeia nula como um nome de rótulo. Se você conseguir que isso funcione aqui, você economizará dois bytes. Na verdade, não tenho certeza se o rótulo é necessário; a menos que eu tenha perdido alguma coisa, a primeira linha é idempotente; portanto, você poderá voltar ao início do programa em vez de precisar de um rótulo.:
(mais um bug usado como recurso); nesse caso, ot
eb
! comandos saltam para a posição do rótulo. Além disso, um código sed deve funcionar para pelo menos uma versão do sed, semelhante a outros idiomas, para que você não precise criar código que funcione também para o BSD.PHP 7.1,
5855543735 bytesNota: usa codificação IBM-850
Execute assim:
Explicação
Tweaks
-R
(que$argn
disponibiliza)fonte
Bean , 24 bytes
Hexdump:
JavaScript equivalente:
Desculpe por pisar no seu pé, Arnauld .
Explicação:
Coloca a primeira linha de entrada como string não formatada
a
e substitui qualquer dígito seguido por um ou mais!
por1
, para que o restante possa ser encontradoeval
por JavaScript.Experimente a demonstração ou a suíte de testes
fonte