Tarea

Dada una matriz de enteros positivos, reemplace cada elemento con la paridad de la suma de los otros elementos. Se garantiza que la matriz tenga al menos 2 elementos.

Definición

• Paridad: si un número es par o impar.

Ejemplo

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

• Reemplazar 1con la paridad de 2+3+1, es decir even.
• Reemplazar 2con la paridad de 1+3+1, es decir odd.
• Reemplazar 3con la paridad de 1+2+1, es decir even.
• Reemplazar 1con la paridad de 1+2+3, es decir even.

Salida: [even, odd, even, even]

Entrada

Una matriz de enteros positivos.

Puede tomarlo como una matriz adecuada o como una cadena de enteros positivos separados por salto de línea.

Puede suponer que la matriz y los valores dentro están dentro de la capacidad de manejo de su idioma.

Salida

Una matriz de dos valores consistentes , uno que representa oddy otro que representa even.

Puede generarlo como una cadena separada por salto de línea de los dos valores.

Casos de prueba

Entradas:

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

Salidas:

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

Nota: puede elegir otros valores consistentes que no sean oddy even.

Tanteo

Este es el código de golf . La respuesta más corta en bytes gana.

Se aplica la escapatoria estándar .

Jalea , 3 bytes

+SḂ

Pruébalo en línea!

Cómo 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.

JavaScript (ES6), 38 36 32 bytes

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

Usos 0para pares e 1impares.

Prueba

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

Usos Truepara valores impares y Falsepara valores pares.

Pruébalo en línea!

Resta cada elemento de la suma de la lista y prueba si es impar.

fvolvió a pointfree también tiene 20 bytes: map=<<(odd.).(-).sum.

MATL , 5 , 4 bytes

ts-o

Pruébalo en línea!

¡Un byte guardado gracias a Dennis!

Esto da '1' para impar y '0' para par. Explicación:

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

Alicia , 31 28 bytes

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

Pruébalo en línea!

El formato de entrada no importa mientras los enteros estén separados. El formato de salida está separado por salto de línea.

El diseño probablemente todavía no sea óptimo, pero todavía no he encontrado una manera de acortar esto.

Explicación

/     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 gracias a @KZhang

Salidas 1 para impar, 2 para par.

¡Intentalo!

Explicación

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 (heredado) , 4 3 bytes

O^È

Pruébalo en línea!

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

Python 2 , 33 31 bytes

^{-2 bytes gracias a Leaky Nun}

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

Pruébalo en línea!

R, 21 bytes

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

lee la lista de stdin y devuelve 0 para pares, 1 para impares. enlaza la entrada a la variable ndentro de la llamada en sumlugar de llamarla afuera, es decir,n=scan();(sum(n)-n)%%2

Pruébalo en línea!

Mathematica, 13 bytes

#+Tr@#&/*OddQ

o

OddQ[#+Tr@#]&

Clojure, 30 bytes

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

Resta todos los valores de cada valor, por ejemplo, con la entrada, [a b c d]el segundo valor calculado es b - a - b - c - d= -(a + c + d). La salida es falsepar e trueimpar.

Pero también podría usar +y calcular cada término subsiguiente dos veces para que no afecte la paridad.

CJam , 10 bytes

{_:+f+1f&}

Este es un bloque anónimo (función) que toma la entrada de la pila y la reemplaza por la salida.

Pruébalo en línea!

Explicación

Considere la 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

J , 6 bytes

2|]++/

Pruébalo en línea!

APL (Dyalog Unicode) , 19 7 bytes

Golfó 12 bytes gracias a @ Adám

2|+/-¨⊢

Pruébalo en línea!

Japt , 7 bytes

£x +X&1

Pruébalo en línea!

Explicación

 £   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,@_}

Salidas 1para pares e impares 0.

Clojure (Script), 36 bytes

La salida es truepara impar y falsepara par. Tanto la salida como la entrada son secuencias.

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

PHP, 50 bytes

Versiones en linea

1 para impar, 0 para par

Salida como cadena separada con _

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

PHP, 72 bytes

Salida como uso de matriz 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 para impar, 0 para par

Prueba detallada en línea

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
¶
 

Pruébalo en línea! Salidas 1 para impar y 0 para par. Explicación: Las dos primeras líneas duplican la entrada una vez para cada número en la entrada, pero sin el elemento en sí. Esto crea una línea en blanco adicional que luego se elimina. La entrada se convierte luego de decimal a unario, los espacios se eliminan y se calcula la paridad. Incluso la paridad se convierte a cero y los resultados se vuelven a unir en una línea. Editar: Guardado 2 bytes gracias a @FryAmTheEggman. Intenté algunas otras versiones que son conceptualmente más agradables pero que requieren demasiados bytes para expresarse:

\d\B

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

Cambia todas las entradas a su paridad, luego voltea todas sus paridades si el total tiene paridad impar.

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

11

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

Suma un duplicado de la entrada, luego toma la paridad de todo, luego invierte las paridades si la suma es impar, luego elimina la suma nuevamente.

Ohm , 4 bytes

DΣ-é

Pruébalo en línea!

Básicamente, un puerto directo de la MAT y 05AB1E respuestas. Usos truepara pares e falseimpares.

k, 9 bytes

{2!x-+/x}

El resultado es un 1para oddy un 0para incluso. Pruébalo en línea.

Convertido a pseudocódigo, sería:

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

Scala , 19 bytes

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

Pruébalo en línea!

Brain-Flak , 94 68 66 bytes

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

Pruébalo en línea!

Esto parece un poco largo para la tarea. Puede haber una forma más conveniente de hacer esto.

Explicación

Primero calculamos la suma de la pila con:

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

Pasamos por toda la pila agregando ese resultado a cada elemento y determinamos la paridad

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

Esto utiliza un algoritmo de mod 2 bastante bueno que se me ocurrió para este desafío.

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

Esto empuja 1 debajo de los decrementos de entrada hasta que la entrada llega a cero cada vez que se realiza 1-nal 1 que colocamos anteriormente, luego elimina la entrada.

Sabio , 54 52 bytes

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

Pruébalo en línea!

Explicación

Este código sería mucho más corto si no tomara tantos bytes para intercambiar los dos elementos superiores. El registro actual es

:?^:!^:?^!

Desafortunadamente, esto constituye la mayoría del código.

Primero tomamos la suma XOR de la pila

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

Luego XOR esto con cada elemento y el elemento con el último bit puesto a cero

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

Java , 81 78 bytes

3 bytes gracias 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);}

Pruébalo en línea!

Modifica la matriz en el lugar.

AWK , 64 bytes

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

Pruébalo en línea!

Emite a 0para sumas pares y 1para sumas impares separadas por nuevas líneas. El único pensamiento un poco fuera de lo común fue colocar el printcomando dentro del forpaso de "incremento". Intenté algunas formas "inteligentes" de imprimir, pero no guardaron bytes.

Solo por risitas, si no quieres nuevas líneas:

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

que tiene el mismo número de bytes que el anterior, pero es un poco más obtuso.

Swift - 55 bytes

^{¡Finalmente vence a C! Además, 0 para pares, 1 para impares}

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

Una función, con uso: g(a: [1,2,3,2,1] // => 0 1 0 1 0

¡Echale un vistazo!

Axioma, 45 bytes

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

sin verificación del tipo de entrada, posible recálculo de la suma "a" de cada elemento ... pruebas

(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

Pruébalo en línea!