Les six principaux acteurs de la sitcom américaine Friends ont tous convenu qu'ils recevraient le même salaire tout au long de la série (après la saison 2, au moins). Mais cela ne signifie pas qu'ils avaient tous la même quantité de temps d'antenne ou qu'ils interagissaient tous à l'écran avec la même quantité.

Dans ce défi, vous écrirez un programme qui pourrait aider à déterminer quels amis Friends étaient vraiment les meilleurs.

Installer

Pensez à regarder un épisode ou une scène de Friends et à noter exactement qui est à l'écran pendant chaque prise de vue et pendant combien de temps.

Nous abrégerons le nom de chaque personnage:

• Cest pour Chandler
• Jest pour Joey
• Mest pour Monica
• Pc'est pour Phoebe
• Rest pour Rachel
• Sest pour Ross

Ensuite, pour chaque prise de vue (ou chaque fois qu'un personnage entre / sort la prise), nous répertorions qui était à l'écran. Par exemple:

504 CRS
200 J
345 MP
980
2000 CJMPRS

Cela veut dire que:

• Pendant 504 ms, Chandler, Rachel et Ross étaient à l'écran.
• Puis pendant 200 ms, Joey était.
• Puis pendant 345 ms, Monica et Phoebe l'ont été.
• Puis pendant 980 ms, aucun des 6 personnages principaux n'était à l'écran.
• Puis pendant 2 secondes, ils l'ont tous été.

^{(Ce n'est pas à partir d'un clip réel, je l'ai inventé.)}

Notez que ce qui suit serait équivalent:

504 CRS
1 J
199 J
345 MP
980
2000 CJMPRS

Pour analyser les combinaisons de caractères ayant le plus de temps d'écran, nous examinons les 64 sous-ensembles possibles des 6 caractères et totalisons le temps d'écran qu'ils avaient. Si tous les membres d'un sous-ensemble apparaissent à l'écran pendant une prise de vue, même s'il y a plus de caractères que ceux du sous-ensemble , la durée de cette prise de vue est ajoutée à la durée totale d'écran de ce sous-ensemble.

Il y a une exception pour le sous-ensemble vide - seules les scènes avec aucun des 6 personnages principaux sont comptées.

Ainsi, l'analyse de l'exemple ci-dessus serait:

980
2504 C
2200 J
2345 M
2345 P
2504 R
2504 S
2000 CJ
2000 CM
2000 CP
2504 CR
2504 CS
2000 JM
2000 JP
2000 JR
2000 JS
2345 MP
2000 MR
2000 MS
2000 PR
2000 PS
2504 RS
2000 CJM
2000 CJP
2000 CJR
2000 CJS
2000 CMP
2000 CMR
2000 CMS
2000 CPR
2000 CPS
2504 CRS
2000 JMP
2000 JMR
2000 JMS
2000 JPR
2000 JPS
2000 JRS
2000 MPR
2000 MPS
2000 MRS
2000 PRS
2000 CJMP
2000 CJMR
2000 CJMS
2000 CJPR
2000 CJPS
2000 CJRS
2000 CMPR
2000 CMPS
2000 CMRS
2000 CPRS
2000 JMPR
2000 JMPS
2000 JMRS
2000 JPRS
2000 MPRS
2000 CJMPR
2000 CJMPS
2000 CJMRS
2000 CJPRS
2000 CMPRS
2000 JMPRS
2000 CJMPRS

Nous pouvons voir que J(juste Joey) avait 2200 ms de temps d'écran parce qu'il en avait 200 par lui-même et 2000 avec tout le monde.

Défi

Écrivez un programme qui accepte une chaîne ou un fichier texte tel que

504 CRS
200 J
345 MP
980
2000 CJMPRS

où chaque ligne a le formulaire [time in ms] [characters on screen], et affiche le temps total que chacun des 64 sous-ensembles des 6 caractères a passé à l'écran, où chaque ligne a le formulaire [total time in ms for subset] [characters in subset](comme ci-dessus).

L'entrée peut être considérée comme une chaîne de stdin, la ligne de commande ou une fonction, ou il peut s'agir du nom d'un fichier texte contenant les données.

• Les nombres en millisecondes seront toujours des entiers positifs.
• Les lettres des caractères seront toujours dans l'ordre CJMPRS(alphabétique).
• Vous pouvez éventuellement supposer qu'il y a un espace de fin lorsqu'il n'y a pas de personnages dans la scène (par exemple 980 ).
• Vous pouvez éventuellement supposer qu'il existe une nouvelle ligne de fin.
• L'entrée aura au moins 1 ligne et peut en avoir arbitrairement plusieurs.

La sortie doit être imprimée, renvoyée ou écrite dans un autre fichier texte sous la forme d'une chaîne de 64 lignes.

• Les lignes peuvent être dans n'importe quel ordre.
• Les lettres de caractères n'ont pas besoin d'être dans l' CJMPRSordre.
• Avec le temps total des sous - ensembles de 0ms ne doivent être énumérés.
• Il peut éventuellement y avoir un espace de fin après le total de sous-ensemble vide.
• Il peut éventuellement y avoir une nouvelle ligne de fin.

(Ce problème peut bien sûr être généralisé à plus de personnages, mais nous nous en tiendrons aux 6 personnages CJMPRS amis .)

Le code le plus court en octets gagne.

^{Notez que j'apprécie réellement les amis et ne pense pas que certains personnages sont plus importants que les autres. Les statistiques seraient cependant intéressantes. ;)}

Pyth, 37 octets

Vy"CJMPRS"++smvhdf?q@eTNNN!eTcR\ .zdN

Essayez-le en ligne: Démonstration

Explication:

  "CJMPRS"                             string with all friends
 y                                     create all subsets
V                                      for loop, N iterates over ^:
                                 .z      all input lines
                             cR\         split each line at spaces
                 f                       filter for lines T, which satisfy:
                  ?      N                 if N != "":
                   q@eTNN                    intersection(T[1],N) == N
                                           else:
                          !eT                T[1] == ""
             m                           map each of the remaining d to:
              vhd                          eval(d[0]) (extract times)
            s                            sum
           +                       d     + " "
          +                         N    + N
                                         implicitly print

Haskell, 187 octets

f=g.(>>=(q.words)).lines
g t=p"CJMPRS">>=(\k->show(sum.map snd$filter((==k).fst)t)++' ':k++"\n")
q[n]=[("",read n)]
q[n,s]=[(k,read n)|k<-tail$p s]
p s=map concat$sequence[[[],[c]]|c<-s]

fest une fonction qui prend l'entrée, sous la forme d'une chaîne multi-lignes unique, et renvoie la sortie multi-lignes sous la forme d'une chaîne unique. Il reste probablement beaucoup de terrain de golf ici.

λ: putStr test1
504 CRS
1 J
199 J
345 MP
980
2000 CJMPRS

λ: putStr $ f test1
980 
2504 S
2504 R
2504 RS
2345 P
2000 PS
2000 PR
2000 PRS
2345 M
2000 MS
2000 MR
2000 MRS
2345 MP
2000 MPS
2000 MPR
2000 MPRS
2200 J
2000 JS
2000 JR
2000 JRS
2000 JP
2000 JPS
2000 JPR
2000 JPRS
2000 JM
2000 JMS
2000 JMR
2000 JMRS
2000 JMP
2000 JMPS
2000 JMPR
2000 JMPRS
2504 C
2504 CS
2504 CR
2504 CRS
2000 CP
2000 CPS
2000 CPR
2000 CPRS
2000 CM
2000 CMS
2000 CMR
2000 CMRS
2000 CMP
2000 CMPS
2000 CMPR
2000 CMPRS
2000 CJ
2000 CJS
2000 CJR
2000 CJRS
2000 CJP
2000 CJPS
2000 CJPR
2000 CJPRS
2000 CJM
2000 CJMS
2000 CJMR
2000 CJMRS
2000 CJMP
2000 CJMPS
2000 CJMPR
2000 CJMPRS

SWI-Prolog, 381 octets

s([E|T],[F|N]):-E=F,(N=[];s(T,N));s(T,[F|N]).
a(A):-split_string(A," \n","",B),w(B,[],C),setof(L,s(`CJMPRS`,L),M),x(C,[` `|M]).
w([A,B|T],R,Z):-number_string(N,A),(B="",C=` `;string_codes(B,C)),X=[[N,C]|R],(T=[],Z=X;w(T,X,Z)).
x(A,[M|T]):-y(M,A,0,R),atom_codes(S,M),writef("%t %w\n",[R,S]),(T=[];x(A,T)).
y(_,[],R,R).
y(M,[[A,B]|T],R,Z):-subset(M,B),S is R+A,y(M,T,S,Z);y(M,T,R,Z).

Cela devrait être exécuté comme:

a("504 CRS
200 J
345 MP
980 
2000 CJMPRS").

Notez que vous devrez peut-être remplacer tous les `vers "et tous "les 'si vous avez une ancienne version de SWI-Prolog.

Je pourrais raser plus de 100 octets si je n'avais pas à utiliser une chaîne comme entrée.

Haskell, 150 136 octets

import Data.List
f=(subsequences"CJMPRS">>=).g
g l c=show(sum[read x|(x,y)<-map(span(/=' '))$lines l,c\\y==[],c/=[]||c==y])++' ':c++"\n"

Exemple d'utilisation:

*Main> putStr $ f "504 CRS\n1 J\n199 J\n345 MP\n980\n2000 CJMPRS"
980 
2504 C
2200 J
2000 CJ
2345 M
2000 CM
2000 JM
2000 CJM
2345 P
2000 CP
2000 JP
2000 CJP
2345 MP
2000 CMP
2000 JMP
2000 CJMP
2504 R
2504 CR
2000 JR
2000 CJR
2000 MR
2000 CMR
2000 JMR
2000 CJMR
2000 PR
2000 CPR
2000 JPR
2000 CJPR
2000 MPR
2000 CMPR
2000 JMPR
2000 CJMPR
2504 S
2504 CS
2000 JS
2000 CJS
2000 MS
2000 CMS
2000 JMS
2000 CJMS
2000 PS
2000 CPS
2000 JPS
2000 CJPS
2000 MPS
2000 CMPS
2000 JMPS
2000 CJMPS
2504 RS
2504 CRS
2000 JRS
2000 CJRS
2000 MRS
2000 CMRS
2000 JMRS
2000 CJMRS
2000 PRS
2000 CPRS
2000 JPRS
2000 CJPRS
2000 MPRS
2000 CMPRS
2000 JMPRS
2000 CJMPRS

Approche différente de la réponse de @ MtnViewMark : pour toutes les combinaisons cde caractères, trouvez les lignes de la chaîne d'entrée où la différence cet la liste des lignes ysont vides (attention au cas spécial où aucun caractère n'est à l'écran (par exemple 980) -> cne doit pas être vide ou c == y). Extraire le nombre et la somme.

CJam, 67 58 octets

"CJMPRS"6m*_.&:$_&qN/_{_el=},:~1bpf{{1$\-!},Sf/0f=:i1bS\N}

Essayez-le en ligne dans l' interpréteur CJam .

Perl 5 (5.10+), 128 octets

2 octets par ligne de sortie. use feature "say"non inclus dans le nombre d'octets.

@_=<>;for$i(0..63){@c=qw(C J M P R S)[grep$i&(1<<$_),0..5];
$r=@c?join".*","",@c:'$';$t=0;for(@_){$t+=$1 if/(.*) $r/}say"$t ",@c}

Non-golfé:

# Read the input into an array of lines.
my @lines = <>;
# For every 6-bit number:
for my $i (0 .. 63) {
    # Select the elements of the list that correspond to 1-bits in $i
    my @indices = grep { $i & (1 << $_) } 0 .. 5;
    my @characters = ('C', 'J', 'M', 'P', 'R', 'S')[@indices];

    # Build a regex that matches a string that contains all of @characters
    # in order... unless @characters is empty, then build a regex that matches
    # end-of-line.
    my $regex = @characters
      ? join ".*", ("", @c)
      : '$';

    my $time = 0;
    # For each line in the input...
    for my $line (@lines) {
        # If it contains the requisite characters...
        if ($line =~ /(.*) $regex/) {
            # Add to the time total
            $time += $1;
        }
    }

    # And print the subset and the total time.
    say "$time ", @characters;
}

K, 95

{(+/'{x[1]@&min'y in/:*x}[|"I \n"0:x]'b)!b:" ",?,/{x{,/y{x,/:y@&y>max x}\:x}[d]/d:"CJMPRS"}

Prend une chaîne comme "504 CRS\n200 J\n345 MP\n980 \n2000 CJMPRS"

k){(+/'{x[1]@&min'y in/:*x}[|"I \n"0:x]'b)!b:" ",?,/{x{,/y{x,/:y@&y>max x}\:x}[d]/d:"CJMPRS"}["504 CRS\n200 J\n345 MP\n980  \n2000 CJMPRS"]
980 | " "
2504| "C"
2200| "J"
2345| "M"
2345| "P"
2504| "R"
2504| "S"
2000| "CJ"
2000| "CM"
2000| "CP"
2504| "CR"
2504| "CS"
2000| "JM"
2000| "JP"
2000| "JR"
2000| "JS"
2345| "MP"
2000| "MR"
2000| "MS"
2000| "PR"
2000| "PS"
2504| "RS"
2000| "CJM"
2000| "CJP"
2000| "CJR"
2000| "CJS"
2000| "CMP"
2000| "CMR"
2000| "CMS"
2000| "CPR"
2000| "CPS"
2504| "CRS"
2000| "JMP"
2000| "JMR"
2000| "JMS"
2000| "JPR"
2000| "JPS"
2000| "JRS"
2000| "MPR"
2000| "MPS"
2000| "MRS"
2000| "PRS"
2000| "CJMP"
2000| "CJMR"
2000| "CJMS"
2000| "CJPR"
2000| "CJPS"
2000| "CJRS"
2000| "CMPR"
2000| "CMPS"
2000| "CMRS"
2000| "CPRS"
2000| "JMPR"
2000| "JMPS"
2000| "JMRS"
2000| "JPRS"
2000| "MPRS"
2000| "CJMPR"
2000| "CJMPS"
2000| "CJMRS"
2000| "CJPRS"
2000| "CMPRS"
2000| "JMPRS"
2000| "CJMPRS"