Aufgabe

Ersetzen Sie bei einem gegebenen Array positiver Ganzzahlen jedes Element durch die Parität der Summe der anderen Elemente. Das Array enthält garantiert mindestens 2 Elemente.

Definition

• Parität: ob eine Zahl gerade oder ungerade ist.

Beispiel

Für das Array [1,2,3,1]:

• Ersetzen Sie 1durch die Parität von 2+3+1, dh even.
• Ersetzen Sie 2durch die Parität von 1+3+1, dh odd.
• Ersetzen Sie 3durch die Parität von 1+2+1, dh even.
• Ersetzen Sie 1durch die Parität von 1+2+3, dh even.

Ausgabe: [even, odd, even, even]

Eingang

Ein Array mit einer positiven Ganzzahl.

Sie können es als ein geeignetes Array oder als eine durch Zeilenumbrüche getrennte Zeichenfolge positiver Ganzzahlen betrachten.

Sie können davon ausgehen, dass das Array und die darin enthaltenen Werte innerhalb der in Ihrer Sprache verfügbaren Bearbeitungsmöglichkeiten liegen.

Ausgabe

Ein Array von zwei konsistenten Werten , von denen einer repräsentiert odd, einer repräsentiert even.

Sie können es als durch Zeilenvorschub getrennte Zeichenfolge der beiden Werte ausgeben.

Testfälle

Eingänge:

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

Ausgänge:

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

Hinweis: Sie können auch andere konsistente Werte als oddund auswählen even.

Wertung

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

Es gilt die Standardlücke .

Gelee , 3 Bytes

+SḂ

Probieren Sie es online!

Wie es funktioniert

+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 Bytes

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

Verwendet 0für gerade und 1für ungerade.

Prüfung

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 Bytes

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

Verwendet Truefür ungerade und Falsefür gerade Werte.

Probieren Sie es online!

Subtrahieren Sie jedes Element von der Summe der Liste und testen Sie, ob es ungerade ist.

fwandte sich an pointfree hat 20 Bytes auch: map=<<(odd.).(-).sum.

MATL , 5 , 4 Bytes

ts-o

Probieren Sie es online!

Ein Byte gespart dank Dennis!

Dies ergibt '1' für ungerade und '0' für gerade. Erläuterung:

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 Bytes

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

Probieren Sie es online!

Das Eingabeformat spielt keine Rolle, solange die ganzen Zahlen getrennt sind. Das Ausgabeformat ist zeilenweise getrennt.

Das Layout ist wahrscheinlich immer noch nicht optimal, aber ich habe noch keinen Weg gefunden, dies weiter zu verkürzen.

Erläuterung

/     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 Bytes

mi2-sQ

-1 Byte dank @KZhang

Ausgänge 1 für ungerade, 2 für gerade.

Versuch es!

Erläuterung

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 (Legacy) , 4 3 Bytes

O^È

Probieren Sie es online!

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

Python 2 , 33 31 Bytes

^{-2 Bytes dank Leaky Nun}

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

Probieren Sie es online!

R, 21 Bytes

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

Liest die Liste von stdin und gibt 0 für gerade, 1 für ungerade zurück. bindet die Eingabe an die Variable ninnerhalb des Aufrufs, sumanstatt sie außerhalb aufzurufen, dhn=scan();(sum(n)-n)%%2

Probieren Sie es online!

Mathematica, 13 Bytes

#+Tr@#&/*OddQ

oder

OddQ[#+Tr@#]&

Clojure, 30 Bytes

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

Subtrahiert nacheinander alle Werte von jedem Wert, z. B. bei Eingabe ist [a b c d]der 2. berechnete Wert b - a - b - c - d= -(a + c + d). Die Ausgabe erfolgt falsefür gerade undtrue für ungerade.

Sie können aber auch +jeden nachfolgenden Term zweimal verwenden und berechnen, damit die Parität nicht beeinträchtigt wird.

CJam , 10 Bytes

{_:+f+1f&}

Dies ist ein anonymer Block (Funktion), der die Eingabe vom Stapel nimmt und durch die Ausgabe ersetzt.

Probieren Sie es online!

Erläuterung

Betrachten Sie die Eingabe [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

J , 6 Bytes

2|]++/

Probieren Sie es online!

APL (Dyalog Unicode) , 19 7 Bytes

Golf 12 Bytes dank @ Adám

2|+/-¨⊢

Probieren Sie es online!

Japt , 7 Bytes

£x +X&1

Probieren Sie es online!

Erläuterung

 £   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 Bytes

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

Ausgänge 1für ungerade und 0gerade.

Clojure (Skript), 36 Byte

Die Ausgabe erfolgt truefür ungerade und falsefür gerade. Sowohl Ausgabe als auch Eingabe sind Sequenzen.

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

PHP, 50 Bytes

Online-Versionen

1 für ungerade, 0 für gerade

Ausgabe als String getrennt mit _

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

PHP, 72 Bytes

Ausgabe als Array verwenden array_map

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

C 68 62 Bytes

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

1 für ungerade, 0 für gerade

Ausführlicher Online-Test

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;
    }
}

Retina , 40 38 Bytes

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶
 

Probieren Sie es online! Ausgänge 1 für ungerade und 0 für gerade. Erläuterung: Die ersten beiden Zeilen duplizieren die Eingabe einmal für jede Zahl in der Eingabe, jedoch ohne das Element selbst. Dadurch wird eine zusätzliche Leerzeile erstellt, die dann gelöscht wird. Die Eingabe wird dann von dezimal nach unär konvertiert, die Leerzeichen werden gelöscht und die Parität berechnet. Die gerade Parität wird dann in Null umgewandelt und die Ergebnisse zu einer Zeile zusammengefasst. Bearbeiten: 2 Bytes dank @FryAmTheEggman gespeichert. Ich habe einige andere Versionen ausprobiert, die konzeptionell ansprechender sind, aber viel zu viele Bytes benötigen, um ausgedrückt zu werden:

\d\B

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

Ändert alle Eingaben in ihre Parität und kippt dann alle ihre Paritäten, wenn die Summe eine ungerade Parität aufweist.

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

11

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

Summiert ein Duplikat der Eingabe, nimmt dann die Parität von allem und invertiert dann die Paritäten, wenn die Summe ungerade ist, und löscht dann die Summe erneut.

Ohm , 4 Bytes

DΣ-é

Probieren Sie es online!

Grundsätzlich antwortet ein direkter Port der MATL und 05AB1E . Verwendet truefür gerade und falsefür ungerade.

k, 9 Bytes

{2!x-+/x}

Die Ausgabe ist ein 1für oddund ein 0für gerade. Probieren Sie es online aus.

In Pseudocode konvertiert wäre es:

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

Scala , 19 Bytes

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

Probieren Sie es online!

Brain-Flak , 94 68 66 Bytes

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

Probieren Sie es online!

Dies scheint ein wenig lang für die Aufgabe. Es könnte einen bequemeren Weg geben, dies zu tun.

Erläuterung

Zuerst berechnen wir die Summe des Stapels mit:

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

Dann durchlaufen wir den gesamten Stapel und addieren dieses Ergebnis zu jedem Element und bestimmen die Paarigkeit

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

Dies verwendet einen ziemlich coolen Mod 2-Algorithmus, den ich mir für diese Herausforderung ausgedacht habe.

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

Dadurch wird eine 1 unter die Eingangsdekremente gedrückt, bis der Eingang bei jeder Ausführung 1-nder zuvor eingegebenen 1 Null erreicht. Anschließend wird der Eingang entfernt.

Wise , 54 52 Bytes

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

Probieren Sie es online!

Erläuterung

Dieser Code wäre viel kürzer, wenn nicht so viele Bytes erforderlich wären, um die beiden obersten Elemente auszutauschen. Der aktuelle Datensatz ist

:?^:!^:?^!

Dies macht leider den größten Teil des Codes aus.

Zuerst nehmen wir die XOR-Summe des Stapels

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

Wir XOREN dies dann mit jedem Element und dem Element, dessen letztes Bit auf Null gesetzt wurde

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

Java , 81 78 Bytes

3 Bytes dank 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);}

Probieren Sie es online!

Ändert das Array an Ort und Stelle.

AWK , 64 Bytes

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

Probieren Sie es online!

Gibt a 0für gerade Summen und aus1 ungerade durch Zeilenumbrüche getrennte Summen aus. Das einzige, was nicht ganz selbstverständlich war, war die Platzierung derprint Befehl in die Leiste zu stellenfor "Inkrement" -Schritt einzufügen. Ich habe ein paar "clevere" Möglichkeiten zum Drucken ausprobiert, aber sie haben keine Bytes gespeichert.

Nur zum Kichern, wenn Sie keine Zeilenumbrüche wollen:

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

Das hat die gleiche Anzahl von Bytes wie oben, ist aber etwas stumpfer.

Schnell - 55 Bytes

^{Schliesslich schlägt C! Auch 0 für gerade, 1 für ungerade}

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

Eine Funktion mit Verwendung: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Hör zu!

Axiom, 45 Bytes

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

keine Prüfung auf Eingabetyp, mögliche Neuberechnung der Summe "a" jedes Elements ... testet

(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 Bytes

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

Probieren Sie es online!