# Invert a boolean array

A nice simple one

# Input

Given a boolean array (Or an acceptable alternative), you can assume the array will never be more than 32 elements long.

[false, false, true, false, false]

# Output

Invert every element of the array and output it.

[true, true, false, true, true]

# Rules

• You can write a full program or just a function
• Standard loopholes apply
• Shortest code in bytes, per language, wins!

# Test cases

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

Input: //Example of acceptable alternative
[0,1,1]
Output:
[1,0,0]
• How about arrays of 0 (false, all 0 bits) and -1 (true, all 1 bits)? – Lynn Sep 15 '16 at 11:52
• @Lynn While it's the OPs decision, I'd say it should be up to whether your language considers though truthy/falsy. – Martin Ender Sep 15 '16 at 11:53
• Related. (Given the simplicity of the core task, I'd say the differences in format are significant enough that these aren't duplicates.) – Martin Ender Sep 15 '16 at 12:28
• More than code golf this looks to me like: what is the not operator in your favourite language? Additional points if it works on lists. – licorna Sep 15 '16 at 23:32

# Python 2, 24 bytes (non-competing)

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

Logic is similar to Steven's, but I tried to use this comment's idea, but different, because it still takes 0/1 arrays, not 0/-1. There is no byte shaving for using 0/-1, so let's be sane. Note that this is non-competing, until Steven or Lynn allows me to use the idea. If so, I might remove the non-competing mark. Note that this code cannot be shamelessly stolen, it's still here. Only Steven can use it for his answer.

# Ruby, 14 bytes

Anonymous function:

->a{a.map &:!}

Test it:

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

## Perl 6, 9 bytes

*.map: !*

Usage:

say (*.map: !*)((0, 1, 1)) # (True False False)

## Actually, 2 bytes

♂Y

Try it online!

Map () Boolean negate (Y)

## Clojure, 12 bytes

#(map not %)

Basically the same as the Haskell answer. Unfortunately, Clojure doesn't have implicit partial application; thus the function macro.

# Julia (1 Byte - Thanks to Dennis [See Comments])

!

Map the logical not to all elements of collection y, works due to automatic vectorization (as Dennis explained). My previous answer was basically using `f(n)=map(!,n)' to map the logical not, but Julia does this on it's own. Jeez, what a cool language. Second time using it, still trying to learn here!

Try it here

• ! (1 byte) is enough. ! vectorizes automatically. – Dennis Sep 15 '16 at 21:36
• In the console I had it didnt let me do that :(, plus thats a snippet, is it not? – Magic Octopus Urn Sep 16 '16 at 2:03
• I've tested it with version 0.4; it's possible that it doesn't work in older versions of Julia. ! by itself evaluates to a function, which can be saved in a variable (just like a lambda), and is therefore considered a valid function submission. For.example, you can use it like f=!;print(f([true,false])). – Dennis Sep 16 '16 at 2:24
• That's neat, technically 3 bytes for f=! though, unless just saying "!" is its own function works. – Magic Octopus Urn Sep 19 '16 at 15:09
• By community consensus, ! is a valid answer on ois own. – Dennis Sep 19 '16 at 15:22

~

Try it online!

vnot

Try it online!

# Pyth, 2 bytes

!M

Explanation: (M)ap boolean not (!) over input.

Try it online!

• m! works aswell and makes more sense to me since you map the not over the input array. – KarlKastor Sep 15 '16 at 12:25
• @KarlKastor They compile down to the same thing, assign("Q", eval_input()); imp_print(Pmap(lambda d: Pnot(d), Q)) – Steven H. Sep 15 '16 at 12:38

## Hoon, 24 bytes

|*
*
(turn +< |=(? !+<))

Creates a generic gate, map over the contents of the list, negate all loobeans in it.

This uses the normal Hoon tricks, namely using a generic ("wet"/|*) gate to avoid having to specify the sample type, along with having unnamed samples (* or ?) and using tree navigation syntax (+<) to fetch them.

> a
~[%.y %.n %.n %.y %.n %.y]
> =f |*
*
(turn +< |=(? !+<))
> (f a)
~[%.n %.y %.y %.n %.y %.n]

# Groovy (19 Bytes)

{x->x.collect{!it}}

Simple mapping function in a closure.

## Stata, 20 bytes

recode x (0=1) (1=0)

x is the input, and the rest is self-explanatory

# braingasm, 9 bytes

,[48-z:,]

Assumes that input from stdin is a string of only "0"s and "1"s, i.e. bytes containing the value 48 or 49. Prints the negated values to stdout.

How it works: Read one byte from stdin (,), and loop ([]) until the end of the input. For each byte, subtract 48 (48-) and print 1 if the result is 0 and vice versa (z is the zero-flag, : prints the given integer value), then get another byte from stdin (,)

[0 1 0 1 1 1 0]

# Racket, 15 bytes

(curry map not)

• Making this a lambda might make this more succinct, no? I was going to partially apply for my answer (partial map not, Clojure), but a function macro ended up being smaller. Idk what Rackets anonymous functions look like though honestly. – Carcigenicate Sep 22 '16 at 22:12
• Unfortunately Racket's shortest anonymous function uses the form of (λ (arguments) function-body), so it would be (λ(l)(map not l)) which is 18 bytes (the lambda symbol is two bytes). Interestingly, (map not(read)) is also 15 bytes. – Winny Sep 24 '16 at 20:18
• It actually uses a lambda symbol? Damn. That seems needlessly complicated :/ – Carcigenicate Sep 24 '16 at 21:09
• (There is also lambda, but that's not applicable to code golfing at all.) – Winny Sep 25 '16 at 9:48

m!

Try it here!

map(not, input)

## Golang, 40 bytes

func(a[]bool){for i,b:=range a{a[i]=!b}}

### usage

package main
import "fmt"
func main() {
a:=[]bool{true, true, false}
func(a []bool){for i,b:=range a{a[i]=!b}}(a)
fmt.Print(a) // => [false false true]
}

# Brainfuck, 7269 61 bytes

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

Closest i managed to get as BF dosent have Array support

Formatting is stupid, i will fix it when i get a pc... Somehow it wont let me post it as a snippet

• You could put all the lines together into one long line, it doesn't really matter for us (because with newlines, the total byte length is 78 bytes). – clismique Sep 22 '16 at 23:14
• -4: ,>++++++++[<------>-]+<[->-<]>[<+>-]++++++++[<++++++>-]<. – Kamila Szewczyk Dec 20 '20 at 10:24

# PHP, 30 bytes

foreach($argv[1] as$i)echo!$i; Testing code:$argv[1] = [true,true,false,true,false,false,true,false];
foreach($argv[1] as$i)echo!$i; Test online # C++11, 30 bytes As unnamed lambda: [](auto&v){for(auto&x:v)x=!x;} Accepts any standard container like vector<int> (but not vector<bool>) or int[] or bool[]. • For the suggested edit: making this a function would require a return type – Karl Napf Nov 15 '16 at 0:22 # 6502 Machine Language - 14 Bytes AE 00 01 CA B5 00 49 01 95 00 8A D0 F6 00 Array of bytes is in zero page. Length of array is in$0100.

Flipped array is in zero page.

Assembler code:

AE 00 01 - ldx $0100 CA - dex B5 00 - lda$00, X
49 01    - eor #$01 95 00 - sta$00, X
8A       - txa
D0 F6    - BNE (-10)
00       - BRK

(My first golf answer - sorry if format is off.)

• Welcome to Code Golf, nice first answer! Your formatting is fine, don't worry :p – Redwolf Programs Dec 21 '20 at 4:01

# Vyxala, 2 1 byte

-1 thanks to lyxal

Try it Online!

# Java, 51 bytes

l.stream().map(b->!b).collect(Collectors.toList());

l = a Collection of Booleans I feel like this could be shorter, then again golfing in java ^^

• Unless the challenge says otherwise, all submissions need to be full programs or callable functions, as opposed to snippets which expect the input to be stored in a hardcoded variable. The shortest fix would probably be to wrap what you've got in a simple function body (or lambda, depending on Java version). – Martin Ender Sep 15 '16 at 12:48
• As alternative, you can use streams directly: s->s.map(b->!b). I'm currently asking on meta if this is acceptable or not. – Olivier Grégoire Sep 15 '16 at 13:58
• Hmmm... Also, you don't reference the packages, either in import or full text. – Olivier Grégoire Sep 15 '16 at 14:29
• If s->s.map(b->!b) that @OlivierGrégoire already posted wasn't allowed, you could still golf it by returning an Object-array l->l.stream().map(b->!b).toArray() instead (also, as stated by others, your current solution isn't valid. It should have a leading l->; Collectors should be java.util.stream.Collectors; and you can drop the trailing ;). – Kevin Cruijssen Jan 24 '18 at 15:24

# PHP , 45 Bytes

<?foreach($_GET[a]as$v)$a[]=1-$v;print_r($a); • As the question states 'Invert every element of the array and output it.' and people aren't usually too picky on output format, save 6 bytes by doing print_r($a); at the end – gabe3886 Sep 15 '16 at 16:13
• Okay I'll try it – Jörg Hülsermann Sep 15 '16 at 16:22
• You don't need the spaces there. Your whole code can be written as <?foreach($_GET[a]as$v)$a[]=1-$v;print_r(\$a);. This saves 2 bytes and works. – Ismael Miguel Sep 15 '16 at 20:43

## Common Lisp, 7

bit-not

Negate bits on a bit array.

## Example

(bit-not #*00101010010100101001010010101)
=> #*11010101101011010110101101010