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 0ou 1, seguida de zero ou mais !' s ( /!*[01]!*/).
Por exemplo, a entrada pode ser !!!0!!!!ou !!!1ou !0!!ou 0!ou 1.

O !antes 0ou depois das 1negaçõ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 0ou 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.

Mathematica, 25 17 bytes

Input[]/.!x_:>1-x

Recebe 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 !xsobrar um resultado, substituí-lo por 1-x.

Alguns fatos interessantes sobre a avaliação:

1. Na verdade, o Mathematica também possui o operador fatorial duplo !!, que calcula n*(n-2)*(n-4)*..., mas é aplicado a 0ou 1ainda fornece 1, portanto, não importa que 0!!!!!seja realmente analisado ((0!!)!!)!.
2. Embora o Mathematica saia !0e !1não seja avaliado, ele sabe que !é auto-inverso e, por isso, cancela automaticamente todos os pares de liderança !. Depois do ToExpressionque estamos sempre deixou com um dos 0, 1, !0, !1.

[Bash] + Utilitários Unix, 21 17 bytes

sed s/.!!*$/1/|bc

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

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0

Retina , 20 15 14 bytes

Agradecemos a Leo por economizar 1 byte.

0!
1
!!

^1|!0

Experimente online!

Explicação

0!
1

Transformar 0!em 1. 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.

^1|!0

Conte o número de correspondências dessa regex, que é ou 1ou 0e fornece o resultado desejado.

Grime , 14 12 9 bytes

e`\0!~\!_

Experimente online!

Explicação

Isso corresponde à entrada em relação a um padrão, imprimindo 1para correspondência e 0sem correspondência.

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

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 único 0. O xor deles é bem-sucedido, a menos que a entrada seja única 0. 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.

Brainfuck, 85 72 (84) bytes

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

para retornar numericamente ou

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

para texto ASCII. > também pode ser prefixado para evitar quebra de memória.

Experimente online!

Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

Ou, para resposta em texto, substitua a última linha por

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return

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 .

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

Python, -44- 42 bytes

Economizou 2 bytes graças ao Zgarb!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

Passo a passo:

1. x[-1]!='0'
   se xtermina com 1ou !⇔ xnão termina com 0, a parte fatorial deve ter valor 1, caso contrário0
2. ^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, .rstripnão remove o número da sequência, portanto o comprimento calculado é compensado por 1; portanto, a condição é invertida
3. O deslocamento de 1 na etapa 2 é corrigido alterando !=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!

JavaScript (ES6), 43 41 29 bytes

s=>+eval(s.replace(/.!+$/,1))

Método não regex ( 41 31 bytes)

Abaixo está minha abordagem inicial. É um pouco mais interessante, mas significativamente mais longo ainda mais após uma otimização significativa do Neil (10 bytes salvos) .

f=([c,...s])=>1/c?c|s>'':1-f(s)

Casos de teste

let f =

s=>+eval(s.replace(/.!+$/,1))

;[
  "0", "1", "0!", "1!", "!0", "!1", "!0!", "!1!", "0!!",
  "1!!", "!!0", "!!1", "!0!!", "!!!1", "!!!0!!!!", "!!!1!!!!"
].map(
  s => console.log(s, '=>', f(s))
)

Geléia , 5 bytes

VeMḂ$

Experimente online!

Função monádica esperando uma string. Entradas com !s iniciais fazem com que 1a 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?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.

05AB1E , 9 bytes

Código:

.V¹'!ÜgG_

Usa a codificação CP-1252 . Experimente online! ou Verifique todos os casos de teste!

Explicação:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number

Retina , 13 bytes

Uma abordagem um pouco estranha, mas é curta e funciona.

0$
!1
!!

^\d

Nas duas primeiras linhas, substituímos um final 0por !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!

Ruby, 12 + 1 = 39 24 15 13 bytes

Usa a -nbandeira. Graças a @GB por -9 bytes!

p~/!*$|0$/%2

Perl , 20 bytes

19 bytes de código + -psinalizador.

s/\d!+/1/;$_=0+eval

Experimente online!

A negação de Perl retorna undefou 1, então eu uso 0+para numerar os 0+undefretornos do resultado 0. Além disso, não há muito a dizer sobre o código.

C, 68 62 61 53 bytes

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

Espremido mais alguns bytes com algum abuso

Experimente online!

Perl 6 , 32 28 23 bytes

{m/(\!)*(1|0.)*/.sum%2}

Como funciona

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.

Haskell , 39 bytes

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

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.

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.

Befunge, 24 bytes

~"!"-:#v_$1+
*+2%!.@>0~`

Experimente online!

Isso começa contando o número de !caracteres lidos no stdin. O primeiro caractere que não é a !será 0ou 1, 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:

!((c + d*e) % 2)

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 um 1(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ão 0e 1são o oposto do que precisamos.

Observando o código com mais detalhes:

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.

Haskell , 27 bytes

f('!':b)=1-f b
f"0"=0
f _=1

Experimente online!

Cada líder !complementa a saída para o restante da expressão, feita como 1-. Continuamos lançando até atingir um dígito. Se o restante for justo "0", o resultado será 0. Caso contrário, é um 1ou é seguido por um ou mais !, portanto, o resultado é 1.

Ruby, 22 21 20 bytes

->s{(s=~/!*$|0$/)%2}

Explicação:

• Primeiro caso, eu tenho alguns '!' no final, remova-os, obtenha o comprimento módulo 2.
• Segundo caso, não '!', Se o último caractere for zero, remova-o, obtenha o comprimento módulo 2
• Se o último caractere for 1, volte ao primeiro caso

(-1 byte roubando a idéia da @Value Ink)

Gelatina , 8 bytes

œr”!LḂ=V

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

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

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 simples eval( 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.

Python, 38 bytes

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

TryItOnline!

Uma função sem nome que pega uma sequência de entrada se retorna um número inteiro 0ou 1.

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 simples s.index(max(s))%2.

As ord(s[-1])%2verificaçõ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.

Java 7, 105 82 81 bytes

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

Experimente online!

Solução antiga regex-ish

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}

CJam , 12 11 bytes

r_W='0=!\~;

Experimente online! Conjunto de testes (imprime a 1para cada caso de teste correto).

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.

Haskell , 67 65 bytes

f s|foldr(\_->not)(last s`elem`"1!")$fst.span(<'0')$s="1"|1<3="0"

Experimente online! Uso:f "!!!0!!!!"

Salvou dois bytes graças a @nimi.

Brainfuck, 115 bytes

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

Experimente online!

Ungolfed:

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]

Lote, 62 bytes

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

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:

• Mude 0!para1
• Excluir pares de !!(isso também é seguro para os !!s antes do dígito)
• Excluir qualquer restante restante !(que agora só pode ser após a 1)

Fórmula IBM / Lotus Notes - 77 bytes

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

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ão

Primeiro, verificamos se a sequência de entrada no campo (entrada) acontém 1ou 0levamos 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, anexamos 1à !string ( 0!e 1!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 um 1ou a 0.

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.

sed, 36 33 31 bytes

Sed puro, sem utilitários bc / shell. Trabalhos em GNU sed <4.3; 33 bytes no BSD e GNU 4.3+.

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

Simples o suficiente se você estiver familiarizado sed; comentou para quem não é:

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

Teste:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%

PHP 7.1, 58 55 54 37 35 bytes

Nota: usa codificação IBM-850

echo!!$argn[-1]^strspn($argn,~Ì)%2;

Execute assim:

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

Explicação

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

Tweaks

• Salva 3 bytes usando a codificação IBM-850
• Salvo um byte, alterando ligeiramente a regex
• Salva 17 bytes, nova versão sem nomes longos de funções e retorna
• 2 bytes salvos usando -R(que $argndisponibiliza)

Bean , 24 bytes

Hexdump:

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

JavaScript equivalente:

+eval(a.replace(/.!+$/,1))

Desculpe por pisar no seu pé, Arnauld .

Explicação:

Coloca a primeira linha de entrada como string não formatada ae substitui qualquer dígito seguido por um ou mais! por 1, para que o restante possa ser encontrado evalpor JavaScript.

Experimente a demonstração ou a suíte de testes