Intro

Chaque année, Dyalog Ltd. organise un concours d’étudiants. Le défi consiste à écrire un bon code APL. Il s'agit d'une édition code-golf indépendante du langage et du huitième problème de cette année.

J'ai la permission explicite de poster ce défi ici de l'auteur original du concours. N'hésitez pas à vérifier en suivant le lien fourni et en contactant l'auteur.

Problème

Avec une liste booléenne *, "éteignez" toutes les vérités après la première vérité.

Aucune vérité? Aucun problème! Il suffit de retourner la liste non modifiée.

Exemples

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

[] → []

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

* Toutes vos vérités doivent être identiques et toutes vos fausses doivent être identiques. Cela inclut la sortie.

Python 2 , 35 octets

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

Essayez-le en ligne! L'entrée et la sortie sont des lignes True / False.

Basé sur la solution de Dennis . Redéfinissent la variable Trued'être Falseaprès une Trueentrée est rencontrée. De cette façon, toute autre entrée de Truesera évaluée Falseet imprimée en tant que telle.

La redéfinition est True&=b<1, à savoir True = True & (b<1). Lorsque l'entrée best True, (b<1)False (depuis True==1) Truedevient ainsi False.

APL , 2 octets

<\

Evalue à la fonction "numériser avec moins que". Essayez-le en ligne!

Explication

Dans APL, l'opérateur \(scan) réduit chaque préfixe non vide d'un tableau en utilisant la fonction fournie. Par exemple, étant donné le tableau 0 1 0, il calcule 0(préfixe de longueur 1), 0<1(préfixe de longueur 2) et 0<(1<0)(préfixe de longueur 2) et place les résultats dans un nouveau tableau; les parenthèses s'associent à droite. Réduire par <de la droite a pour résultat le 1moment exact où se 1trouvent le dernier élément du tableau et le reste 0, ainsi le préfixe correspondant au plus à gauche 1est réduit à 1et les autres à 0.

Aceto , 19 17 octets non concurrents

Nouvelle version (17 octets):

Cette nouvelle version prend les caractères un par un et est mieux exécutée avec l' -Foption. Cela fonctionne de manière similaire, mais pas identique à la solution précédente:

 >,
Op0
p|1u
,ip^

Ancienne réponse (19 octets):

(Non compétitif car j'ai dû corriger deux bugs dans l'interprète)

|p1u
iOp<
|!`X
rd!r

C’est la première réponse Aceto qui souligne ce qu’elle peut faire relativement bien, je dirais. Les "listes" sont des flux d'entrée, avec une entrée par ligne, "1" pour vrai et "0" pour faux, avec une chaîne vide indiquant la fin de la liste.

Les programmes Aceto fonctionnent sur une courbe de Hilbert, commençant en bas à gauche et se terminant en bas à droite. Premièrement, nous rlisons une chaîne, nous la dmettons en uplicate et la nions ( !), transformant les chaînes vides en True, tout le reste en False. Ensuite, il y a un miroir horizontal conditionnel ( |): si l'élément supérieur de la pile est la vérité, faites-le miroir horizontalement. Cela se produit lorsque la chaîne était vide. Si nous procédons en miroir, nous atterrissons sur le Xqui tue l’interprète.

Sinon, nous convertissons la copie restante de la pile en un ientier et faisons un autre miroir horizontal conditionnel: Cette fois, parce que 1 est la vérité et 0 est la fausseté, nous reflétons si nous voyons la (première) valeur vraie. Si nous ne reflétons pas (nous avons donc vu un 0), nous pimprimons ce qu'il y a sur la pile (puisque la pile est vide, un zéro) et Opassons à la rigin de la courbe, à l'endroit où nous avons commencé, en recommençant tout le processus.

Sinon, lorsque nous voyons un 1, nous reflétons et atterrissons sur la u, ce qui inverse la direction dans laquelle nous nous déplaçons sur la courbe de Hilbert. 1paffiche un 1, et maintenant nous suivons le même chemin que Osi nous avions vu un 0, mais puisque nous sommes en "mode inversé", notre origine est en bas à droite , nous sautons donc là.

Maintenant nous rlisons une autre chaîne et la nions. Si la chaîne était vide, et donc de la résistance de la pile est truthy, `ne pas échapper à la commande suivante ( X), nous faire arrêter de fumer.

Dans le cas contraire (si la chaîne n'a pas été vide), nous n'échapper à la et l' ignorer. Dans ce cas, nous allons à gauche ( ), rint 0 (car la pile est vide), et retournons à la rigin.X<pO

Java8, 24 19 octets

Long::highestOneBit

J'espère que c'est légal; J'ai l'impression que les entrées / sorties ne doivent pas être évaluées comme vraies / fausses dans la langue. Prend un long comme entrée et en donne un comme sortie, avec les vrais et les zéros faux dans la représentation binaire. Par exemple, binaire 00101 est 5 et renverrait binaire 00100, qui est 4.

Cinq octets grâce à @puhlen

Retina , 6 octets

1>`1
0

Essayez-le en ligne!

L'entrée est une liste de 0s (pour False) et de 1s (pour True).

Correspond à tous 1et remplace chacun sauf le premier ( 1>) par un 0.

V , 7 octets

f1òf1r0

Essayez-le en ligne!

Ma première soumission en V! \ o /

Comment ça fonctionne

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 octets

Fonction anonyme prenant et renvoyant une liste de Bools.

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

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

Essayez-le en ligne!

Comment ça fonctionne

• Se plie sur une liste en partant de la droite, ajoutant de nouveaux éléments et éventuellement modifiant ceux qui suivent.
• xest l'élément à ajouter à la sous-liste l.
• Les utilisations qui Falsecomparent moins que True, map(x<)ltransformeront tout Trues len Falsesi xest True.

Gelée , 4 octets

+\=a

Essayez-le en ligne!

Voici un algorithme assez différent de la plupart des autres solutions linguistiques de golf (bien que, après l'avoir posté, j'ai remarqué que la solution R utilisait également cet algorithme) et lié au détenteur actuel du record Jelly.

Explication

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

Tant que tous les éléments à gauche d'un élément sont 0, la somme cumulative d'un élément sera égale à l'élément lui-même. À droite du premier 1, les deux sont différents (car nous ajoutons maintenant le total non nul des éléments à gauche). Ainsi, +\=nous donne une liste contenant 1 (c'est-à-dire vrai) jusqu'au premier élément de vérité inclus. Enfin, ET logique avec la liste initiale nous donnera 1 pour que le premier élément de truthy.

JavaScript (ES6), 33 à 26 octets

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

I / O est dans les tableaux de 0 et 1.

05AB1E , 6 octets

Code:

ā<s1kQ

Explication:

ā         # 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

Utilise le codage 05AB1E . Essayez-le en ligne!

Simulateur de machine de Turing , 39 octets

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

Essayez-le en ligne!

brainfuck , 55 octets

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

Essayez-le en ligne!

Gelée , 4 octets

Un port de ma réponse 05AB1E.

i1=J

Explication (argument α ):

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

Essayez-le en ligne!

R , 24 octets

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

Essayez-le en ligne!

Exemple:

Pour les FALSE TRUE TRUE FALSE
cumsum(T<-scan(,F))==Tretours d' entrée TRUE TRUE FALSE FALSE. Le F dans le balayage assure une entrée logique.
FALSE TRUE TRUE FALSEet TRUE TRUE FALSE FALSEest FALSE TRUE FALSE FALSE. Un seul &fait une comparaison élémentaire.

Octave, 23 octets

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

Essayez-le en ligne!

Première différence de maximum cumulatif de la liste.

J , 3 octets

</\

Définit un verbe monadique. Ceci est un port trivial de ma réponse APL . Essayez-le en ligne!

Python, 58 octets

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

Si x[i]est faux, la sortie est fausse; sinon, cela indique si l'élément est ou non la première occurrence dans le tableau de lui-même.

PHP, 37 octets

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

Perl 5, 20 octets

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

La vérité est 1et Falsey est ''(une chaîne vide).

Explication:

mapboucle sur les éléments de la liste it @_, les arguments passés au sous-programme, définissant chaque élément sur $ _ localement et renvoyant un tableau des valeurs de retour calculées à partir de chaque élément. $_&&!$x++sorties $_si $_est falsey et !$x++si c'est la vérité. (Notez que && est en court-circuit et !$x++n'est donc exécuté que lorsque la première valeur de vérité est atteinte). $x++retourne 0(ce qui est falsey) la première fois qu'il est exécuté, puis incrémente à chaque fois (et reste donc la vérité). La !négation $x++, et donc il renvoie la vérité la première fois qu'il est rencontré et falsey par la suite.

Pyth - 9 octets

.e&b!s<Qk

Essayez-le ici

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

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

L'entrée et la sortie correspondent à un booléen ( vrai ou faux ) par ligne.

Essayez-le en ligne!

C #, 77 octets

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

Compile a Func<bool[], bool[]>. Rien d'intelligent, juste une solution simple.

sed , 16 19 octets

15 18 octets code source + 1 octet pour l'indicateur -r (ou l'indicateur -E pour BSD sed).

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

Essayez-le en ligne!

Edit: Merci Riley pour avoir signalé une erreur.

Gelée , 4 octets

TḊṬ^

Essayez-le en ligne!

Comment?

Cela fait ce qui a été demandé dans un sens littéral:

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 (avec les commandes gcc), 40

Une approche légèrement différente:

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

Cela peut être considéré comme invalide - dans ce cas, je marquerai volontiers ceci comme non compétitif.

Les "tableaux" d'entrée et de sortie sont des entiers non signés de 32 bits - ceci limite la taille de la liste d'entrée à exactement 32 - cela peut être un disqualifiant. Si l'entrée a moins de 32 bits de long, elle peut être complétée avec zéro bit à la fin.

Essayez-le en ligne .

Lot, 85 73 octets

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

Prend l'entrée en tant qu'arguments de ligne de commande. Pour exemple:1.bat 0 1 0 1 0 0 1

La version précédente

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

Brain-Flak , 230 octets

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

J'expliquerai bientôt mais ma mère m'a cuisiné des pommes de terre frites

([]){{}({}[()]<>)<>([])}{}<>([]){{}({}<>)<>([])}{}<> 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

Essayez-le en ligne!

Remerciement spécial

Un merci spécial à Wheat Wizard et à Riley de m'avoir aidé énormément avec le code!

Python 3, 69 66 64 60 54 53 octets

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

Prend un tableau de falses et trues. Ceci est une compréhension de la liste de falses sauf si la valeur de l'itération en cours est trueet qu'elle est la première truede l'entrée.

Cela semble un peu long (et c'est mon premier lambda), donc si vous pouviez trouver un moyen de jouer au golf, ce serait grandement apprécié!

Brain-Flak , 146 144 octets

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

Essayez-le en ligne!

# 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 octets

10 octets code + 2 pour -pl.

$_&&=!$-++

Essayez-le en ligne!