Un joli simple

Contribution

Étant donné un tableau booléen (ou une alternative acceptable), vous pouvez supposer que le tableau ne comportera jamais plus de 32 éléments.

[false, false, true, false, false]

Production

Inversez chaque élément du tableau et affichez-le.

[true, true, false, true, true]

Règles

• Vous pouvez écrire un programme complet ou juste une fonction
• Des échappatoires standard s'appliquent
• Le code le plus court en octets, par langue, gagne!

Cas de test

Input:
[true, false]
Output:
[false, true]

Input: //Example of acceptable alternative
[0,1,1]
Output:
[1,0,0]

05AB1E , 1 octet

Code:

_

Explication:

_     # Logical not

Essayez-le en ligne!

Gelée , 1 octet

¬

Essayez-le en ligne!

¬est NON logique (1 si faux-y, sinon 0). C(«Complément», 1-z ) fonctionne également.

Javascript ES6, 15 octets

a=>a.map(b=>!b)

Pas beaucoup d'explications nécessaires je suppose

f=
a=>a.map(b=>!b)

a.innerHTML = `[true, false, 1, 0] => ${ f([true, false, 1, 0]) }`

<pre id=a>

Matlab, 4 1 octet

Cela devrait être explicite.

~

Matlab a l'opérateur de négation à un octet ~, si vous voulez une fonction que vous pouvez utiliser @not.

Haskell, 7 octets

map not

Exemple:

Prelude> (map not) [False, True, True]
[True,False,False]

MATL , 1 octet

~

Essayez-le en ligne!

~est le non logique et comme de nombreuses fonctions, il peut également être appliqué à des tableaux / matrices.

C, 46 octets version récursive

f(char*s){*s?putchar(*s&72?*s:*s^1),f(++s):0;}

C, 47 octets version itérative

f(char*s){for(;*s;putchar(*s&72?*s:*s^1),s++);}

Exécuter à l'aide de cette fonction principale

main(c,v)char**v;
{
    f(v[1]);
}

et entrer comme ça

a.exe [1,0,1,1,0]
[0,1,0,0,1]

R, 1 octet

!

Exemple:

> !c(TRUE, FALSE)
[1] FALSE  TRUE

Il fonctionne également avec une entrée numérique:

> !c(1, 0)
[1] FALSE  TRUE

Nous ne sommes pas non plus limités aux tableaux unidimensionnels. Faisons une matrice et remplissons-la au hasard avec des 0 et des 1:

> mat = matrix(rbinom(16, 1, .5), ncol=4)
> mat
     [,1] [,2] [,3] [,4]
[1,]    0    1    1    1
[2,]    0    1    0    0
[3,]    0    0    0    0
[4,]    1    1    1    0

Nous pouvons inverser cela tout aussi facilement:

> !mat
      [,1]  [,2]  [,3]  [,4]
[1,]  TRUE FALSE FALSE FALSE
[2,]  TRUE FALSE  TRUE  TRUE
[3,]  TRUE  TRUE  TRUE  TRUE
[4,] FALSE FALSE FALSE  TRUE

Nous pouvons continuer à le faire pour un nombre arbitraire de dimensions. Voici un exemple sur un tableau à quatre dimensions:

> bigarray = array(rbinom(32, 1, 0.5), dim=c(2,2,2,2))
> bigarray
, , 1, 1

     [,1] [,2]
[1,]    0    0
[2,]    0    0

, , 2, 1

     [,1] [,2]
[1,]    1    0
[2,]    0    0

, , 1, 2

     [,1] [,2]
[1,]    0    1
[2,]    0    1

, , 2, 2

     [,1] [,2]
[1,]    1    0
[2,]    1    1

> !bigarray
, , 1, 1

     [,1] [,2]
[1,] TRUE TRUE
[2,] TRUE TRUE

, , 2, 1

      [,1] [,2]
[1,] FALSE TRUE
[2,]  TRUE TRUE

, , 1, 2

     [,1]  [,2]
[1,] TRUE FALSE
[2,] TRUE FALSE

, , 2, 2

      [,1]  [,2]
[1,] FALSE  TRUE
[2,] FALSE FALSE

Ne fonctionne pas pour les personnages, je le crains.

> !"Hello world"
Error in !"Hello world" : Invalid argument type.

Perl 6 , 4 octets

Version "française" / Unicode:

!«*

Version "Texas" / ASCII:

!<<*

L'entrée est une valeur unique qui peut être traitée comme une liste.

C'est aa Quel que soit lambda ( *) avec l' opérateur logique non prefix ( !) combiné en utilisant prefix hyper operator ( «) .

En fait, c'est la même chose que:

-> $_ { $_.values.hyper.map: &prefix:<!> }
# ( currently the Rakudo implementation doesn't actually do the ｢.hyper｣ call,
#   but prefix ｢«｣ is specifically designated for doing things in parallel )

Usage:

# pretend it's a method
say (True,False,True,True).&( !«* );
# (False True False False)

say ( !«* )( (False,False,True,False,False) );
# (True True False True True)


# give it a lexical name
my &list-invert = !«*;

#              v¯¯ a space is necessary here
say list-invert (True,False);
# (False True)

say (False,True).&list-invert;
# (True False)

Labyrinthe , 9 octets

,$:)%#$.,

Essayez-le en ligne! Suppose une entrée séparée par une nouvelle ligne avec une nouvelle ligne de fin. Merci à @MartinEnder pour son aide au golf.

Ce programme est un peu bizarre pour un programme Labyrinth - il n'utilise pas la nature 2D du langage, et il rebondit en fait. Lors du premier voyage en avant, nous avons:

[Moving rightward]
,            Read char c of input
 $           XOR c with implicit 0 at bottom of stack
  :)%        Calculate c % (c+1), erroring out if c == -1 from EOF, otherwise returns c
     #$      XOR with (length of stack == 1)
       .     Output (c^1) as char
        ,    Read newline

[Moving leftward]
       .     Output newline
      $      XOR two implicit 0s, stack [0]
    %#       Mod with (length of stack == 1), giving stack [0]
 $:)         Increment, duplicate then XOR, stack still [0]
,            Read char c of input

L'occurrence suivante de $XOR puis le 0 existant sur la pile avec c, par opposition à un 0 implicite au bas de la pile comme lors de la première exécution. Les deux situations laissent la pile telle quelle [c]et le programme se répète par la suite.

Alternative 9 octets:

,:):/$.:,
,::)/)$.,
,:):%)$.,

Mathematica, 7 octets

Not/@#&

ou sans lettres:

!#&/@#&

Quant au sucre syntaxique: &marque l'extrémité droite d'une fonction sans nom et a une très faible priorité. #fait référence au premier argument du plus proche et englobant &. !est l'opérateur pour Not. Il ne !#&s'agit donc que d'une fonction sans nom qui nie son argument, en d'autres termes, elle est identique à la fonction intégrée Not. /@est l'opérateur pour Map. Le code serait donc également équivalent à un peu plus lisible Map[Not, #]&.

Python, 27 25 24 octets

Merci à Lynn pour avoir joué au golf sur deux octets, et à xnor et Mego pour en avoir joué un autre.

lambda a:[b^1for b in a]

C #, 19 octets

comme fonction annonymous, prend un bool [] et retourne un IEnumerable

b=>b.Select(x=>!x);

ou en 36 octets avec

dynamic f(bool[]b)=>b.Select(x=>!x);

Formule IBM / Lotus Notes, 2 octets

!a

Usage:

Créez un formulaire Notes avec deux champs nommés a et b.

a (entrée) = modifiable, nombre, multi-valeurs, séparé par des virgules

b (sortie) = calculé, nombre, multi-valeurs, séparé par des virgules

Collez la formule ci-dessus dans b et donnez une valeur par défaut de 0.

Créez un nouveau document avec le formulaire, entrez une liste binaire dans a et appuyez sur F9 pour mettre à jour la sortie.

Exemples:

Fonctionne car étant donné une liste en entrée, la formule Notes appliquera l'action spécifiée à chaque élément de la liste.

J, 2 octets

-.

Ceci est le verbe de négation.

Cas de test

   -. 0 1 0 0 1
1 0 1 1 0

Swift 3 (7 octets)

.map(!)

par exemple

[true, false].map(!)

Explication

Semble assez évident. Appelle mapsur la baie [true, false]. Le seul "piège" est que, dans Swift, les opérateurs ne sont que des fonctions et peuvent être passés comme arguments. Cela signifie map(!)passer la fonction "non" !dans map.

Langage de programmation Shakespeare , 240 octets

.
Ajax,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Puck]
Puck:
Open your mind.Is hog as big as you?If so, let us return to scene II.You be sum of difference of zero and you and cat.Open thy heart!Let us return to scene I.
Scene II:.
[Exeunt]

Accepte une entrée en tant que chaîne de \0et \1caractères de contrôle. Sorties sous forme de chaîne de 0ou 1. Si l'entrée doit être la même que la sortie, remplacez-la Open thy heartpar Speak thy mindpour aucun changement du nombre d'octets. Si \0et \1ne peut être utilisé, procédez comme ci - dessus, mais aussi remplacer Open your mindavec Listen to thy heartune pénalité de 5 octets.

Non golfé:

The Invertion of Veronan Arrays.

Romeo, who stores the element.
Juliet, who lectures him.

Act I: In which an array is inverted.

Scene I: A silent entrance.

[Enter Romeo and Juliet]

Scene II: In which Juliet pours out her heart to Romeo.

Juliet:
  Open your mind. Is nothing better than thee? If so, let us proceed to scene III. 
  Thou art as good as the sum of the difference between nothing and thee and my 
  cat. Open your heart! Let us return to scene II.

Scene III: Finale.

[Exeunt]

Cela se traduit approximativement par le pseudocode C suivant:

int romeo;

Scene1:
romeo = getchar();
if (0 > romeo) goto Scene2;
romeo = 0 - romeo + 1;
printf("%d", romeo);
goto Scene1;

Scene2:;

J'utilise cet interprète . Exemple d'exécution:

$ python splc.py invert.spl > invert.c
$ gcc invert.c -o invert.exe
$ echo -ne "\x00\x01\x00" | ./invert
101

JAISBaL , 1 octet

!

Comme toutes les autres réponses à 1 octet, il s'agit de l'opérateur de négation, qui peut fonctionner sur un tableau si nécessaire. Cela laisse la sortie sur la pile, qui est imprimée à la fin du programme.

Pour deux octets, le tableau peut être explicitement imprimé:

!§

L'entrée est dans le format de tableau incroyablement étrange de JAISBaL (que j'ai inventé, mais je ne l'aime pas ...).

Cas de test (sortie de l'interpréteur Java, 3.0.5):

Enter a value > [true][false]


--------------------
Stack: [[false, true]]
Locals: {}
----------------------------------------
Enter a value > [false][false][true][false][false]


--------------------
Stack: [[true, true, false, true, true]]
Locals: {}

PowerShell, 15 octets

$args[0]|%{!$_}

Je pense que cela peut même fonctionner en v1, donc j'ai laissé le numéro de version hors du titre. Boucle à travers l'entrée $argset annule tour à tour chaque élément. Ce tableau résultant est laissé sur le pipeline.

La chose intéressante, cependant, est que PowerShell est si lâche sur ses exigences de casting, vous pouvez faire une entrée complètement mélangée et obtenir une sortie booléenne appropriée. Par exemple, voici les valeurs booléennes littérales $false/ $true, les nombres 0 1et 123456789sous forme d'entiers, une chaîne vide, une chaîne non vide, un tableau vide et un tableau non vide -

PS C:\Tools\Scripts\golfing> .\invert-a-boolean-array.ps1 @($false,$true,0,1,123456789,'','foo',@(),@(1,1))
True
False
True
False
False
True
False
True
False

Perl, 7 octets

Comprend +2 pour -lp

Donnez à chaque valeur booléenne 0 ou 1 sur sa propre ligne

invert.pl
1
1
0
^D

invert.pl:

#!/us/bin/perl -lp
$_^=1

Brachylog , 7 octets

:{-$_}a

Essayez-le en ligne!

Explication

:{   }a   Apply this predicate to each element of the Input
  -         Decrement
   $_       Negate

Cheddar, 10 octets

@.map((!))

J'espère que j'ai bien compté pendant que j'écris à partir du téléphone

Java, 58 octets

void f(boolean[]a){for(boolean i:a)System.out.print(!i);}

brainfuck (58 octets)

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

Essayez-le ici

Non golfé

-[>+<-----]>---     Number 48 (stands for 0)
>,                  Read in first point
[               
    <[->->+<<]      Subtract 1 from 48 flag, subtract 1 from read data, add 1 for new flag
    >           
    [--<]           If sitting on 1 (true) subtract 2 and move left)
        >[>]<       Move to 48 flag
        [-<+<+>>]   Add 48 to data point
        <+.[-]<     Add 1 move print, zero cell, move to new 48 cell
        >,          Read in next point
]                   Loop if input remaining

Prend une entrée de 1 ou de 0 indivis (11001).

Logicode , 9 8 octets

out!binp

Vraiment simple.

Prend l'entrée comme une chaîne binaire, car Logicode ne prend pas en charge les listes (ce [true, false]serait le cas 10).

Le outsort le résultat de la ligne.

La !commande calcule le NOT de chaque bit de la chaîne, donc quelque chose comme !111serait 000.

C'est binpune entrée binaire.

1 octet enregistré grâce à @daHugLenny

CJam , 4 octets

{:!}

L'entrée est une liste de 0s et 1s.

Essayez-le en ligne!

Japt, 3 octets

¡!X

Japt n'a pas d'entrée booléenne, donc l'entrée est un tableau de 0 et de 1. Testez-le en ligne!

Comment ça fonctionne

¡    // Map each item X in the input to
 !X  //  the boolean NOT of X.
     // Implicit output

Rétine , 3 octets

%`0

Essayez-le en ligne!

Pour chaque ligne ( %), comptez le nombre de 0s.

Python 2, 24 octets (non concurrent)

lambda a:[i-1for i in a]

La logique est similaire à celle de Steven, mais j'ai essayé d'utiliser l'idée de ce commentaire, mais différente, car elle prend toujours 0/ 1tableaux, pas 0/ -1. Il n'y a pas de rasage d'octets pour utiliser 0/ -1, alors soyons sains d'esprit. Notez que ce n'est pas en compétition, jusqu'à ce que Steven ou Lynn me permettent d'utiliser l'idée. Si c'est le cas, je pourrais retirer la marque non concurrente. Notez que ce code ne peut pas être volé sans vergogne, il est toujours là. Seul Steven peut l'utiliser pour sa réponse.

Rubis, 14 octets

Fonction anonyme:

->a{a.map &:!}

Essaye-le:

->a{a.map &:!}.call([true, true, false, true, false, true, true])
# => [false, false, true, false, true, false, false]