Zadanie

Biorąc pod uwagę tablicę dodatnich liczb całkowitych, zamień każdy element na parzystość sumy pozostałych elementów. Tablica ma co najmniej 2 elementy.

Definicja

• Parzystość: czy liczba jest nieparzysta, czy parzysta.

Przykład

Dla tablicy [1,2,3,1]:

• Zamień 1na parzystość 2+3+1, tj even.
• Zamień 2na parzystość 1+3+1, tj odd.
• Zamień 3na parzystość 1+2+1, tj even.
• Zamień 1na parzystość 1+2+3, tj even.

Wydajność: [even, odd, even, even]

Wkład

Tablica dodatnich liczb całkowitych.

Możesz wziąć go jako odpowiednią tablicę lub jako ciąg liczb całkowitych dodatnich oddzielonych od linii.

Możesz założyć, że tablica i zawarte w niej wartości mieszczą się w możliwościach obsługi twojego języka.

Wydajność

Tablica dwóch spójnych wartości , jedna reprezentująca odd, jedna reprezentująca even.

Możesz wyprowadzić go jako ciąg znaków oddzielony wierszem dwóch wartości.

Przypadki testowe

Wejścia:

[1, 2, 3, 1]
[1, 2, 3, 2, 1]
[2, 2]
[100, 1001]

Wyjścia:

[even, odd, even, even]
[even, odd, even, odd, even]
[even, even]
[odd, even]

Uwaga: możesz wybrać inne spójne wartości inne niż oddi even.

Punktacja

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa.

Obowiązuje standardowa luka .

Galaretka , 3 bajty

+SḂ

Wypróbuj online!

Jak to działa

+SḂ  Main link. Argument: A (array)

 S   Compute the sum of A.
+    Add the sum to each element of A.
     Using _ (subtraction) or ^ (bitwise XOR) would also work.
  Ḃ  Bit; compute the parity of each resulting integer.

JavaScript (ES6), 38 36 32 bajtów

a=>a.map(b=>eval(a.join`+`)-b&1)

Używa 0parzystych i 1nieparzystych.

Test

f=
a=>a.map(b=>eval(a.join`+`)-b&1)
console.log(f([1, 2, 3, 1]))
console.log(f([1, 2, 3, 2, 1]))
console.log(f([100, 1001]))

Haskell, 20 bajtów

f x=odd.(sum x-)<$>x

Wykorzystuje Truewartości nieparzyste i Falseparzyste.

Wypróbuj online!

Odejmij każdy element od sumy listy i sprawdź, czy jest nieparzysty.

fzwrócił się do pointfree posiada również 20 bajtów: map=<<(odd.).(-).sum.

MATL , 5 , 4 bajty

ts-o

Wypróbuj online!

Jeden bajt zapisany dzięki Dennisowi!

Daje to „1” dla nieparzystych i „0” dla parzystych. Wyjaśnienie:

t       % Duplicate the input
 s      % Get the sum of the input
  -     % Subtract it from the original input
   o    % Get the parity of each element

Alice , 31 28 bajtów

/O.HQ\d$K@
\i#\ /d2-&+!w?+2%

Wypróbuj online!

Format wejściowy nie ma znaczenia, o ile liczby całkowite są rozdzielone. Format wyjściowy jest oddzielony od linii.

Układ prawdopodobnie nie jest jeszcze optymalny, ale nie znalazłem jeszcze sposobu na jego dalsze skrócenie.

Wyjaśnienie

/     Reflect to SE. Switch to Ordinal.
i     Read all input as a string.
      Reflect off bottom boundary. Move to NE.
.     Duplicate the input string.
      Reflect off top boundary. Move to SE.
\     Reflect to N. Switch to Cardinal.
H     Implicitly convert the top copy of the input to the integers it
      contains and take the absolute value of the top-most one. (Taking
      the absolute value doesn't do anything, but we need the implicit
      conversion to integers.)
      The IP wraps back to the second line.
\     Reflect to SE. Switch to Ordinal.
      Immediately reflect off bottom boundary. Move to NE.
Q     Reverse the stack (this converts the integers back to strings but
      that's irrelevant). After this, we end up with all the individual
      integers on the bottom of the stack in reverse order and the other
      copy of the input string with all integers on top.
      Reflect off top boundary. Move to SE.
/     Reflect to E. Switch to Cardinal.
d     Push the stack depth, which is one more than the number of list
      elements (due to the other input string on the stack).
2-    Subtract 2.
&+    Run + that many times, which implicitly converts the second string
      to the integers it contains and then adds up all the list elements.
!     Store the sum on the tape.
w     Push the current IP position to the return address stack. This
      lets us return here repeatedly to implement a loop.

  ?+    Retrieve the input sum from the tape and add it to the current
        element.
  2%    Compute its parity. Other ways to do this are 1A and 0x. 2F would
        also work but it gives 0/2 instead of 0/1.
        The IP wraps the first column of the grid.
  \     Reflect to NE. Switch to Ordinal. The IP bounces diaginally up
        and down until it hits the next \.
  O     Implicitly convert the current parity to a string and print it
        with a trailing linefeed.
  #     Skip the next command (the H).
  \     Reflect to E. Switch to Cardinal.
  d     Push the stack depth. This is zero when we're done.
  $     Skip the next command if the stack depth is indeed zero, which
        exits the loop.

K     Jump to the return address on top of the return address stack without
      popping it (so that the next K will jump there again).

@     Terminate the program.

Pyth, 7 6 bajtów

mi2-sQ

-1 bajtów dzięki @KZhang

Wyjścia 1 dla nieparzystych, 2 dla parzystych.

Spróbuj!

Wyjaśnienie

m%-sQd2
m      Q    # For each element in the (implicit) input list
   sQ       # Take the sum of all the elements
  -  d      # subtract that element, so that we now have the sum of the other elements
 %    2     # modulo 2; 1=off, 0=even

05AB1E (starsza wersja) , 4 3 bajty

O^È

Wypróbuj online!

O   # Sum
 ^  # XOR with (implicit) input
  È # Print 1 for even / 0 for odd

Python 2 , 33 31 bajtów

^{-2 bajty dzięki Leaky Nun}

lambda x:[sum(x)-z&1for z in x]

Wypróbuj online!

R, 21 bajtów

(sum(n<-scan())-n)%%2

czyta listę ze standardowego wejścia i zwraca 0 dla parzystej, 1 dla nieparzystej. wiąże dane wejściowe ze zmienną nwewnątrz wywołania sumzamiast wywoływać je na zewnątrz, tj.n=scan();(sum(n)-n)%%2

Wypróbuj online!

Mathematica, 13 bajtów

#+Tr@#&/*OddQ

lub

OddQ[#+Tr@#]&

Clojure, 30 bajtów

#(for[i %](odd?(apply - i %)))

Odejmuje wszystkie wartości kolejno od każdej wartości, na przykład przy wprowadzaniu [a b c d]druga obliczona wartość to b - a - b - c - d= -(a + c + d). Wyjście jest falseparzyste i truenieparzyste.

Ale równie dobrze możesz użyć +i obliczyć każdy kolejny termin dwa razy, aby nie wpływał on na parzystość.

CJam , 10 bajtów

{_:+f+1f&}

Jest to anonimowy blok (funkcja), który pobiera dane wejściowe ze stosu i zastępuje je danymi wyjściowymi.

Wypróbuj online!

Wyjaśnienie

Rozważ wejście [1 2 3 1] .

{         e# Begin block
          e#   STACK: [1 2 3 1]
  _       e#   Duplicate
          e#   STACK: [1 2 3 1], [1 2 3 1]
  :+      e#   Fold addition over the array: compute its sum
          e#   STACK: [1 2 3 1], 7 
  f+      e#   Map addition over the array with extra parameter
          e#   STACK: [8 10 11 8]
  1       e#   Push 1
          e#   STACK: [8 10 11 8], 1
  f&      e#   Map bit-wise "and" over the array with extra parameter
          e#   STACK: [0 0 1 0]
}         e# End block

jot , 6 bajtów

2|]++/

Wypróbuj online!

APL (Dyalog Unicode) , 19 7 bajtów

Grał w golfa 12 bajtów dzięki @ Adám

2|+/-¨⊢

Wypróbuj online!

Japt , 7 bajtów

£x +X&1

Wypróbuj online!

Wyjaśnienie

 £   x +X&1
 mX{ x +X&1}  // Ungolfed
UmX{Ux +X&1}  // Variable introduction

UmX{       }  // Replace each item in the input array with
         &1   //   the parity of
    Ux        //   the sum of the input array
       +X     //   plus X.
              // Implicit: output result of last expression

Perl 5, 31 bajtów

sub{map$x+=$_,@_;map$x-$_&1,@_}

Wyjścia 1dla nieparzystych i 0parzystych.

Clojure (skrypt), 36 bajtów

Wyjście jest truenieparzyste i falseparzyste. Zarówno dane wyjściowe, jak i wejściowe są sekwencjami.

(fn[l](map #(odd?(-(apply + l)%))l))

PHP, 50 bajtów

Wersje online

1 dla nieparzystych, 0 dla parzystych

Dane wyjściowe jako ciąg oddzielony _

<?foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

PHP, 72 bajty

Dane wyjściowe jako użycie tablicy array_map

<?print_r(array_map(function($v){return array_sum($_GET)-$v&1;},$_GET));

C, 68 62 bajtów

i;s;f(c,l)int*l;{while(i<c)s+=l[i++];while(i)l[--i]=s-l[i]&1;}

1 dla nieparzystych, 0 dla parzystych

Szczegółowe Wypróbuj online

f(int c, int * l)
{
    int i = 0, s = 0;

    while(i < c)
    {
        s = s + l[i];
        i = i + 1;
    }

    // assert(i == c)

    while(i > 0)
    {
        i = i - 1;
        l[i] = s - l[i]&1;
    }
}

Siatkówka , 40 38 bajtów

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Wypróbuj online! Wyjścia 1 dla nieparzystych i 0 dla parzystych. Objaśnienie: Pierwsze dwa wiersze duplikują dane wejściowe jeden raz dla każdej liczby na wejściu, ale bez samego elementu. To tworzy dodatkową pustą linię, która jest następnie usuwana. Dane wejściowe są następnie konwertowane z dziesiętnej na unarną, spacje są usuwane, a parzystość obliczana. Nawet parzystość jest następnie konwertowana na zero, a wyniki ponownie łączone w jedną linię. Edycja: Zapisano 2 bajty dzięki @FryAmTheEggman. Wypróbowałem kilka innych wersji, które są koncepcyjnie bardziej przyjemne, ale do wyrażenia wymagają o wiele za dużo bajtów:

\d\B

T`2468O`00001
T`d`10`^([^1]*1[^1]*1)*[^1]*1[^1]*$

Zmienia wszystkie dane wejściowe na ich parzystość, a następnie odwraca wszystkie ich parytety, jeśli suma ma nieparzystą parzystość.

\d+
$*
^.*
$&¶$&
 (?=.*$)

11

\B
0
T`d`10`.*¶1
¶0

Sumuje duplikat danych wejściowych, a następnie przyjmuje parzystość wszystkiego, a następnie odwraca parzystości, jeśli suma jest nieparzysta, a następnie usuwa sumę ponownie.

Ohm , 4 bajty

DΣ-é

Wypróbuj online!

Zasadniczo bezpośredni port odpowiedzi MATL i 05AB1E . Używa trueparzystych i falsenieparzystych.

k, 9 bajtów

{2!x-+/x}

Wyjście jest 1na odd, a 0na parzyste. Wypróbuj online.

Przekształcony w pseudokod, będzie to:

for number in x:
    yield (number - sum(x)) % 2

Scala , 19 bajtów

x=>x.map(x.sum-_&1)

Wypróbuj online!

Brain-Flak , 94 68 66 bajtów

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

Wypróbuj online!

To wydaje się trochę za długie na zadanie. Może to być wygodniejszy sposób.

Wyjaśnienie

Najpierw obliczamy sumę stosu za pomocą:

({({}<>)<>})

Przechodzimy przez cały stos, dodając ten wynik do każdego elementu i określając pary

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

Wykorzystuje całkiem fajny algorytm mod 2, który wymyśliłem do tego wyzwania.

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

Spycha to 1 poniżej dekretu wejściowego, aż sygnał wejściowy osiągnie zero za każdym razem, gdy wykonujemy 1-n1, który umieściliśmy wcześniej, a następnie usuwa dane wejściowe.

Wise , 54 52 bajtów

::^:??[:!^:?^:!^:?^?]|!::^??[!:?^:><^!:?^:!^:?^?]!&|

Wypróbuj online!

Wyjaśnienie

Ten kod byłby o wiele krótszy, gdyby nie zajęło tylu bajtów zamiana dwóch górnych elementów. Obecny rekord to

:?^:!^:?^!

To niestety stanowi większość kodu.

Najpierw bierzemy sumę XOR stosu

::^:??[:!^:?^:!^:?^?]|!

Następnie XOR to z każdym elementem i elementem z ostatnim bitem zerowanym

::^??[!:?^:><^!:?^:!^:?^?]!&|

Java , 81 78 bajtów

3 bajty dzięki Kevin Cruissen

void f(int[]a){int s=0,i=a.length;for(int x:a)s+=x;for(;i-->0;a[i]=s-a[i]&1);}

Wypróbuj online!

Zmienia tablicę w miejscu.

AWK , 64 bajty

{for(i=0;++i<=NF;print s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}

Wypróbuj online!

Wyprowadza 0a 1dla liczb parzystych i dla liczb nieparzystych oddzielonych znakami nowej linii. Jedynym, nawet nieco nieszablonowym, pomysłem było umieszczenie printpolecenia wewnątrzfor kroku „przyrostu”. Próbowałem kilku „sprytnych” sposobów drukowania, ale nie oszczędzały bajtów.

Tylko na chichot, jeśli nie chcesz nowych linii:

{for(i=0;++i<=NF;m=m,s[i]%2)for(j=0;++j<=NF;)if(i!=j)s[i]+=$j}1

który ma taką samą liczbę bajtów jak powyżej, ale jest nieco bardziej rozwarty.

Szybki - 55 bajtów

^{Wreszcie bije C! Również 0 dla parzystej, 1 dla nieparzystej}

func g(a:[Int]){for i in a{print((a.reduce(0,+)-i)%2)}}

Funkcja z użyciem: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Sprawdź to!

Aksjomat, 45 bajtów

f(a)==[(reduce(+,a)-a.j)rem 2 for j in 1..#a]

brak sprawdzania typu danych wejściowych, możliwe przeliczenie sumy „a” każdego elementu… testy

(27) -> [[a,f(a)] for a in [[1,2,3,1], [1,2,3,2,1], [2,2], [100, 1001] ]]
   (27)
   [[[1,2,3,1],[0,1,0,0]], [[1,2,3,2,1],[0,1,0,1,0]], [[2,2],[0,0]],
    [[100,1001],[1,0]]]

Julia 1.0 , 17 bajtów

x->(sum(x).-x).%2

Wypróbuj online!