Die sechs Haupt Besetzung der amerikanischen Sitcom Freunde alle einig , dass sie das gleiche Gehalt gezahlt würde während des gesamten Laufs der Reihe (nach Saison 2, zumindest). Das bedeutet aber nicht, dass sie alle die gleiche Sendezeit hatten oder dass sie alle auf dem Bildschirm die gleiche Menge miteinander interagierten.

In dieser Herausforderung schreibst du ein Programm, mit dem du herausfinden kannst, welche Friends- Freunde wirklich die besten waren.

Installieren

Betrachten Sie eine Episode oder Szene von Freunden und notieren Sie sich genau, wer bei jeder Kameraaufnahme wie lange auf dem Bildschirm ist.

Wir werden den Namen jedes Charakters abkürzen:

• Cist für Chandler
• Jist für Joey
• Mist für Monica
• Pist für Phoebe
• Rist für Rachel
• Sist für Ross

Dann listen wir für jede Kameraaufnahme (oder jedes Mal, wenn ein Charakter die Aufnahme betritt / verlässt) auf, wer auf dem Bildschirm war. Beispielsweise:

504 CRS
200 J
345 MP
980
2000 CJMPRS

Dies besagt, dass:

• 504 ms lang waren Chandler, Rachel und Ross auf dem Bildschirm.
• Dann war Joey für 200ms.
• Dann für 345ms waren Monica und Phoebe.
• Dann war für 980 ms keine der 6 Hauptfiguren auf dem Bildschirm.
• Dann waren es für 2 Sekunden alle.

^{(Dies ist nicht aus einem tatsächlichen Clip, ich habe es erfunden.)}

Beachten Sie, dass Folgendes gleichwertig wäre:

504 CRS
1 J
199 J
345 MP
980
2000 CJMPRS

Um zu analysieren, welche Kombinationen von Zeichen die meiste Bildschirmzeit hatten, betrachten wir alle 64 möglichen Teilmengen der 6 Zeichen und addieren die Bildschirmzeit, die sie hatten. Wenn während einer Kameraaufnahme alle Personen in einer Untergruppe auf dem Bildschirm angezeigt werden , wird die Zeit für diese Kameraaufnahme zur Gesamtbildschirmzeit dieser Untergruppe addiert , auch wenn mehr Zeichen als nur die in der Untergruppe enthaltenen vorhanden sind.

Es gibt eine Ausnahme für die leere Untermenge - nur die Szenen ohne die 6 Hauptfiguren werden gezählt.

Die Analyse des obigen Beispiels wäre also:

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

Wir können sehen, dass J(nur Joey) 2200 ms Bildschirmzeit hatte, weil er 200 für sich und 2000 für alle hatte.

Herausforderung

Schreiben Sie ein Programm, das eine Zeichenfolge oder eine Textdatei wie z

504 CRS
200 J
345 MP
980
2000 CJMPRS

Dabei hat jede Zeile das Formular [time in ms] [characters on screen]und gibt die Gesamtzeit aus, die jede der 64 Teilmengen der 6 Zeichen auf dem Bildschirm verbracht hat, wobei jede Zeile das Formular hat [total time in ms for subset] [characters in subset](genau wie oben).

Die Eingabe kann als Zeichenfolge für stdin, die Befehlszeile oder eine Funktion verwendet werden oder als Name einer Textdatei, die die Daten enthält.

• Die Millisekundenzahlen sind immer positive ganze Zahlen.
• Die Buchstaben werden immer in der Reihenfolge CJMPRS(alphabetisch) angezeigt.
• Sie können optional davon ausgehen, dass ein Leerzeichen nachgestellt ist, wenn die Szene keine Zeichen enthält (z 980 . B. ).
• Optional können Sie davon ausgehen, dass eine nachgestellte Zeile vorhanden ist.
• Der Eingang hat mindestens 1 Zeile und kann beliebig viele haben.

Die Ausgabe sollte gedruckt oder als 64-zeilige Zeichenfolge zurückgegeben oder in eine andere Textdatei geschrieben werden.

• Die Zeilen können in beliebiger Reihenfolge sein.
• Die Buchstaben müssen nicht in der CJMPRSReihenfolge sein.
• Subsets mit 0 ms Gesamtzeit tun müssen aufgeführt werden.
• Optional kann nach der leeren Gesamtsumme der Teilmenge ein Leerzeichen stehen.
• Optional kann eine nachgestellte Zeile eingefügt werden.

(Dieses Problem kann natürlich auf mehrere Zeichen verallgemeinert werden, aber wir bleiben bei den 6 CJMPRS Friends- Zeichen.)

Der kürzeste Code in Bytes gewinnt.

^{Beachte, dass ich eigentlich Freunde mag und nicht denke, dass einige Charaktere wichtiger sind als die anderen. Die Statistik wäre allerdings interessant. ;)}

Pyth, 37 Bytes

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

Probieren Sie es online aus: Demonstration

Erläuterung:

  "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 Bytes

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]

fist eine Funktion, die die Eingabe als einzelne mehrzeilige Zeichenfolge verwendet und die mehrzeilige Ausgabe als einzelne Zeichenfolge zurückgibt. Wahrscheinlich gibt es hier noch viel zu golfen.

λ: 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 Bytes

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

Dies wird voraussichtlich ausgeführt als:

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

Beachten Sie, dass Sie alle müssen möglicherweise ersetzen `zu "und jeder "zu , 'wenn Sie eine alte Version von SWI-Prolog haben.

Ich könnte mehr als 100 Bytes einsparen, wenn ich keinen String als Eingabe verwenden müsste.

Haskell, 150 136 Bytes

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"

Anwendungsbeispiel:

*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

Anderer Ansatz als die Antwort von @ MtnViewMark : Suchen Sie für alle Kombinationen cder Zeichen die Zeilen der Eingabezeichenfolge, in denen der Unterschied zu cund die Liste zu den Zeilen yleer sind ( beachten Sie den Sonderfall, in dem kein Zeichen auf dem Bildschirm angezeigt wird (z. B. 980) -> cdarf nicht leer sein oder c == y). Extrahiere die Zahl und die Summe.

CJam, 67 58 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Perl 5 (5.10+), 128 Bytes

2 Bytes pro Ausgabezeile. use feature "say"nicht in der Byteanzahl enthalten.

@_=<>;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}

Nicht golfen:

# 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"}

Nimmt eine Zeichenfolge wie "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"