Étant donné une collection non ordonnée d'entiers positifs par toute méthode d'entrée raisonnable, renvoyez toutes les sous-collections qui ont un nombre impair d'éléments impairs (c'est-à-dire qui ont un total impair).

Il s'agit de code-golf , vous devez donc viser à minimiser le nombre d'octets de votre programme.

Étant donné que certaines langues ont uniquement des collections ordonnées (listes, tableaux, vecteurs, etc.) ou n'ont pas de collection non ordonnée qui autorise les doublons, vous pouvez utiliser des collections ordonnées (quel que soit votre choix de langue), mais vous ne devez pas générer de collections en double avec des commandes différentes (par exemple [2,3]et [3,2]). Vous pouvez sortir dans l'ordre que vous jugez bon.

Cas de 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 octets

{æÙʒOÉ

Essayez-le en ligne!

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

-2 octets grâce à @EriktheOutgolfer

Python 3 , 93 octets

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}

Renvoie un ensemble de tuples. Très probablement trop longtemps.

Essayez-le en ligne!

Pyth , 10 9 8 octets

{f%sT2yS

Essayez-le en ligne!

         # 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 octets

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

Imprime un ensemble de tuples. Si un ensemble de chaînes est autorisé, tuple(sorted(y))peut être remplacé par `sorted(y)`pour 86 octets .

Essayez-le en ligne!

Gelée , 9 octets

ṢŒPSḂ$ÐfQ

Essayez-le en ligne!

Bug corrigé grâce à 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 octets

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

Pour filtrer les combinaisons identiques, je filtre les doublons en les convertissant en une Bag(collection non ordonnée) avant de comparer. Malheureusement, je n'ai pas pu trouver un moyen d'accepter une Bagentrée aussi concise.

Brachylog , 11 octets

o⊇ᵘ{+ḃt1&}ˢ

Essayez-le en ligne!

J'espérais trouver une solution plus courte, mais voici le mieux que je pouvais faire.

Explication

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.

Ouais, j'aurais pu utiliser modulo 2 pour vérifier la bizarrerie, mais ce n'est pas une approche étrange;)

Mathematica 31 44 38 octets

Parmi tous les sous-ensembles de l'ensemble d'entrée, il renvoie ceux pour lesquels la somme Tr,, est impaire.

6 octets économisés grâce à 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 octets

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

prend l'entrée des arguments de la ligne de commande; courir avec -nrou l' essayer en ligne .

panne

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