Tarefa

Dada uma matriz de números inteiros positivos, substitua cada elemento pela paridade da soma dos outros elementos. A matriz é garantida para ter pelo menos 2 elementos.

Definição

Paridade: se um número é ímpar ou par.

Exemplo

Para a matriz [1,2,3,1]:

Substitua 1pela paridade de 2+3+1, ie even.
Substitua 2pela paridade de 1+3+1, ie odd.
Substitua 3pela paridade de 1+2+1, ie even.
Substitua 1pela paridade de 1+2+3, ie even.

Saída: [even, odd, even, even]

Entrada

Uma matriz de número inteiro positivo.

Você pode tomá-lo como uma matriz adequada ou como uma sequência de números inteiros positivos separados por avanço de linha.

Você pode assumir que a matriz e os valores internos estão dentro da capacidade de manipulação do seu idioma.

Saída

Uma matriz de dois valores consistentes , um representando odd, um representando even.

Você pode produzi-lo como uma sequência separada por avanço de linha dos dois valores.

Casos de teste

Entradas:

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

Saídas:

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

Nota: você pode escolher outros valores consistentes além de odde even.

Pontuação

Isso é código-golfe . A resposta mais curta em bytes vence.

A brecha padrão se aplica.

code-golf array-manipulation

— Freira Furada
fonte

16

Gelatina , 3 bytes

+SḂ

Experimente online!

Como funciona

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

Essa é uma abordagem inteligente.

— Leaky Nun

1

@LeakyNun É a mesma abordagem que todo mundo está usando, mas menor: P

— ETHproductions

@ETHproductions Praticamente, sim. Thete são apenas tantas maneiras de calcular a paridade ...

— Dennis

@ETHproductions este usa disso, em vez de subtração ...

— Leaky Nun

@LeakyNun True, minha resposta em japonês também. Em Jelly seria apenas_SḂ

— ETHproductions

8

JavaScript (ES6), 38 36 32 bytes

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

Usa 0para pares e 1ímpares.

Teste

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

Expandir snippet

— Luke
fonte

2 bytes: c-b&1em vez de(c-b)%2

— Leaky Nun

Bah! Você chegou antes de mim!

— Shaggy

1

Vou ter que lembrar de usar eval(a.join`+`)mais a.reduce((x,y)=>x+y). Isso é inteligente

— Cyoce

8

Haskell, 20 bytes

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

Usa Truepara valores ímpares e Falsepara valores pares.

Experimente online!

Subtraia cada elemento da soma da lista e teste se é ímpar.

fvirou-se para pointfree também tem 20 bytes: map=<<(odd.).(-).sum.

— nimi
fonte

6

MATL , 5 , 4 bytes

ts-o

Experimente online!

Um byte economizado graças ao Dennis!

Isso fornece '1' para ímpar e '0' para par. Explicação:

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
fonte

6

Alice , 31 28 bytes

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

Experimente online!

O formato de entrada não importa, desde que os números inteiros sejam separados. O formato de saída é separado por avanço de linha.

O layout provavelmente ainda não é o ideal, mas ainda não encontrei uma maneira de encurtar isso.

Explicação

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

6

Pitão, 7 6 bytes

mi2-sQ

-1 Byte graças a @KZhang

Saídas 1 para ímpar, 2 para par.

Tente!

Explicação

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
fonte

Alterando o módulo %_2para um GCD i2_, você pode fazer o dimplícito alterar o código para mi2-sQ, salvando um byte. As saídas são alteradas para 2 para par e 1 para ímpar.

— K Zhang

6

05AB1E (legado) , 4 3 bytes

O^È

Experimente online!

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

— Riley
fonte

1 byte off

— Leaky Nun

Eu sei que já faz um tempo, mas você pode remover a inicial D, pois a entrada é implicitamente.

— Kevin Cruijssen

5

Python 2 , 33 31 bytes

^{-2 bytes graças a Leaky Nun}

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

Experimente online!

— Cajado
fonte

2 bytes: sum(x)-z&1em vez de(sum(x)-z)%2

— Leaky Nun

3

sum(x,z)%2também funcionaria

— xnor

4

R, 21 bytes

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

lê a lista de stdin e retorna 0 para par, 1 para ímpar. vincula a entrada à variável ndentro da chamada em sumvez de chamá-la para fora, ou seja,n=scan();(sum(n)-n)%%2

Experimente online!

— Giuseppe
fonte

3

Mathematica, 13 bytes

#+Tr@#&/*OddQ

ou

OddQ[#+Tr@#]&

— Martin Ender
fonte

3

Clojure, 30 bytes

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

Subtrai todos os valores de cada valor por vez, por exemplo, com a entrada, [a b c d]o 2º valor calculado é b - a - b - c - d= -(a + c + d). A saída é falsepara par e trueímpar.

Mas você também pode usar +e calcular cada termo subseqüente duas vezes para não afetar a paridade.

— NikoNyrh
fonte

3

CJam , 10 bytes

{_:+f+1f&}

Este é um bloco anônimo (função) que pega a entrada da pilha e a substitui pela saída.

Experimente online!

Explicação

Considere entrada [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
fonte

3

J , 6 bytes

2|]++/

Experimente online!

— Freira Furada
fonte

3

APL (Dyalog Unicode) , 19 7 bytes

Golfou 12 bytes graças a @ Adám

2|+/-¨⊢

Experimente online!

— Kritixi Lithos
fonte

2

Japonês , 7 bytes

£x +X&1

Experimente online!

Explicação

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

2

Perl 5, 31 bytes

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

Saídas 1para ímpar e 0par.

— Chris
fonte

+1, legal. Acho que são 28 bytes: perldoc perlsubdiz : "A assinatura faz parte do corpo de uma sub-rotina. Normalmente, o corpo de uma sub-rotina é simplesmente um bloco de código".

— Msh210 2/17

@ msh210 Obrigado! Eu não acho que é assim que funciona, embora o corpo da sub-rotina tenha apenas 28 bytes, mas você não pode deixar de fora subsem quebrá-lo.

— Chris

Mas às vezes uma sub-rotina funciona sem sub, por exemplo, depois sortou grepou como argumento para outra sub-rotina. Vale a pena perguntar sobre o Code Golf Meta .

— Msh210

@ msh210 Uma sub-rotina funciona sem subapenas se for utilizada numa função de protótipo ( sorte grepfor mais ou menos prototipada). Mas, caso contrário, subé necessário. Independentemente, jogar 3 bytes por omissão subnão é realmente interessante.

— Dada

2

Clojure (Script), 36 bytes

A saída é truepara ímpar e falsepara par. Tanto a saída como a entrada são sequências.

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

— madstap
fonte

2

PHP, 50 bytes

Versões Online

1 para ímpar, 0 para par

Saída como sequência separada por _

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

PHP, 72 bytes

Saída como uso de matriz array_map

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

— Jörg Hülsermann
fonte

1

Você pode largar o ?:0que não faz nada. 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 para ímpar, 0 para par

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

— Khaled.K
fonte

2

Retina , 40 38 bytes

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶

Experimente online! Saídas 1 para ímpar e 0 para par. Explicação: As duas primeiras linhas duplicam a entrada uma vez para cada número na entrada, mas sem o próprio elemento. Isso cria uma linha em branco extra que é excluída. A entrada é então convertida de decimal para unária, os espaços são excluídos e a paridade calculada. Paridade uniforme é então convertida em zero e os resultados são reunidos novamente em uma linha. Editar: salvou 2 bytes graças a @FryAmTheEggman. Eu tentei algumas outras versões que são conceitualmente mais agradáveis, mas que levam muitos bytes para serem expressas:

\d\B

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

Altera todas as entradas para sua paridade e, em seguida, vira todas as suas paridades se o total tiver paridade ímpar.

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

11

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

Soma uma duplicata da entrada, pega a paridade de tudo, inverte as paridades se a soma for ímpar e exclui a soma novamente.

— Neil
fonte

Tentei o que me veio à mente e obtive uma solução um pouco mais curta , embora ainda ache que não é a ideal. Particularmente, não gosto de como manejo o zero extra que recebo no final.

— FryAmTheEggman

@FryAmTheEggman Sua economia resulta de uma maneira menos visível de converter seus ;s de volta em espaços. Se você colocar o ;no início, poderá salvar um byte, excluindo-o imediatamente, em vez de depois que ele se converta em 0.

— Neil

Na verdade, olhando de novo, por que o seu último estágio não está apenas substituindo novas linhas por espaços? Isso não salvaria 2 bytes?

— FryAmTheEggman

@FryAmTheEggman Sim; Eu acho que originalmente tinha mais de um substituto para fazer em uma iteração anterior.

— Neil

2

Ohm , 4 bytes

DΣ-é

Experimente online!

Basicamente uma porta direta do MATL e 05AB1E respostas. Usa truepara pares e falseímpares.

— Nick Clifford
fonte

1

k, 9 bytes

{2!x-+/x}

A saída é um 1para odde um 0para par. Experimente online.

Convertido em pseudocódigo, seria:

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

— zgrep
fonte

1

Scala , 19 bytes

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

Experimente online!

— Brian McCutchon
fonte

1

Flak cerebral , 94 68 66 bytes

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

Experimente online!

Isso parece um pouco longo para a tarefa. Pode haver uma maneira mais conveniente de fazer isso.

Explicação

Primeiro calculamos a soma da pilha com:

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

Percorremos toda a pilha, adicionando esse resultado a cada elemento e determinando a paridade

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

Isso usa um algoritmo mod 2 bem legal que eu criei para esse desafio.

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

Isso empurra 1 sob os decréscimos de entrada até que a entrada chegue a zero cada vez que executa 1-no 1 colocado anteriormente e, em seguida, remove a entrada.

— Assistente de Trigo
fonte

Você pode modificar 2 no final. Você não precisa modificar 2 a soma.

— Leaky Nun

@LeakyNun Thanks! Eu apenas percebi isso e fiz a correção.

— Assistente de trigo

1

Sábio , 54 52 bytes

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

Experimente online!

Explicação

Esse código seria muito menor se não fossem necessários tantos bytes para trocar os dois principais elementos. O registro atual é

:?^:!^:?^!

Infelizmente, isso constitui a maioria do código.

Primeiro pegamos a soma XOR da pilha

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

Em seguida, fazemos XOR isso com cada elemento e o elemento com o último bit zerado

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

— Assistente de Trigo
fonte

1

Java , 81 78 bytes

3 bytes graças a 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);}

Experimente online!

Modifica a matriz no local.

— Freira Furada
fonte

Você pode jogar golfe por 3 bytes como este: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);}

— Kevin Cruijssen

67 bytes se você usar um lambda: Experimente online!

— Brian McCutchon

Obrigado, mas eu não gosto de usar um lambda.

— Freira vazando

1

AWK , 64 bytes

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

Experimente online!

Emite a 0para somas pares e 1ímpares separadas por novas linhas. O único pensamento até um pouco fora da caixa foi colocar o printcomando dentro dofor etapa "incremento". Tentei algumas maneiras "inteligentes" de imprimir, mas elas não salvaram bytes.

Apenas para rir, se você não quiser novas linhas:

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

que tem a mesma contagem de bytes que acima, mas é um pouco mais obtuso.

— Robert Benson
fonte

1

Swift - 55 bytes

^{Finalmente bate C! Além disso, 0 para par, 1 para ímpar}

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

Uma função, com uso: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Confira!

— Mr. Xcoder
fonte

Não (x-y)%2x-y&1

— estou

@Cyoce Para mim, após o teste, não funciona. Operações bit a bit não são o forte de Swift

— Mr. Xcoder

1

Axioma, 45 bytes

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

sem verificação do tipo de entrada, possível recálculo da soma "a" de cada elemento ... testes

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

1

Julia 1.0 , 17 bytes

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

Experimente online!

— gggg
fonte

Paridade da soma de outros elementos

Tarefa

Definição

Exemplo

Entrada

Saída

Casos de teste

Pontuação

Gelatina , 3 bytes

Como funciona

JavaScript (ES6), 38 36 32 bytes

Teste

Haskell, 20 bytes

MATL , 5 , 4 bytes

Alice , 31 28 bytes

Explicação

Pitão, 7 6 bytes

Explicação

05AB1E (legado) , 4 3 bytes

Python 2 , 33 31 bytes

R, 21 bytes

Mathematica, 13 bytes

Clojure, 30 bytes

CJam , 10 bytes

Explicação

J , 6 bytes

APL (Dyalog Unicode) , 19 7 bytes

Japonês , 7 bytes

Explicação

Perl 5, 31 bytes

Clojure (Script), 36 bytes

PHP, 50 bytes

PHP, 72 bytes

C, 68 62 bytes

Retina , 40 38 bytes

Ohm , 4 bytes

k, 9 bytes

Scala , 19 bytes

Flak cerebral , 94 68 66 bytes

Explicação

Sábio , 54 52 bytes

Explicação

Java , 81 78 bytes

AWK , 64 bytes

Swift - 55 bytes

Axioma, 45 bytes

Julia 1.0 , 17 bytes