Parität der Summe der anderen Elemente

23

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 .

code-golf  array-manipulation 
— Undichte Nonne
quelle

Antworten:

16

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.
— Dennis
quelle
Das ist ein kluger Ansatz.
— Undichte Nonne
1
@LeakyNun Es ist derselbe Ansatz, den alle anderen verwenden, nur kürzer: P
— ETHproductions
@ETHproductions So ziemlich ja. Es gibt nur so viele Möglichkeiten, die Parität zu berechnen ...
— Dennis
@ETHproductions verwendet dies Addition anstelle von Subtraktion ...
— Leaky Nun
@LeakyNun Stimmt, meine Japt-Antwort funktioniert auch. In Jelly wäre es einfach_SḂ
— ETHproductions
8

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]))
Erweitern Sie das Snippet

— Luke
quelle
2 Bytes aus: c-b&1anstelle von(c-b)%2
— Leaky Nun
Bah! Du warst schneller als ich!
— Shaggy
1
Ich werde mich daran erinnern müssen , um zu verwenden , eval(a.join`+`)über a.reduce((x,y)=>x+y). Das ist klug
— Cyoce
8

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.

— nimi
quelle
6

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
— DJMcMayhem
quelle
6

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.
— Martin Ender
quelle
6

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
— KarlKastor
quelle
Indem Sie das Modulo %_2in eine GCD ändern i2_, können Sie sogar dimplizit den Code in ändern mi2-sQund so ein Byte sparen. Die Ausgänge werden auf 2 für gerade und 1 für ungerade geändert.
— K Zhang
4

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!

— Giuseppe
quelle
3

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.

— NikoNyrh
quelle
3

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
— Luis Mendo
quelle
2

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
— ETHproductions
quelle
2

Perl 5, 31 Bytes

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

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

— Chris
quelle
+1, nett. Ich denke jedoch, dass dies 28 Bytes sind: perldoc perlsub"Die Signatur ist Teil des Rumpfs einer Unterroutine. Normalerweise ist der Rumpf einer Unterroutine einfach ein geschweifter Codeblock."
— msh210
@ msh210 Danke! Ich glaube nicht, dass es so funktioniert, obwohl der Rumpf der Subroutine nur 28 Bytes hat, aber Sie können nicht weglassen, subohne ihn zu brechen.
— Chris
Manchmal funktioniert ein Unterprogramm jedoch auch ohne sub, z. B. nach sortoder grepoder als Argument für ein anderes Unterprogramm. Fragen Sie nach Code Golf Meta .
— msh210
@ msh210 Eine Unterroutine funktioniert subnur dann ohne , wenn sie in einer prototypisierten Funktion verwendet wird ( sortund grepmehr oder weniger prototypisiert sind). Ansonsten ist das subaber erforderlich. Trotzdem subist es nicht wirklich interessant , 3 Bytes durch Weglassen zu spielen .
— Dada
2

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))
— Irrsinn
quelle
2

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));
— Jörg Hülsermann
quelle
1
Sie können das fallen lassen, ?:0es tut nichts. foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;
— Christoph
2

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;
    }
}
— Khaled.K
quelle
2

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.

— Neil
quelle
Ich habe versucht, was mir in den Sinn kam, und habe eine etwas kürzere Lösung gefunden , obwohl ich immer noch denke, dass sie kaum optimal ist. Besonders mag ich nicht, wie ich mit der zusätzlichen Null umgehe, die ich am Ende bekomme.
— FryAmTheEggman
@FryAmTheEggman Ihre Ersparnis ergibt sich aus einer weniger sichtbaren Möglichkeit, Ihren ;s-Rücken in Leerzeichen umzuwandeln . Wenn Sie das ;am Anfang setzen, können Sie ein Byte speichern, indem Sie es sofort löschen, anstatt es in eine 0 umzuwandeln.
— Neil
Wenn Sie noch einmal hinschauen, warum ersetzen Sie in Ihrer letzten Phase nicht nur Zeilenumbrüche durch Leerzeichen? Würde das nicht 2 Bytes sparen?
— FryAmTheEggman
@FryAmTheEggman Ja; Ich glaube, ich hatte ursprünglich mehr als einen Ersatz in einer früheren Iteration.
— Neil
1

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.

— Weizen-Assistent
quelle
Du kannst zuletzt 2 modifizieren. Sie müssen die Summe nicht 2 modifizieren.
— Undichte Nonne
@LeakyNun Danke! Ich habe das einfach gemerkt und das Problem behoben.
— Weizen-Assistent
1

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

::^??[!:?^:><^!:?^:!^:?^?]!&|
— Weizen-Assistent
quelle
1

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.

— Robert Benson
quelle
1

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!

— Mr. Xcoder
quelle
Nicht vertraut mit Swift, aber in vielen Sprachen können Sie ersetzen (x-y)%2mitx-y&1
— Cyoce
@Cyoce Bei mir funktioniert das nach dem Testen nicht. Bitweise Operationen sind nicht Swifts
— Stärke
1

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]]]
— RosLuP
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.