Compito

Dato un array di numeri interi positivi, sostituisci ogni elemento con la parità della somma degli altri elementi. Si garantisce che l'array abbia almeno 2 elementi.

Definizione

Parità: se un numero è pari o dispari.

Esempio

Per l'array [1,2,3,1]:

Sostituire 1con la parità di 2+3+1, ad es even.
Sostituire 2con la parità di 1+3+1, ad es odd.
Sostituire 3con la parità di 1+2+1, ad es even.
Sostituire 1con la parità di 1+2+3, ad es even.

Produzione: [even, odd, even, even]

Ingresso

Un array di numeri interi positivi.

Puoi prenderlo come un array appropriato o come una stringa separata di linefeed di numeri interi positivi.

Puoi presumere che l'array e i valori all'interno siano all'interno della capacità di gestione della tua lingua.

Produzione

Un array di due valori coerenti , uno che rappresenta odd, uno che rappresenta even.

È possibile emetterlo come una stringa separata da avanzamento riga dei due valori.

Casi test

ingressi:

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

Uscite:

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

Nota: è possibile scegliere altri valori coerenti diversi da odde even.

punteggio

Questo è code-golf . Vince la risposta più breve in byte.

Si applica la scappatoia standard .

code-golf array-manipulation

— Perdente Suora
fonte

16

Gelatina , 3 byte

+SḂ

Provalo online!

Come funziona

+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

Questo è un approccio intelligente.

— Leaky Nun,

1

@LeakyNun È lo stesso approccio che usano tutti, solo più breve: P

— ETHproductions

@ETHproductions Praticamente, sì. Esistono solo tanti modi per calcolare la parità ...

— Dennis,

@ETHproductions utilizza l'aggiunta anziché la sottrazione ...

— Leaky Nun

@LeakyNun È vero, anche la mia risposta di Japt lo fa. In Jelly sarebbe solo_SḂ

— ETHproductions

8

JavaScript (ES6), 38 36 32 byte

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

Utilizza 0per pari e 1dispari.

Test

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

Espandi frammento

— Luca
fonte

2 byte di sconto: c-b&1invece di(c-b)%2

— Leaky Nun,

Bah! Mi hai battuto sul tempo!

— Shaggy,

1

Dovrò ricordarsi di utilizzare eval(a.join`+`)sopra a.reduce((x,y)=>x+y). È intelligente

— Cyoce

8

Haskell, 20 byte

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

Utilizza Trueper valori dispari e Falseper valori pari.

Provalo online!

Sottrarre ciascun elemento dalla somma dell'elenco e verificare se è dispari.

frivolti a pointfree ha anche 20 byte: map=<<(odd.).(-).sum.

— Nome del modello
fonte

6

MATL , 5 , 4 byte

ts-o

Provalo online!

Un byte salvato grazie a Dennis!

Questo dà '1' per dispari e '0' per pari. Spiegazione:

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 byte

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

Provalo online!

Il formato di input non ha importanza finché i numeri interi sono separati. Il formato di output è separato da avanzamento riga.

Il layout probabilmente non è ancora ottimale, ma non ho ancora trovato un modo per accorciarlo ulteriormente.

Spiegazione

/     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

Pyth, 7 6 byte

mi2-sQ

-1 Byte grazie a @KZhang

Uscite 1 per dispari, 2 per pari.

Provalo!

Spiegazione

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

Modificando il modulo %_2in un GCD i2_, è anche possibile effettuare la dmodifica implicita del codice in mi2-sQ, salvando un byte. Le uscite vengono cambiate in 2 per pari e 1 per dispari.

— K Zhang,

6

05AB1E (legacy) , 4 3 byte

O^È

Provalo online!

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

— Riley
fonte

1 byte off

— Leaky Nun

So che è passato del tempo, ma è possibile rimuovere l'iniziale D, poiché l'input è implicitamente.

— Kevin Cruijssen,

5

Python 2 , 33 31 byte

^{-2 byte grazie a Leaky Nun}

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

Provalo online!

— asta
fonte

2 byte di sconto: sum(x)-z&1invece di(sum(x)-z)%2

— Leaky Nun,

3

sum(x,z)%2funzionerebbe anche

— xnor

4

R, 21 byte

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

legge l'elenco da stdin e restituisce 0 per pari, 1 per dispari. associa l'input alla variabile nall'interno della chiamata suminvece di chiamarla all'esterno, ovveron=scan();(sum(n)-n)%%2

Provalo online!

— Giuseppe
fonte

3

Mathematica, 13 byte

#+Tr@#&/*OddQ

o

OddQ[#+Tr@#]&

— Martin Ender
fonte

3

Clojure, 30 byte

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

Sottrae a turno tutti i valori di ciascun valore, ad esempio inserendo [a b c d]il 2o valore calcolato è b - a - b - c - d= -(a + c + d). L'output è falsepari e truedispari.

Ma potresti anche usare +e calcolare ogni termine successivo due volte in modo da non influire sulla parità.

— NikoNyrh
fonte

3

CJam , 10 byte

{_:+f+1f&}

Questo è un blocco (funzione) anonimo che accetta l'input dallo stack e lo sostituisce con l'output.

Provalo online!

Spiegazione

Considera l'input [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 byte

2|]++/

Provalo online!

— Perdente Suora
fonte

3

APL (Dyalog Unicode) , 19 7 byte

Giocato a golf 12 byte grazie a @ Adám

2|+/-¨⊢

Provalo online!

— Kritixi Lithos
fonte

2

Japt , 7 byte

£x +X&1

Provalo online!

Spiegazione

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

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

Uscite 1per pari e dispari 0.

— Chris
fonte

+1, carino. Penso che questo sia di 28 byte: perldoc perlsubdice : "La firma fa parte del corpo di una subroutine. Normalmente il corpo di una subroutine è semplicemente un blocco di codice rinforzato".

— msh210,

@ msh210 Grazie! Non penso che funzioni così, anche se il corpo della subroutine ha solo 28 byte, ma non puoi lasciarlo fuori subsenza romperlo.

— Chris,

Ma a volte una subroutine funziona senza sub, ad esempio, dopo sorto grepo come argomento per un'altra subroutine. Questo potrebbe valere la pena di chiedere informazioni su Code Golf Meta .

— msh210

@ msh210 Una subroutine funziona subsolo se viene utilizzata in una funzione prototipata ( sorte greppiù o meno prototipata). Ma per il resto, subè necessario. Indipendentemente da ciò, giocare a golf a 3 byte omettendo subnon è davvero interessante.

— Dada,

2

Clojure (Script), 36 byte

L'output è trueper pari e dispari false. Sia l'output che l'input sono sequenze.

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

— madstap
fonte

2

PHP, 50 byte

Versioni online

1 per dispari, 0 per pari

Uscita come stringa separata con _

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

PHP, 72 byte

Output come utilizzo dell'array array_map

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

— Jörg Hülsermann
fonte

1

Puoi lasciar perdere ?:0non fa nulla. foreach($_GET as$v)echo array_sum($_GET)-$v&1,_;

— Christoph,

2

C, 68 62 byte

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

1 per dispari, 0 per pari

Prova dettagliata 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 byte

\d+
¶$` $'
^¶

\d+
$*
+` |11

%M`1
¶

Provalo online! Uscite 1 per pari e 0 per pari. Spiegazione: Le prime due righe duplicano l'input una volta per ogni numero nell'input, ma senza l'elemento stesso. Ciò crea una riga vuota aggiuntiva che viene quindi eliminata. L'input viene quindi convertito da decimale a unario, gli spazi vengono eliminati e la parità calcolata. La parità pari viene quindi convertita in zero e i risultati vengono nuovamente riuniti in una riga. Modifica: salvato 2 byte grazie a @FryAmTheEggman. Ho provato alcune altre versioni che sono concettualmente più gradevoli ma che richiedono troppi byte per esprimere:

\d\B

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

Modifica tutti gli input nella loro parità, quindi inverte tutte le loro parità se il totale ha parità dispari.

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

11

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

Somma un duplicato dell'input, quindi prende la parità di tutto, quindi inverte le parità se la somma è dispari, quindi elimina nuovamente la somma.

— Neil
fonte

Ho provato quello che mi è venuto in mente e ho ottenuto una soluzione leggermente più breve , anche se penso ancora che non sia ottimale. In particolare, non mi piace il modo in cui gestisco lo zero in più che ottengo alla fine.

— FryAmTheEggman,

@FryAmTheEggman Il tuo risparmio deriva dall'avere un modo meno visibile di convertire i tuoi ;spazi in spazi. Se si inserisce ;all'inizio, è possibile salvare un byte eliminandolo immediatamente anziché dopo che viene convertito in 0.

— Neil

In realtà, guardando di nuovo, perché la tua ultima tappa non sta semplicemente sostituendo le nuove linee con gli spazi? Non risparmierebbe 2 byte?

— FryAmTheEggman,

@FryAmTheEggman Sì; Penso che inizialmente avevo più di un sostituto da effettuare in una precedente iterazione.

— Neil,

2

Ohm , 4 byte

DΣ-é

Provalo online!

Fondamentalmente una porta diretta delle risposte MATL e 05AB1E . Utilizza trueper pari e falsedispari.

— Nick Clifford
fonte

1

k, 9 byte

{2!x-+/x}

L'output è un 1for odde un 0for even. Provalo online.

Convertito in pseudocodice, sarebbe:

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

— zgrep
fonte

1

Scala , 19 byte

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

Provalo online!

— Brian McCutchon
fonte

1

Brain-Flak , 94 68 66 byte

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

Provalo online!

Questo sembra un po 'lungo per l'attività. Potrebbe esserci un modo più conveniente per farlo.

Spiegazione

Innanzitutto calcoliamo la somma dello stack con:

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

Andiamo attraverso l'intero stack aggiungendo quel risultato a ciascun elemento e determiniamo la coppia

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

Questo utilizza un algoritmo mod 2 piuttosto interessante che mi è venuto in mente per questa sfida.

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

Questo spinge 1 sotto i decrementi dell'input fino a quando l'input raggiunge lo zero ogni volta che si esegue 1-ncon l'1 che abbiamo inserito in precedenza, quindi rimuove l'input.

— Mago del grano
fonte

Puoi mod 2 alla fine. Non è necessario modificare 2 la somma.

— Leaky Nun,

@LeakyNun Grazie! L'ho appena capito e ho fatto la correzione.

— Wheat Wizard

1

Saggio , 54 52 byte

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

Provalo online!

Spiegazione

Questo codice sarebbe molto più breve se non ci volessero così tanti byte per scambiare i primi due elementi. Il record attuale è

:?^:!^:?^!

Questo purtroppo costituisce la maggior parte del codice.

Per prima cosa prendiamo la somma XOR dello stack

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

Quindi XOR questo con ogni elemento e l'elemento con l'ultimo bit azzerato

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

— Mago del grano
fonte

1

Java , 81 78 byte

3 byte grazie 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);}

Provalo online!

Modifica l'array sul posto.

— Perdente Suora
fonte

Puoi giocare a golf di 3 byte in questo modo: 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 byte se usi un lambda: provalo online!

— Brian McCutchon,

Grazie, ma non mi piace usare un lambda.

— Leaky Nun,

1

AWK , 64 byte

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

Provalo online!

Emette a 0per somme pari e 1per somme dispari separate da newline. L'unico pensiero appena uscito dalla scatola era inserire il printcomando all'interno del passaggio for"incremento". Ho provato alcuni modi "intelligenti" per stampare, ma non hanno salvato i byte.

Solo per risatine, se non vuoi newline:

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

che ha lo stesso numero di byte di cui sopra, ma è un po 'più ottuso.

— Robert Benson
fonte

1

Rapido - 55 byte

^{Finalmente batte C! Inoltre, 0 per pari, 1 per dispari}

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

Una funzione, con utilizzo: g(a: [1,2,3,2,1] // => 0 1 0 1 0

Controlla!

— Mr. Xcoder
fonte

Non hai familiarità con Swift, ma in molte lingue puoi sostituirlo (x-y)%2conx-y&1

— Cyoce

@Cyoce Per me, dopo il test, non funziona. Le operazioni

— bit per bit

1

Assioma, 45 byte

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

nessun controllo per tipo di input, possibile ricalcolo della somma "a" per ogni elemento ... test

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

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

Provalo online!

— gggg
fonte

Parità di somma di altri elementi

Compito

Definizione

Esempio

Ingresso

Produzione

Casi test

punteggio

Gelatina , 3 byte

Come funziona

JavaScript (ES6), 38 36 32 byte

Test

Haskell, 20 byte

MATL , 5 , 4 byte

Alice , 31 28 byte

Spiegazione

Pyth, 7 6 byte

Spiegazione

05AB1E (legacy) , 4 3 byte

Python 2 , 33 31 byte

R, 21 byte

Mathematica, 13 byte

Clojure, 30 byte

CJam , 10 byte

Spiegazione

J , 6 byte

APL (Dyalog Unicode) , 19 7 byte

Japt , 7 byte

Spiegazione

Perl 5, 31 byte

Clojure (Script), 36 byte

PHP, 50 byte

PHP, 72 byte

C, 68 62 byte

Retina , 40 38 byte

Ohm , 4 byte

k, 9 byte

Scala , 19 byte

Brain-Flak , 94 68 66 byte

Spiegazione

Saggio , 54 52 byte

Spiegazione

Java , 81 78 byte

AWK , 64 byte

Rapido - 55 byte

Assioma, 45 byte

Julia 1.0 , 17 byte