Güzel, basit bir tane

Giriş

Bir boole dizisi (veya kabul edilebilir bir alternatif) verildiğinde, dizinin hiçbir zaman 32 öğeden uzun olmayacağını varsayabilirsiniz.

[false, false, true, false, false]

Çıktı

Dizinin her öğesini ters çevirin ve çıktısını alın.

[true, true, false, true, true]

kurallar

• Tam bir program veya sadece bir işlev yazabilirsiniz
• Standart boşluklar geçerlidir
• Dil başına bayt cinsinden en kısa kod kazanır!

Test senaryoları

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

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

05AB1E , 1 bayt

Kod:

_

Açıklama:

_     # Logical not

Çevrimiçi deneyin!

Jöle , 1 bayt

¬

Çevrimiçi deneyin!

¬mantıksal DEĞİLDİR (false-y ise 1, başka 0). C(“Tamamlayıcı”, 1 − z ) de çalışır.

Javascript ES6, 15 bayt

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

Fazla açıklama gerekmiyor sanırım

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

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

<pre id=a>

Matlab, 4 1 bayt

Bu kendi kendini açıklayıcı olmalıdır.

~

Matlab, ~kullanabileceğiniz bir işlev istiyorsanız , tek baytlık olumsuzlama operatörüne sahiptir @not.

Haskell, 7 bayt

map not

Misal:

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

MATL , 1 bayt

~

Çevrimiçi deneyin!

~mantıksal değildir ve birçok fonksiyon olduğu gibi, dizilere / matrislere de uygulanabilir.

C, 46 Bayt özyinelemeli sürüm

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

C, 47 Bayt yinelemeli sürüm

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

Bu ana işlevi kullanarak çalıştır

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

ve bu şekilde girdi

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

R, 1 bayt

!

Misal:

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

Ayrıca sayısal girdi ile çalışır:

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

Biz de tek boyutlu dizilerle sınırlı değiliz. Bir matris oluşturalım ve rastgele 0 ve 1'lerle dolduralım:

> 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

Bunu kolayca tersine çevirebiliriz:

> !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

Bunu rastgele sayıda boyut için yapmaya devam edebiliriz. Dört boyutlu bir dizi için bir örnek:

> 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

Korkarım karakterler için işe yaramıyor.

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

Perl 6 , 4 bayt

"Fransızca" / Unicode sürümü:

!«*

"Texas" / ASCII sürümü:

!<<*

Girdi, liste olarak ele alınabilen tek bir değerdir.

Bu, a öneki hiper operatörü ( ) kullanılarak birleştirilen mantıksal önek operatörü ( ) ile birlikte lambda ( *) ne olursa olsun .!«

Etkili olarak bu aynı:

-> $_ { $_.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 )

Kullanımı:

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

Labirent , 9 bayt

,$:)%#$.,

Çevrimiçi deneyin! Sondaki yeni satır ile satırsonu ile ayrılmış girdiyi varsayar. Golf konusunda yardım için @MartinEnder'e teşekkürler.

Bu program bir Labirent programı için biraz garip - dilin 2D doğasından faydalanmıyor ve aslında ileri geri sekiyor. İlk ileri yolculukta:

[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

Daha $sonra XOR bir sonraki oluşumu c, ilk çalıştırmadaki gibi yığının dibindeki örtük 0'ın aksine , yığındaki mevcut 0 ile . Her iki durum da yığını olarak bırakır [c]ve program daha sonra tekrarlanır.

Alternatif 9 bayt:

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

Mathematica, 7 bayt

Not/@#&

veya harfsiz:

!#&/@#&

Sözdizimsel şekere gelince: &isimsiz bir fonksiyonun sağ ucunu işaretler ve çok düşük önceliğe sahiptir. #En yakın ve kapatmakta olan ilk bağımsız değişken ifade eder &. !operatörüdür Not. Yani !#&sadece argümanını reddeden isimsiz bir işlev, yani yerleşik olanla aynı Not. /@operatörüdür Map. Bu yüzden kod biraz daha okunabilir olana eşit olacaktır Map[Not, #]&.

Python, 27 25 24 bayt

İki bayt golf için Lynn ve başka bir golf için xnor ve Mego teşekkürler.

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

C #, 19 bayt

anonim bir işlev olarak, bir bool [] alır ve bir IEnumerable döndürür

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

veya 36 bayt ile

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

IBM / Lotus Notes Formülü, 2 bayt

!a

Kullanımı:

A ve b adlı iki alan içeren bir Notlar formu oluşturun.

a (giriş) = düzenlenebilir, sayı, çoklu değer, virgülle ayrılmış

b (çıktı) = hesaplanan, sayı, çoklu değer, virgülle ayrılmış

Yukarıdaki formülü b'ye yapıştırın ve varsayılan bir 0 değeri verin.

Formla yeni bir belge oluşturun, a'ya ikili bir liste girin ve çıktıyı güncellemek için F9 tuşuna basın.

Örnekler:

Liste girdi olarak verildiğinden çalışır, Notes formülü listedeki her öğeye belirtilen işlemi uygular.

J, 2 bayt

-.

Bu olumsuzlama fiilidir.

Test durumu

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

Swift 3 (7 bayt)

.map(!)

Örneğin

[true, false].map(!)

açıklama

Oldukça açık görünüyor. Aramalar mapdizi [true, false]. Bir "gotcha", Swift'te operatörlerin sadece işlevler olduğu ve argümanlar olarak iletilebileceğidir. Bu araçlar map(!)"değil" işlevini geçiyor !içine map.

Shakespeare Programlama Dili , 240 bayt

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

Girdi \0ve \1kontrol karakterleri dizesi olarak alır . 0Veya dizesi olarak çıktılar 1. Giriş çıkış ile aynı olması gerekiyorsa, yerini Open thy heartile Speak thy mindByteCount hiçbir değişim için. Eğer \0ve \1kullanılamaz, yukarıda yapmak değil, aynı zamanda değiştirmek Open your mindile Listen to thy heart5 bayt cezası.

Ungolfed:

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]

Bu kabaca aşağıdaki C sözde koduna çevirir:

int romeo;

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

Scene2:;

Bu tercümanı kullanıyorum . Örnek çalışma:

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

JAISBaL , 1 bayt

!

Diğer tüm 1 baytlık cevaplar gibi, bu da gerekirse bir dizi üzerinde çalışabilen olumsuzlama operatörüdür. Bu, çıktıyı programın sonunda yazdırılan yığın üzerinde bırakır.

İki bayt için, dizi açıkça yazdırılabilir:

!§

Giriş JAISBaL inanılmaz garip dizi biçimindedir (icat yaptı, ama ben sevmiyorum ...).

Test Durumları (Java yorumlayıcısından çıktı, 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 bayt

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

Bunun v1'de bile çalışabileceğini düşünüyorum , bu yüzden sürüm numarasını başlıktan çıkardım. Giriş boyunca döngüler$args dolaşır ve sırayla her öğeyi reddeder. Sonuçta elde edilen dizi ardışık düzende kalır.

Bununla birlikte, temiz olan şey, PowerShell'in döküm gereksinimlerinde çok gevşek olması, tamamen karışık bir giriş yapabilir ve uygun bir Boolean çıkışı elde edebilirsiniz. Örneğin, değişmez Boole değerleri $false/ $true, sayılar 0 1ve 123456789tamsayılar, boş bir dize, boş olmayan bir dize, boş bir dizi ve boş olmayan bir dizi -

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 bayt

İçin +2 içerir -lp

Her bir boolean değerini kendi satırında 0 veya 1 olarak verin

invert.pl
1
1
0
^D

invert.pl:

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

Brachylog , 7 bayt

:{-$_}a

Çevrimiçi deneyin!

açıklama

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

Çedar, 10 bayt

@.map((!))

Umarım telefondan yazarken doğru saydım

Java, 58 bayt

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

brainfuck (58 Bayt)

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

Burada deneyin

Ungolfed

-[>+<-----]>---     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

Bölünmemiş 1s veya 0s (11001) girdisi alır.

Logicode , 9 8 bayt

out!binp

Çok basit.

Logicode'ın listeler için desteği olmadığı için girişi ikili bir dize olarak alır (öyle [true, false]olur 10).

outHattın sonucunu çıkarır.

!Gibi bir şey bu yüzden komut, dizede her bit DEĞİL hesaplar !111olacaktır 000.

binpİkili girişidir.

@DaHugLenny sayesinde 1 bayt kaydedildi

CJam , 4 bayt

{:!}

Girdi, 0s ve 1s'nin bir listesidir .

Çevrimiçi deneyin!

Japt, 3 bayt

¡!X

Japt boole girişine sahip değildir, bu nedenle girdi 0s ve 1s dizisidir. Çevrimiçi test edin!

Nasıl çalışır

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

Retina , 3 bayt

%`0

Çevrimiçi deneyin!

Her satır için ( %), 0s sayısını sayın .

Python 2,24 bayt (rakip olmayan)

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

Mantık Steven'ınkine benzer, ancak bu yorumun fikrini kullanmaya çalıştım , ama farklı, çünkü hala 0/ 1diziler alıyor , değil 0/ -1. 0/ Kullanmak için bayt tıraşı yoktur -1, bu yüzden aklı başında olalım. Steven veya Lynn bu fikri kullanmama izin verene kadar bunun rakip olmadığını unutmayın. Öyleyse, belki rakip olmayan işaretini kaldırın. Bu kodun utanmadan çalınamayacağını unutmayın, hala burada. Cevabı için sadece Steven kullanabilir.

Ruby, 14 bayt

Anonim işlev:

->a{a.map &:!}

Dene:

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