Data una raccolta non ordinata di numeri interi positivi con qualsiasi metodo di input ragionevole, restituisce tutte le sotto-raccolte che hanno un numero dispari di elementi dispari (cioè hanno un totale dispari).

Questo è code-golf quindi dovresti mirare a minimizzare il conteggio dei byte del tuo programma.

Poiché alcune lingue hanno solo raccolte ordinate (elenchi, matrici, vettori, ecc.) O non hanno una raccolta non ordinata che consente duplicati, è possibile utilizzare raccolte ordinate (indipendentemente dalla scelta della lingua), tuttavia non è necessario generare raccolte duplicate con ordini diversi (ad es. [2,3]e [3,2]). È possibile produrre in qualunque ordine si ritenga opportuno.

Casi test

[2,3,7,2] -> [[3],[7],[2,3],[2,7],[2,2,3],[2,2,7]]
[2,4,6,8] -> []
[4,9]     -> [[9],[4,9]]

05AB1E , 6 byte

{æÙʒOÉ

Provalo online!

{æÙʒOÉ
{      Sort
 æ     Powerset
  Ù    Uniqufy
   ʒ   Keep elements where
    O                      the sum
     É                             is uneven

-2 byte grazie a @EriktheOutgolfer

Python 3 , 93 byte

f=lambda x,r=[[]]:x and f(x[1:],r+[y+x[:1]for y in r])or{(*sorted(y),)for y in r if sum(y)&1}

Restituisce una serie di tuple. Molto probabilmente troppo a lungo.

Provalo online!

Pyth , 10 9 8 byte

{f%sT2yS

Provalo online!

         # implicit input
       S # sort input, this way the subsets will already be sorted
      y  # all subsets
 f       # filter elements when ..
   sT    # the sum ..
  %  2   # is odd
{        # remove all duplicated elements
         # implicit output

Python 2 , 91 byte

r=[[]]
for n in input():r+=map([n].__add__,r)
print{tuple(sorted(y))for y in r if sum(y)&1}

Stampa una serie di tuple. Se è consentito un set di stringhe, tuple(sorted(y))può essere sostituito con `sorted(y)`per 86 byte .

Provalo online!

Gelatina , 9 byte

ṢŒPSḂ$ÐfQ

Provalo online!

Bug risolto grazie a Jonathan Allan.

ṢŒPSḂ$ÐfQ  Main Link
Ṣ          Sort
 ŒP        Powerset
      Ðf   Filter to keep elements where                         is truthy
    Ḃ                                    the last bit of
   S                                                     the sum
        Q  Only keep unique elements

Perl 6 , 50 byte

{.combinations.grep(*.sum!%%2).unique(:as(*.Bag))}

Per filtrare le combinazioni uguali fino all'ordine, filtrare i duplicati convertendoli in una Bag(raccolta non ordinata) prima del confronto. Sfortunatamente non sono riuscito a trovare un modo per accettare un Baginput così conciso.

Brachylog , 11 byte

o⊇ᵘ{+ḃt1&}ˢ

Provalo online!

Speravo di trovare una soluzione più breve, ma ecco il meglio che potrei fare.

Spiegazione

o⊇ᵘ{+ḃt1&}ˢ    
o                                        the input, sorted
 ⊇ᵘ           Find all unique subsets of

   {    &}ˢ   Then select only those results where
    +                                          the sum
     ḃ                           the base 2 of
      t        The last digit of
       1                                               is 1.

Sì, avrei potuto usare il modulo 2 per verificare la stranezza, ma questo non è un approccio strano;)

Mathematica 31 44 38 byte

Tra tutti i sottoinsiemi del set di input, restituisce quelli per i quali la somma Trè dispari.

6 byte salvati grazie ad alephalpha.

Select[Union@Subsets@Sort@#,OddQ@*Tr]&

 Select[Union@Subsets@Sort@#,OddQ@*Tr]&[{2,3,7,2}]

{{3}, {7}, {2, 3}, {2, 7}, {2, 2, 3}, {2, 2, 7}}

PHP, 126 byte

for(;++$i>>$argc<1;sort($t),$s&1?$r[join(_,$t)]=$t:0)for ($t=[],$j=$s=0;++$j<$argc;)$i>>$j&1?$s+=$t[]=$argv[$j]:0;print_r($r);

accetta input dagli argomenti della riga di comando; corri con -nro provalo online .

abbattersi

for(;++$i>>$argc<1;             # loop through subsets
    sort($t),                       # 2. sort subset
    $s&1?$r[join(_,$t)]=$t:0        # 3. if sum is odd, add subset to results
    )                               # 1. create subset:
    for ($t=[],$j=$s=0;++$j<$argc;)     # loop through elements
        $i>>$j&1?                       # if bit $j is set in $i
        $s+=$t[]=$argv[$j]:0;           # then add element to subset
print_r($r);                    # print results