quintopia ha pubblicato qui una sfida per calcolare i coefficienti multinomiali (parte del testo qui viene copiato da lì). Esiste un algoritmo divertente per calcolare i coefficienti multinomiali mod 2.

Dato un elenco di numeri, k ₁ , k ₂ , ..., k _m , genera il residuo del coefficiente multinomiale:

ridotta mod 2. Il seguente algoritmo fa questo efficiente: per ogni k _i , calcolare l'espansione binario di k _i , cioè, trovare un _ij tale che ciascuna un _ij è 1 o 0 e

Se esiste una j tale che a _rj = a _sj = 1 per r ≠ s, il coefficiente multinomiale mod 2 associato è 0, altrimenti il coefficiente multinomiale mod 2 è 1.

Compito

Scrivere un programma o funzione che prende m numeri, k ₁ , k ₂ , ..., k _m , e le uscite o ritorni corrispondente coefficiente multinomiale. Il tuo programma può facoltativamente prendere m come argomento aggiuntivo, se necessario.

Questi numeri possono essere inseriti in qualsiasi formato uno preferisca, ad esempio raggruppati in elenchi o codificati in unario, o qualsiasi altra cosa, purché il calcolo effettivo del coefficiente multinomiale sia eseguito dal codice e non dal processo di codifica.
L'output può essere qualsiasi valore di verità se il coefficiente multinomiale è dispari e qualsiasi valore di falsità se il coefficiente multinomiale è pari.
Non sono ammessi incorporati progettati per calcolare il coefficiente multinomiale.
Si applicano scappatoie standard.

punteggio

Questo è il codice golf: vince la soluzione più breve in byte.

Esempi:

Per trovare il coefficiente multinomiale di 7, 16 e 1000, espandiamo binariamente ciascuno di essi:

Poiché nessuna colonna ha più di 1, il coefficiente multinomiale è dispari e quindi dovremmo produrre qualcosa di vero.

Per trovare il coefficiente multinomiale di 7, 16 e 76, espandiamo binariamente ciascuno di essi:

Dato che sia 76 che 7 hanno un 4 nella loro espansione binaria, il coefficiente multinomiale è pari e quindi produciamo un valore di falso.

Casi test:

Input: [2, 0, 1]
Output: Truthy

Input: [5,4,3,2,1]
Output: Falsey

Input: [1,2,4,8,16]
Output: Truthy

Input: [7,16,76]
Output: Falsey

Input: [7,16,1000]
Output: Truthy

Input: [545, 1044, 266, 2240]
Output: Truthy

Input: [1282, 2068, 137, 584]
Output: Falsey

Input: [274728976, 546308480, 67272744, 135004166, 16790592, 33636865]
Output: Truthy

Input: [134285315, 33849872, 553780288, 544928, 4202764, 345243648]
Output: Falsey

code-golf math combinatorics

— cappuccio
fonte

1

Benvenuti in PPCG! Bel primo post!

— Rɪᴋᴇʀ

Penso che diverse lingue con ==per l'uguaglianza avrebbero potuto salvare un byte se fosse possibile capovolgere la verità e la falsità.

— Ørjan Johansen,

@ ØrjanJohansen Suona bene.

— Hood

9

Gelatina , 4 byte

S=|/

Provalo online!

Verifica se la somma è uguale al bit-o-sum (cioè a+b+c == a|b|c).

— Perdente Suora
fonte

7

Python 3 2, 55 43 42 byte

lambda l:sum(l)==eval(`l`.replace(*',|'))

-12 byte dal signor Xcoder

-1 byte dalla barra

Provalo online!

Spiegazione: Verifica se la somma dei numeri è uguale al bit per bit o ai numeri.

— pizzapants184
fonte

43 byte:lambda l:sum(l)==eval("|".join(map(str,l)))

— Mr. Xcoder

Puoi raggiungere 42 byte passando a python2

— Rod

4

Python 2 , 37 byte

lambda l:sum(l)==reduce(int.__or__,l)

Provalo online!

Un altro porto dell'algoritmo di pizzapants184 ...

— Erik l'Outgolfer
fonte

3

Pulito , 38 byte

import StdEnv
?l=sum l==foldr(bitor)0l

Provalo online!

Ancora un altro porto.

— Οurous
fonte

2

Japt, 6 byte

Un altro porto di pizzapants184 e le soluzioni di Leaky Nun.

x ¶Ur|

Provalo

— ispido
fonte

Tecnicamente, pizzapants184 ha risposto 14 secondi prima di me ...

— Leaky Nun

2

JavaScript (ES6), 37 35 34 byte

Salvato 2 byte grazie a @ Mr.Xcoder
Salvato 1 byte grazie a @ETHproductions

Il confronto della somma con l'OR bit a bit (come hanno fatto pizzapants184 e Leaky Nun ) è 1 3 4 byte più breve del mio approccio iniziale:

a=>(q=c=>eval(a.join(c)))`|`==q`+`

Casi test

Mostra snippet di codice

let f =

a=>(q=c=>eval(a.join(c)))`|`==q`+`

console.log(f([2, 0, 1]))                                                       // Truthy
console.log(f([5,4,3,2,1]))                                                     // Falsey
console.log(f([1,2,4,8,16]))                                                    // Truthy
console.log(f([7,16,76]))                                                       // Falsey
console.log(f([7,16,1000]))                                                     // Truthy
console.log(f([545, 1044, 266, 2240]))                                          // Truthy
console.log(f([1282, 2068, 137, 584]))                                          // Falsey
console.log(f([274728976, 546308480, 67272744, 135004166, 16790592, 33636865])) // Truthy
console.log(f([134285315, 33849872, 553780288, 544928, 4202764, 345243648]))    // Falsey

Espandi frammento

Alt. versione, 38 byte

a=>!a.some((x,i)=>a.some(y=>i--&&x&y))

Casi test

Mostra snippet di codice

let f =

a=>!a.some((x,i)=>a.some(y=>i--&&x&y))

console.log(f([2, 0, 1]))                                                       // Truthy
console.log(f([5,4,3,2,1]))                                                     // Falsey
console.log(f([1,2,4,8,16]))                                                    // Truthy
console.log(f([7,16,76]))                                                       // Falsey
console.log(f([7,16,1000]))                                                     // Truthy
console.log(f([545, 1044, 266, 2240]))                                          // Truthy
console.log(f([1282, 2068, 137, 584]))                                          // Falsey
console.log(f([274728976, 546308480, 67272744, 135004166, 16790592, 33636865])) // Truthy
console.log(f([134285315, 33849872, 553780288, 544928, 4202764, 345243648]))    // Falsey

Espandi frammento

— Arnauld
fonte

Tecnicamente, pizzapants184 ha risposto 14 secondi prima di me ...

— Leaky Nun

-1 byte:a=>(q=c=>eval(a.join(c)))`|`==q`+`;

— ETHproductions

@ETHproductions Nice! Funziona bene in Node.js. Ma sei riuscito a farlo funzionare in un browser?

— Arnauld,

Funziona bene per me in Firefox 57. Stai ricevendo un errore o semplicemente non funziona correttamente?

— ETHproductions

@ETHproductions In realtà, sì, funziona. Succede solo a fallire su repl.it .

— Arnauld,

2

Haskell , 38 byte

(==).sum<*>foldl1 xorè una funzione anonima che restituisce a Bool. Usa come ((==).sum<*>foldl1 xor) [2,0,1].

import Data.Bits
(==).sum<*>foldl1 xor

Provalo online!

Praticamente lo stesso trucco di pizzapants184 e Leaky Nun che tutti usano, tranne che con i nomi degli operatori Haskell salva un byte da usare (bit a bit) xorinvece di (.|.)(bit a bit o).
(==).sum<*>foldl1 xorè una versione gratuita di \l->sum l==foldl1 xor l.

— Ørjan Johansen
fonte

2

Java 8, 53 byte

a->{int i=0,j=0;for(int x:a){i+=x;j|=x;}return i==j;}

La risposta di Port of @LeakyNun 's Jelly .

Spiegazione:

Provalo qui.

a->{             // Method with integer-array parameter and boolean return-type
  int i=0,j=0;   //  Two integers, both starting at 0
  for(int x:a){  //  Loop over the array
    i+=x;        //   Add them to the first integer
    j|=x;}       //   And bitwise-OR it with the second integer
  return i==j;}  //  Return if both integers are the same after the loop

— Kevin Cruijssen
fonte

1

Pyth , 6 byte

qsQ.|F

Test Suite.

— Mr. Xcoder
fonte

1

Buccia , 5 byte

§=ΣFv

Provalo online!

— Mr. Xcoder
fonte

1

Perl 6 , 15 byte

{.sum==[+|] $_}

Provalo

Allargato:

{  # bare block lambda with implicit parameter ｢$_｣

    .sum  # the sum of ｢$_｣ (implicit method call)

  ==

    [+|]  # reduce using &infix:«+|» (numeric binary or)

      $_  # the input
}

— Brad Gilbert b2gills
fonte

1

Rosso , 78 byte

f: func[x][b: :to-binary t: 0 s: b 0 foreach n x[t: t + n s: s or b n]s = b t]

Come funziona:

Ungolfed:

Red []
f: func [x][         -  a function taking a block as an argument
    b: :to-binary    -  an alias for the to-binary function
    t: 0             -  set the sum of the numbers to 0
    s: b 0           -  set the "or" total to binary 0
    foreach n x[     -  for each number in the block
        t: t + n     -  add it to the sum
        s: s or b n  -  bitwise or of its binary representation with the total
    ]
    s = b t          - are the sum (binary) and the "or" total equal?
]

Provalo online!

— Galen Ivanov
fonte

1

Wolfram Language (Mathematica) , 15 byte

Tr@#==BitOr@@#&

Provalo online!

— alephalpha
fonte

0

Lotto, 73 byte

@set/as=o=0
@for %%i in (%*)do @set/as+=%%i,o^|=%%i
@if %s%==%o% echo 1

Uscite 1per truthy, nulla per falsy. Un'altra ovvia porta dell'algoritmo di pizzapants184 / Leaky Nun.

— Neil
fonte

0

J , 10 byte

+/=+./&.#:

Ennesimo port of pizzapants184 e le soluzioni di Leaky Nun.

Come funziona?

+/.&.#: - converti i numeri in binari, applica bit a bit o le potenze di due e converti da binario a decimale

+/ - ridurre l'ingresso per aggiunta

= - sono uguali?

Provalo online!

Alternativa semplice

J , 12 byte

2>[:>./+/@#:

Come funziona?

+/@#: - converti ogni numero in binario e trova la somma di ogni potenza di 2

>./ - trova il massimo

2>- è inferiore a 2? -> verità

Provalo online!

— Galen Ivanov
fonte

0

Triangolarità , 31 byte

...)...
..IEu..
.)IE...
"|"JE=.

Provalo online!

Soluzione alternativa, 31 byte

...)...
..IED..
.us"|".
JE=....

Provalo online!

— Mr. Xcoder
fonte

Mod 2 Coefficienti multinomiali

Compito

punteggio

Esempi:

Casi test:

Gelatina , 4 byte

Python 3 2, 55 43 42 byte

Python 2 , 37 byte

Pulito , 38 byte

Japt, 6 byte

JavaScript (ES6), 37 35 34 byte

Casi test

Alt. versione, 38 byte

Casi test

Haskell , 38 byte

Java 8, 53 byte

Pyth , 6 byte

Buccia , 5 byte

Perl 6 , 15 byte

Allargato:

Rosso , 78 byte

Come funziona:

Wolfram Language (Mathematica) , 15 byte

Lotto, 73 byte

J , 10 byte

Come funziona?

Alternativa semplice

J , 12 byte

Come funziona?

Triangolarità , 31 byte

Soluzione alternativa, 31 byte