Introdução

Todos os anos, a Dyalog Ltd. realiza uma competição estudantil. O desafio é escrever um bom código APL. Esta é uma edição de código-golfe independente de idioma do oitavo problema deste ano.

Tenho permissão explícita para postar esse desafio aqui, do autor original da competição. Sinta-se livre para verificar, seguindo o link fornecido e entrando em contato com o autor.

Problema

Dada uma lista booleana *, "desative" todas as verdades após a primeira verdade.

Sem verdades? Sem problemas! Basta retornar a lista sem modificações.

Exemplos

[falsy,truthy,falsy,truthy,falsy,falsy,truthy] → [falsy,truthy,falsy,falsy,falsy,falsy,falsy]

[] → []

[falsy,falsy,falsy,falsy] → [falsy,falsy,falsy,falsy]

* Todas as suas verdades devem ser idênticas e todas as suas falsidades devem ser idênticas. Isso inclui saída.

Python 2 , 35 bytes

while 1:b=input();print b;True&=b<1

Experimente online! Entrada e saída são linhas de Verdadeiro / Falso.

Baseado na solução de Dennis . Redefine a variável Truea ser Falsedepois que uma Trueentrada é encontrada. Dessa forma, qualquer entrada adicional Trueserá avaliada Falsee impressa como tal.

A redefinição é True&=b<1, ie True = True & (b<1). Quando a entrada bé True, então (b<1)é False (since True==1), então Truese torna False.

APL , 2 bytes

<\

Avalia a função "varredura usando menor que". Experimente online!

Explicação

No APL, o operador \(varredura) reduz cada prefixo não vazio de uma matriz da direita, usando a função fornecida. Por exemplo, dado o array 0 1 0, ele calcula 0(prefixo do comprimento 1), 0<1(prefixo do comprimento 2) e 0<(1<0)(prefixo do comprimento 2) e coloca os resultados em um novo array; os parênteses se associam à direita. A redução <da direita resulta 1exatamente quando o último elemento da matriz é 1e o restante é 0, portanto, o prefixo correspondente à extremidade esquerda 1é reduzido 1e os demais a 0.

Aceto , 19 17 bytes não concorrente

Nova versão (17 bytes):

Esta nova versão leva os caracteres um de cada vez e é melhor executada com a -Fopção Funciona de maneira semelhante, mas não idêntica à solução anterior:

 >,
Op0
p|1u
,ip^

Resposta antiga (19 bytes):

(Não concorrente porque tive que corrigir dois erros no intérprete)

|p1u
iOp<
|!`X
rd!r

Esta é a primeira resposta do Aceto que destaca o que ele pode fazer relativamente bem, eu diria. As "listas" são fluxos de entrada, com uma entrada por linha, "1" para verdadeiro e "0" para falso, com uma sequência vazia significando o fim da lista.

Os programas Aceto são executados em uma curva de Hilbert, começando no canto inferior esquerdo e terminando no canto inferior direito. Primeiro, nós ramarramos uma string, duplicamos e a negamos ( !), transformando strings vazias em True, e todo o resto em False. Depois, há um espelho horizontal condicional ( |): se o elemento superior da pilha for verdadeiro, espelhe horizontalmente. Isso acontece quando a string estava vazia. Se fizermos o espelhamento, aterrissaremos no X, que mata o intérprete.

Caso contrário, convertemos a cópia restante na pilha em um integer e fazemos outro espelho horizontal condicional: Dessa vez, porque 1 é verdadeiro e 0 é falso, espelhamos se vemos o (primeiro) valor verdadeiro. Se não espelhamos (então vimos um 0), criamos o pque está na pilha (já que a pilha está vazia, um zero) e pulamos para a Origidez da curva, onde começamos, iniciando todo o processo novamente.

Caso contrário, quando vimos um 1, espelhamos e pousamos no u, o que inverte a direção em que nos movemos na curva de Hilbert. 1pimprime um 1, e agora continuamos da mesma maneira Oque teríamos se tivéssemos visto um 0, mas como estamos no "modo reverso", nossa origem está no canto inferior direito , então pulamos para lá.

Agora, rlemos outra corda e a negamos. Se a seqüência estava vazio e, portanto, o elemento superior da pilha é truthy, `vai não escapar o próximo comando ( X), fazendo-nos sair.

Caso contrário (se a cadeia não estava vazio), nós não escapar do Xe ignorá-lo. Nesse caso, vamos para a esquerda ( <), print 0 (porque a pilha está vazia) e retornamos ao Origin.

Java8, 24 19 bytes

Long::highestOneBit

Espero que isso seja legal; Tive a impressão de que a entrada / saída não precisa ser avaliada como verdadeira / falsa no idioma. Leva um tempo como entrada e fornece um como saída, com uns sendo verdadeiros e zeros sendo falsos na representação binária. Por exemplo, o binário 00101 é 5 e retornaria o binário 00100, que é 4.

Cinco bytes graças a @puhlen

Retina , 6 bytes

1>`1
0

Experimente online!

Entrada é uma lista de 0s (para Falso) 1es (para Verdadeiro).

Corresponde a todos 1e substitui cada um, exceto o primeiro ( 1>) por a 0.

V , 7 bytes

f1òf1r0

Experimente online!

Minha primeira submissão em V! \ o /

Como funciona

f1òf1r0
f1       "go to the next occurence of 1
  ò      "repeat the following until end:
   f1    "    go to the next occurence of 1
     r0  "    replace with 0

Haskell , 25 bytes

Função anônima recebendo e retornando uma lista de Bools.

Use como (foldr(\x l->x:map(x<)l)[])[False,True,False,False].

foldr(\x l->x:map(x<)l)[]

Experimente online!

Como funciona

• Dobra uma lista da direita, acrescentando novos elementos e possivelmente modificando os seguintes.
• xé o elemento a ser anexado à sublist l.
• Usos que Falsecompara menos do que True, por isso map(x<)lvai se transformar qualquer Trues em lem Falsese xé True.

Gelatina , 4 bytes

+\=a

Experimente online!

Aqui está um algoritmo bastante diferente da maioria das outras soluções de linguagem de golfe (embora depois que eu o publiquei, notei que a solução R também usa esse algoritmo) e vincule-o ao atual detentor de registro do Jelly.

Explicação

+\=a
+\    Cumulative sum of the input list
  =   Compare corresponding elements with the input
   a  Logical AND corresponding elements with the input

Desde que todos os elementos à esquerda de um elemento sejam 0, a soma acumulada até um elemento será igual ao próprio elemento. À direita do primeiro 1, os dois são diferentes (porque agora estamos adicionando o total diferente de zero dos elementos à esquerda). Assim, +\=nos fornece uma lista contendo 1 (ou seja, verdadeiro) até e incluindo o primeiro elemento de verdade. Finalmente, AND lógico com a lista original nos dará um 1 apenas para o primeiro elemento de verdade.

JavaScript (ES6), 33 26 bytes

a=>a.map(e=>e&!(i-=e),i=1)

A E / S está em matrizes de 0s e 1s.

05AB1E , 6 bytes

Código:

ā<s1kQ

Explicação:

ā         # External enumeration, get a and push [1 .. len(a)]
 <        # Decrement each
  s       # Swap to get the input
   1k     # Get the first index of 1
     Q    # Check for equality with the enumeration array

Usa a codificação 05AB1E . Experimente online!

Simulador de máquina de Turing , 39 bytes

0 0 0 r 0
0 1 1 r 1
1 0 0 r 1
1 1 0 r 1

Experimente online!

brainfuck , 55 bytes

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

Experimente online!

Gelatina , 4 bytes

Uma porta da minha resposta 05AB1E.

i1=J

Explicação (argumento α ):

i1        # Index of 1 (1-indexed) in α
  =       # Check for equality with the array:
   J      # [1 .. len(α)]

Experimente online!

R , 24 bytes

cumsum(T<-scan(,F))==T&T

Experimente online!

Exemplo:

Para FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tretornos de entrada TRUE TRUE FALSE FALSE. OF na varredura garante entrada lógica.
FALSE TRUE TRUE FALSEe TRUE TRUE FALSE FALSEé FALSE TRUE FALSE FALSE. Um single &faz uma comparação elementar.

Oitava, 23 bytes

@(a)diff([0 cummax(a)])

Experimente online!

Primeira diferença do máximo cumulativo da lista.

J , 3 bytes

</\

Define um verbo monádico. Esta é uma porta trivial da minha resposta APL . Experimente online!

Python, 58 bytes

lambda x:[x[i]and x.index(x[i])==i for i in range(len(x))]

Se x[i]for falso, a saída é falsa; caso contrário, indica se o elemento é ou não a primeira ocorrência na matriz em si.

PHP, 37 bytes

foreach($_GET as$v)echo$v*!$$v++,' ';

Perl 5, 20 bytes

sub{map$_&&!$x++,@_}

Verdade é 1e Falsey é ''(uma string vazia).

Explicação:

mapfaz um loop sobre os elementos da lista @_, os argumentos passados ​​para a sub-rotina, definindo cada elemento como $ _ localmente e retornando uma matriz dos valores de retorno que calcula de cada elemento. $_&&!$x++produz $_se $_for falsey e !$x++se for verdade. (Observe que && está em curto-circuito, portanto, !$x++não é executado até que o primeiro valor de verdade seja atingido). $x++retorna 0(que é falsey) na primeira vez em que é executado e depois aumenta a cada vez (e assim permanece verdadeiro). O !nega $x++, e assim retorna verdadeiramente na primeira vez que é encontrado e desaparece depois disso.

Pitão - 9 bytes

.e&b!s<Qk

Experimente aqui

.e&b!s<Qk
.e          # Python's 'enumerate' (i.e., for each index k and each element b at that index)
      <Qk   # The first k elements of the input
     s      # 'Sum' these first k elements (with booleans, this is a logical 'or')
  &b!       # The value of the output at index k is [value of input @ index k]&&[the negation of the 'sum']

Python 2 , 45 36 bytes

r=0
while 1:n=input();print n>r;r+=n

Entrada e saída são um Booleano ( Verdadeiro ou Falso ) por linha.

Experimente online!

C #, 77 bytes

a=>{var b=1<0;for(int i=0;i<a.Length;){a[i]=b?1<0:a[i];b|=a[i++];}return a;};

Compila para um Func<bool[], bool[]>. Nada realmente inteligente, apenas uma solução direta.

sed , 16 19 bytes

15 código de origem de 18 bytes + 1 byte para o sinalizador -r (ou o sinalizador -E para BSD sed).

:
s/1(0*)1/1\10/
t

Experimente online!

Edit: Obrigado Riley por apontar um erro.

Gelatina , 4 bytes

TḊṬ^

Experimente online!

Quão?

Isso faz o que foi solicitado em um sentido bastante literal:

TḊṬ^ - Main link: list a   e.g. [0,1,0,1,0,0,1]  or  [0,1,0,1,0,1,0]
T    - get the truthy indexes   [  2,  4,    7]      [  2,  4,  6  ]
 Ḋ   - dequeue                  [      4,    7]      [      4,  6  ]
  T  - make a boolean array     [0,0,0,1,0,0,1]      [0,0,0,1,0,1  ]
   ^ - XOR that with a          [0,1,0,0,0,0,0]      [0,1,0,0,0,0,0]

c (com built-in gcc), 40

Uma abordagem ligeiramente diferente:

f(n){return!n?0:1<<31-__builtin_clz(n);}

Isso pode ser considerado inválido - caso em que, felizmente, marcarei isso como não concorrente.

"Matrizes" de entrada e saída são números inteiros não assinados de 32 bits - isso limita o tamanho da lista de entrada a exatamente 32 - pode ser um desqualificador. Se a entrada tiver menos de 32 bits, poderá ser preenchida com zero bits no final.

Experimente online .

Lote, 85 73 bytes

:a
@(if %1.==. exit)&set/ar=(1-f)*%1
@echo %r%&set/af^|=%1&shift&goto a

Recebe entrada como argumentos de linha de comando. Por exemplo:1.bat 0 1 0 1 0 0 1

Versão anterior

@set f=1
:a
@(if %1.==. exit)&set/ar=f*%1
@echo %r%&(if %1==1 set f=)&shift&goto a

Flacidez cerebral , 230 bytes

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

Vou explicar em breve, mas minha mãe me cozinhou algumas batatas fritas

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> Subtracts one from every item

({<({}<>)<>>()}<(())>){({}[()]<<>({}<>)>)}{} Loops down stack until current item is zero and adds one

(([])<{{} (({})())({<{}>{}((<()>))}<{}{}>) ({}<>)<>([])}<>>){({}[()]<({}<>)<>>)}{}<> On every item of stack if it is 0 do nothing and if it is -1 add one

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

{}{} Remove the two zeros at top of stack

([]){{}({}<>)<>([])}{}<> Flip stack back

Experimente online!

Agradecimentos especiais

Agradecimentos especiais ao Wheat Wizard e Riley por me ajudarem bastante com o código!

Python 3, 69 66 64 60 54 53 bytes

lambda i:[k==i.index(j)and j for k,j in enumerate(i)]

Leva uma matriz de falses e trues. Essa é uma compreensão da lista de falses, exceto se o valor da iteração atual for truee for o primeiro truena entrada.

Parece um pouco longo (e é o meu primeiro lambda), por isso, se você encontrar uma maneira de jogar golfe, seria muito apreciado!

Flacidez Cerebral , 146 144 bytes

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

Experimente online!

# Reverse the stack and add a 1 between each to help with reversing later
([]){{}({}<>)(())<>([])}{}<>

# Add a 1 in case there aren't any truthy values (and another 1 like before)
((()))

# Reverse the stack back to it's original order using the 1s from earlier to know when to stop
{{}({}<>)<>}{}<>

# Push 1 to start the loop
(())

# Until we find the first 1
{

 # Pop the last value
 {}

 # Logical not
 ((){[()](<{}>)}{})

  # Put a 0 on the other stack
  (<>)<>

# end loop
}

# Put a 1 on the other stack
<>(())<>

# Push the stack height
([])

# While there are values on this stack
{

 # Move them to the other stack as a 0
 {}(<{}<>>)<>([])

# End while
}{}

# Pop an extra 0
{}

# Switch stacks
<>

# Copy everything back (to reverse it back to it's original)
([])
{
 {}({}<>)<>([])
}<>{}

Perl 5 , 12 bytes

Código de 10 bytes + 2 para -pl.

$_&&=!$-++

Experimente online!