Moyenne sur deux listes

Défi

Étant donné deux listes d'entiers positifs, déterminez s'il est possible de réorganiser les éléments en deux nouvelles listes de sorte que les nouvelles listes aient la même moyenne arithmétique (moyenne).

Contribution

L'entrée peut être prise via STDIN ou comme arguments de fonction. L'entrée peut être considérée comme une liste, ou si votre langue ne prend pas en charge les listes (ou tout autre élément similaire tel que des tableaux / dictionnaires), l'entrée peut être considérée comme une chaîne délimitée par des virgules ou des espaces. C'est,

"1 4 8 2 5,3 1 5 2 5"

est le même que:

[ [1,4,8,2,5], [3,1,5,2,5] ]

Toutes les listes d' entrée auront la même longueur.

Production

Si vous pouvez créer deux nouvelles listes avec la même moyenne, votre programme / fonction doit imprimer ou renvoyer la moyenne. Si vous ne le pouvez pas, votre programme devrait afficher un visage triste :(.

Notez que les listes réarrangées avec des moyennes égales, si elles existent, n'ont pas besoin d'avoir la même longueur. Un nombre illimité de swaps peut être effectué pour créer les nouvelles listes.

Exemples

1 4 8 2 5,3 1 5 2 5 -> 1 4 8 2 3,5 1 5 2 5 (swapped 3 and 5) -> 3.6
1 3 6 2,16 19 19 14 -> [[1,6,19,14],[3,2,16,19]] -> 10
2 6 2,6 3 5 -> 2 6,2 6 3 5 (moved 2) -> 4
90 80 20 1,40 60 28 18 -> :(

C'est le code-golf donc le code le plus court en octets gagne. Comme toujours, les failles standard sont interdites.

Pyth, 24 octets

?}KcsJsQlJmcsdldtPyJK":(

Essayez-le en ligne: Démonstration

Merci à Dennis d'avoir remarqué une erreur et d'avoir joué un octet au golf.

Explication:

?}KcsJsQlJmcsdldtPyJK":(   implicit: Q = evaluated input
      sQ                   all numbers of Q
     J                     save them in J
  KcsJ  lJ                 average of J (sum(J) / len(J))
                           store in K
          m     tPyJ       map each nonempty subset d of J to:
           csdld             average of d
?}                         if K in ^:
                    K        print K
                     ":(   else print sad-face

SWI-Prolog, 159 octets

a(A,B):-append([A,B],R),permutation(R,S),append([Y,Z],S),sum_list(Y,I),sum_list(Z,J),length(Y,L),length(Z,M),L\=0,M\=0,I/L=:=J/M,W is J/M,write(W);write(':(').

Appelé comme a([1,4,8,2,5],[3,1,5,2,5]).

Julia, 101 octets

f(a,b)=(m=mean;p=filter(i->m(i[1])==m(i[2]),partitions([a,b],2));isempty(p)?":(":m(collect(p)[1][1]))

Cela crée une fonction qui accepte deux tableaux et renvoie une chaîne ou un flottant en conséquence.

Non golfé + explication:

function f(a,b)
    # Get the set of all 2-way partitions of the array [a,b]
    l = partitions([a,b], 2)

    # Filter the set of partitions to those where the two
    # contained arrays have equal means
    p = filter(i -> mean(i[1]) == mean(i[2]), l)

    # Return a frown if p is empty, otherwise return a mean
    isempty(p) ? ":(" : mean(collect(p)[1][1])
end

R, 94 octets

Fondamentalement, la même chose que Jakubes, je pense. Si la moyenne des deux listes correspond à la moyenne de toute combinaison des valeurs dans les listes jusqu'à mais sans inclure la longueur combinée de la liste, sortez la moyenne sinon le visage triste.

if(mean(l<-scan())%in%unlist(sapply(2:length(l)-1,function(x)combn(l,x,mean))))mean(l)else':('

Essai

> if(mean(l<-scan())%in%unlist(sapply(2:length(l)-1,function(x)combn(l,x,mean))))mean(l)else':('
1: 1 4 8 2 5
6: 3 1 5 2 5
11: 
Read 10 items
[1] 3.6
> if(mean(l<-scan())%in%unlist(sapply(2:length(l)-1,function(x)combn(l,x,mean))))mean(l)else':('
1: 90 80 20 1
5: 40 60 28 18
9: 
Read 8 items
[1] ":("

Gelée , 22 octets

FŒ!œs2ÆmE$$Ðf⁾:(ÆmX$Ṇ?

Essayez-le en ligne!

Fait avec l'aide de M. Xcoder dans le chat

Explication

FŒ!œs2ÆmE$$Ðf⁾:(ÆmX$Ṇ? - Main link, argument a (2D-array)

F                      - Flatten
 Œ!                    - All permutations
           Ðf          - Keep elements which are truthy when
   œs2    $            -   split into 2 parts and...
      Æm $             -   the means of each...
        E              -   are the same
                     ? - Ternary if
                    Ṇ  -   Condition: No lists remain
             ⁾:(       -   If so: Set the return value to ":("
                   $   -   Otherwise: 
                Æm     -     Get the mean of each list
                  X    -     Randomly choose one (all elements are the same)