Tâche

Étant donné un tableau d'entiers positifs, remplacez chaque élément par la parité de la somme des autres éléments. Le tableau est garanti d'avoir au moins 2 éléments.

Définition

Parité: si un nombre est pair ou impair.

Exemple

Pour le tableau [1,2,3,1]:

Remplacez 1par la parité de 2+3+1, c.-à-d even.
Remplacez 2par la parité de 1+3+1, c.-à-d odd.
Remplacez 3par la parité de 1+2+1, c.-à-d even.
Remplacez 1par la parité de 1+2+3, c.-à-d even.

Sortie: [even, odd, even, even]

Contribution

Un tableau d'entiers positifs.

Vous pouvez le prendre comme un tableau approprié ou comme une chaîne d'entiers positifs séparés par un saut de ligne.

Vous pouvez supposer que le tableau et les valeurs à l'intérieur sont dans la capacité de gestion de votre langue.

Sortie

Un tableau de deux valeurs cohérentes , une représentant odd, une représentant even.

Vous pouvez le produire sous la forme d'une chaîne séparée par des sauts de ligne des deux valeurs.

Cas de test

Contributions:

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

Les sorties:

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

Remarque: vous pouvez choisir d'autres valeurs cohérentes autres que oddet even.

Notation

C'est du code-golf . La réponse la plus courte en octets l'emporte.

L'échappatoire standard s'applique.

code-golf array-manipulation

— Leaky Nun
source

16

Gelée , 3 octets

+SḂ

Essayez-le en ligne!

Comment ça marche

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

C'est une approche intelligente.

— Leaky Nun

1

@LeakyNun C'est la même approche que tout le monde utilise, mais plus courte: P

— ETHproductions

@ETHproductions À peu près, oui. Il n'y a que tant de façons de calculer la parité ...

— Dennis

@ETHproductions cela utilise l'addition au lieu de la soustraction ...

— Leaky Nun

@LeakyNun Vrai, ma réponse Japt fait de même. Dans Jelly, ce serait juste_SḂ

— ETHproductions

8

JavaScript (ES6), 38 36 32 octets

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

Utilise 0pour pair et 1pour impair.

Tester

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

Développer l'extrait

— Luc
source

2 octets de moins: c-b&1au lieu de(c-b)%2

— Leaky Nun

Bah! Tu m'as battu!

— Shaggy

1

Je vais devoir me souvenir d'utiliser eval(a.join`+`)plus a.reduce((x,y)=>x+y). C'est intelligent

— Cyoce

8

Haskell, 20 octets

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

Utilise Truepour les valeurs impaires et Falsepour les valeurs paires.

Essayez-le en ligne!

Soustrayez chaque élément de la somme de la liste et testez s'il est impair.

ftourné vers Pointfree a aussi 20 octets: map=<<(odd.).(-).sum.

— nimi
source

6

MATL , 5 , 4 octets

ts-o

Essayez-le en ligne!

Un octet sauvé grâce à Dennis!

Cela donne «1» pour impair et «0» pour pair. Explication:

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
source

6

Alice , 31 28 octets

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

Essayez-le en ligne!

Le format d'entrée n'a pas d'importance tant que les entiers sont séparés. Le format de sortie est séparé par des sauts de ligne.

La mise en page n'est probablement pas encore optimale, mais je n'ai pas encore trouvé de moyen de raccourcir cela.

Explication

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

6

Pyth, 7 6 octets

mi2-sQ

-1 octet grâce à @KZhang

Sorties 1 pour impair, 2 pour pair.

Essayez!

Explication

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
source

En changeant le modulo %_2en GCD i2_, vous pouvez même faire dimplicitement changer le code en mi2-sQ, en économisant un octet. Les sorties sont modifiées à 2 pour pair et 1 pour impair.

— K Zhang

6

05AB1E (hérité) , 4 3 octets

O^È

Essayez-le en ligne!

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

— Riley
source

1 octet de moins

— Leaky Nun

Je sais que cela fait un moment, mais vous pouvez supprimer l'initiale D, car l'entrée est implicite.

— Kevin Cruijssen

5

Python 2 , 33 31 octets

^{-2 octets grâce à Leaky Nun}

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

Essayez-le en ligne!

— Barre
source

2 octets de moins: sum(x)-z&1au lieu de(sum(x)-z)%2

— Leaky Nun

3

sum(x,z)%2fonctionnerait également

— xnor

4

R, 21 octets

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

lit la liste depuis stdin et retourne 0 pour pair, 1 pour impair. lie l'entrée à la variable nà l'intérieur de l'appel au sumlieu de l'appeler à l'extérieur, c'est-à-diren=scan();(sum(n)-n)%%2

Essayez-le en ligne!

— Giuseppe
source

3

Mathematica, 13 octets

#+Tr@#&/*OddQ

ou

OddQ[#+Tr@#]&

— Martin Ender
source

3

Clojure, 30 octets

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

Soustrait toutes les valeurs de chaque valeur tour à tour, par exemple avec une entrée [a b c d]la 2ème valeur calculée est b - a - b - c - d= -(a + c + d). La sortie est falsepour pair et truepour impair.

Mais vous pourriez aussi bien utiliser +et calculer deux fois chaque terme suivant afin qu'il n'affecte pas la parité.

— NikoNyrh
source

3

CJam , 10 octets

{_:+f+1f&}

Il s'agit d'un bloc (fonction) anonyme qui prend l'entrée de la pile et la remplace par la sortie.

Essayez-le en ligne!

Explication

Tenez compte des commentaires [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
source

3

J , 6 octets

2|]++/

Essayez-le en ligne!

— Leaky Nun
source

3

APL (Dyalog Unicode) , 19 7 octets

Golfé 12 octets grâce à @ Adám

2|+/-¨⊢

Essayez-le en ligne!

— Kritixi Lithos
source

2

Japt , 7 octets

£x +X&1

Essayez-le en ligne!

Explication

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

2

Perl 5, 31 octets

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

Sorties 1impaires et 0paires.

— Chris
source

+1, sympa. Je pense que c'est 28 octets, cependant: perldoc perlsubdit : "La signature fait partie du corps d'un sous-programme. Normalement, le corps d'un sous-programme est simplement un bloc de code contreventé.".

— msh210

@ msh210 Merci! Je ne pense pas que cela fonctionne, bien que le corps du sous-programme ne soit que de 28 octets, mais vous ne pouvez pas le laisser subsans le casser.

— Chris

Mais parfois un sous-programme fonctionne sans sub, par exemple après sortou grepou comme argument pour un autre sous-programme. Cela peut valoir la peine d'être interrogé sur Code Golf Meta .

— msh210

@ msh210 Un sous-programme fonctionne sans subseulement s'il est utilisé dans une fonction prototypée ( sortet grepest plus ou moins prototypé). Mais sinon, le subest requis. Quoi qu'il en soit, jouer au golf 3 octets en omettant subn'est pas vraiment intéressant.

— Dada

2

Clojure (Script), 36 octets

La sortie est truepour impair et falsepour pair. La sortie et l'entrée sont des séquences.

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

— madstap
source

2

PHP, 50 octets

Versions en ligne

1 pour impair, 0 pour pair

Sortie sous forme de chaîne séparée par _

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

PHP, 72 octets

Sortie en tant qu'utilisation de tableau array_map

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

— Jörg Hülsermann
source

1

Vous pouvez laisser tomber ?:0cela ne fait rien. foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

— Christoph

2

C, 68 62 octets

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

1 pour impair, 0 pour pair

Essai détaillé en ligne

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
source

2

Rétine , 40 38 octets

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶

Essayez-le en ligne! Sorties 1 pour impair et 0 pour pair. Explication: Les deux premières lignes dupliquent l'entrée une fois pour chaque numéro de l'entrée, mais sans l'élément lui-même. Cela crée une ligne vierge supplémentaire qui est ensuite supprimée. L'entrée est ensuite convertie de décimale en unaire, les espaces sont supprimés et la parité calculée. La parité paire est ensuite convertie à zéro et les résultats sont réunis sur une seule ligne. Edit: enregistré 2 octets grâce à @FryAmTheEggman. J'ai essayé d'autres versions qui sont conceptuellement plus agréables mais qui prennent beaucoup trop d'octets à exprimer:

\d\B

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

Modifie toutes les entrées à leur parité, puis retourne toutes leurs parités si le total a une parité impaire.

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

11

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

Additionne un doublon de l'entrée, puis prend la parité de tout, puis inverse les parités si la somme est impaire, puis supprime à nouveau la somme.

— Neil
source

J'ai essayé ce qui m'est venu à l'esprit et j'ai obtenu une solution légèrement plus courte , même si je pense toujours que ce n'est pas optimal. En particulier, je n'aime pas comment je gère le zéro supplémentaire que j'obtiens à la fin.

— FryAmTheEggman

@FryAmTheEggman Votre économie vient d'avoir une façon moins visible de reconvertir votre ;s en espaces. Si vous placez le ;au début, vous pouvez enregistrer un octet en le supprimant immédiatement au lieu de le convertir en 0.

— Neil

En fait, en regardant de nouveau, pourquoi votre dernière étape ne remplace-t-elle pas simplement les nouvelles lignes par des espaces? Cela ne sauverait-il pas 2 octets?

— FryAmTheEggman

@FryAmTheEggman Oui; Je pense que j'avais à l'origine plus d'un remplacement à faire dans une précédente itération.

— Neil

2

Ohm , 4 octets

DΣ-é

Essayez-le en ligne!

Fondamentalement, un port direct des réponses MATL et 05AB1E . Utilise truepour pair et falsepour impair.

— Nick Clifford
source

1

k, 9 octets

{2!x-+/x}

La sortie est un 1pour oddet un 0pour même. Essayez-le en ligne.

Converti en pseudocode, ce serait:

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

— zgrep
source

1

Scala , 19 octets

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

Essayez-le en ligne!

— Brian McCutchon
source

1

Brain-Flak , 94 68 66 octets

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

Essayez-le en ligne!

Cela semble un peu long pour la tâche. Il pourrait y avoir un moyen plus pratique de le faire.

Explication

On calcule d'abord la somme de la pile avec:

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

Nous parcourons toute la pile en ajoutant ce résultat à chaque élément et déterminons la paire

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

Cela utilise un algorithme mod 2 assez cool que j'ai trouvé pour ce défi.

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

Cela pousse 1 sous les décréments d'entrée jusqu'à ce que l'entrée atteigne zéro à chaque fois en effectuant 1-nle 1 que nous avons placé plus tôt, puis il supprime l'entrée.

— Assistant de blé
source

Vous pouvez enfin mod 2. Vous n'avez pas besoin de mod 2 la somme.

— Leaky Nun

@LeakyNun Merci! Je viens de m'en rendre compte et j'ai fait le correctif.

— Wheat Wizard

1

Sage , 54 52 octets

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

Essayez-le en ligne!

Explication

Ce code serait beaucoup plus court s'il ne fallait pas autant d'octets pour permuter les deux premiers éléments. Le record actuel est

:?^:!^:?^!

Cela constitue malheureusement la majorité du code.

Nous prenons d'abord la somme XOR de la pile

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

Nous avons ensuite XOR ceci avec chaque élément et l'élément avec le dernier bit mis à zéro

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

— Assistant de blé
source

1

Java , 81 78 octets

3 octets grâce à 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);}

Essayez-le en ligne!

Modifie le tableau sur place.

— Leaky Nun
source

Vous pouvez le 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);}

— jouer

67 octets si vous utilisez un lambda: essayez-le en ligne!

— Brian McCutchon

Merci, mais je n'aime pas utiliser un lambda.

— Leaky Nun

1

AWK , 64 octets

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

Essayez-le en ligne!

Affiche a 0pour les sommes paires et 1pour les sommes impaires séparées par des retours à la ligne. La seule pensée, même un peu originale, était de placer la printcommande à l'intérieur de l' forétape "incrément". J'ai essayé quelques méthodes «intelligentes» pour imprimer, mais elles n'ont pas enregistré d'octets.

Juste pour rire, si vous ne voulez pas de nouvelles lignes:

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

qui a le même nombre d'octets que ci-dessus, mais est un peu plus obtus.

— Robert Benson
source

1

Swift - 55 octets

^{Bat enfin C! Aussi, 0 pour pair, 1 pour impair}

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

Une fonction, à l'usage: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Vérifiez-le!

— M. Xcoder
source

Pas familier avec Swift, mais dans de nombreuses langues, vous pouvez le remplacer (x-y)%2parx-y&1

— Cyoce

@Cyoce Pour moi, après les tests, cela ne fonctionne pas. Les opérations au niveau du bit ne sont pas le fort de Swift

— M. Xcoder

1

Axiome, 45 octets

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

pas de vérification du type d'entrée, recalcul possible de la somme "a" de chaque élément ... tests

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

1

Julia 1.0 , 17 octets

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

Essayez-le en ligne!

— gggg
source

Parité de la somme des autres éléments

Tâche

Définition

Exemple

Contribution

Sortie

Cas de test

Notation

Gelée , 3 octets

Comment ça marche

JavaScript (ES6), 38 36 32 octets

Tester

Haskell, 20 octets

MATL , 5 , 4 octets

Alice , 31 28 octets

Explication

Pyth, 7 6 octets

Explication

05AB1E (hérité) , 4 3 octets

Python 2 , 33 31 octets

R, 21 octets

Mathematica, 13 octets

Clojure, 30 octets

CJam , 10 octets

Explication

J , 6 octets

APL (Dyalog Unicode) , 19 7 octets

Japt , 7 octets

Explication

Perl 5, 31 octets

Clojure (Script), 36 octets

PHP, 50 octets

PHP, 72 octets

C, 68 62 octets

Rétine , 40 38 octets

Ohm , 4 octets

k, 9 octets

Scala , 19 octets

Brain-Flak , 94 68 66 octets

Explication

Sage , 54 52 octets

Explication

Java , 81 78 octets

AWK , 64 octets

Swift - 55 octets

Axiome, 45 octets

Julia 1.0 , 17 octets