¿Qué personajes de Friends eran realmente los mejores amigos?

30

Los seis principales miembros del reparto de la American comedia Amigos todos estuvieron de acuerdo en que se les pagaría el mismo sueldo a través del funcionamiento de la serie (después de la temporada 2, por lo menos). Pero eso no significa que todos hayan tenido la misma cantidad de tiempo en el aire o que todos hayan interactuado en la pantalla la misma cantidad.

En este desafío, escribirás un programa que podría ayudar a determinar qué Amigos amigos eran realmente los mejores.

Preparar

Considere ver un episodio o escena de Friends y anote exactamente quién está en la pantalla durante cada captura de cámara y durante cuánto tiempo.

Abreviaremos el nombre de cada personaje:

Luego, por cada toma de la cámara (o cada vez que un personaje ingresa / sale de la toma), enumeraremos quién estaba en la pantalla. Por ejemplo:

504 CRS
200 J
345 MP
980
2000 CJMPRS

Esto está diciendo que:

  • Durante 504 ms, Chandler, Rachel y Ross estuvieron en la pantalla.
  • Luego, durante 200 ms, Joey fue.
  • Luego, durante 345 ms, Mónica y Phoebe fueron.
  • Luego, durante 980 ms, ninguno de los 6 personajes principales estaba en la pantalla.
  • Luego, durante 2 segundos, todos fueron.

(Esto no es de un clip real, lo inventé).

Tenga en cuenta que lo siguiente sería equivalente:

504 CRS
1 J
199 J
345 MP
980
2000 CJMPRS

Para analizar qué combinaciones de caracteres tuvieron el mayor tiempo de pantalla, observamos los 64 subconjuntos posibles de los 6 caracteres y sumamos el tiempo de pantalla que tenían. Si todos los integrantes de un subconjunto aparecen en la pantalla durante una captura de cámara, incluso si hay más caracteres que solo los del subconjunto , el tiempo para esa captura de cámara se agrega al tiempo de pantalla total de ese subconjunto.

Hay una excepción para el subconjunto vacío: solo se cuentan las escenas con ninguno de los 6 personajes principales.

Entonces el análisis del ejemplo anterior sería:

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

Podemos ver que J(solo Joey) tenía 2200 ms de tiempo en pantalla porque tenía 200 solo y 2000 con todos.

Reto

Escriba un programa que tome una cadena o un archivo de texto como

504 CRS
200 J
345 MP
980
2000 CJMPRS

donde cada línea tiene la forma [time in ms] [characters on screen], y genera la cantidad total de tiempo que cada uno de los 64 subconjuntos de los 6 caracteres pasaron en la pantalla, donde cada línea tiene la forma [total time in ms for subset] [characters in subset](tal como arriba).

La entrada puede tomarse como una cadena para stdin, la línea de comando o una función, o puede ser el nombre de un archivo de texto que contiene los datos.

  • Los números de milisegundos siempre serán enteros positivos.
  • Las letras de los caracteres siempre estarán en el orden CJMPRS(alfabético).
  • Opcionalmente, puede suponer que hay un espacio final cuando no hay caracteres en la escena (por ejemplo 980 ).
  • Opcionalmente, puede suponer que hay una nueva línea final.
  • La entrada tendrá al menos 1 línea y puede tener arbitrariamente muchas.

El resultado debe imprimirse o devolverse o escribirse en otro archivo de texto como una cadena de 64 líneas.

  • Las líneas pueden estar en cualquier orden.
  • Las letras de los caracteres no necesitan estar en el CJMPRSorden.
  • Subconjuntos con 0 ms tiempo total no ha de estar registrado.
  • Opcionalmente, puede haber un espacio final después del total del subconjunto vacío.
  • Opcionalmente, puede haber una nueva línea final.

(Por supuesto, este problema puede generalizarse a más personajes, pero nos quedaremos con los 6 personajes de CJMPRS Friends ).

El código más corto en bytes gana.

Tenga en cuenta que realmente disfruto de Friends y no creo que algunos personajes sean más importantes que otros. Sin embargo, las estadísticas serían interesantes. ;)

code-golf  arithmetic  combinatorics 
— Pasatiempos de Calvin
fuente
77
¿Obtendremos una recompensa si publicamos un análisis de la serie? ;)
— Beta Decay
55
Puedo o no haber visto cada episodio docenas de veces y ser dueño de las 10 temporadas ...
— Alex A.
@AlexA. Puedo o no saber de lo que estás hablando ...
— bolov
El conjunto vacío es un caso especial: no obedece la regla "incluso si hay más caracteres que solo los del subconjunto", o de lo contrario obtendría 4029 en el ejemplo (la cantidad total de tiempo que al menos no uno está en la pantalla), y no 980.
— hobbs
1
@BetaDecay ¡Muy posiblemente, en realidad!
— Calvin's Hobbies

Respuestas:

10

Pyth, 37 bytes

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

Pruébelo en línea: demostración

Explicación:

  "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
— Jakube
fuente
Casi no vale la pena intentarlo cuando escribo una línea de mi solución y ya es más larga que toda la respuesta de Pyth
— :-P
44
@hobbs Esa es la desventaja de las competiciones de idiomas mixtos. Pero no se deje intimidar, las soluciones en otros idiomas generalmente reciben más votos. Solo mire la solución Haskell.
— Jakube
3
36% más corto y me di cuenta de que tenía un error en mi código ...
— Dennis
Es bastante desafortunado que cMuse la .*expansión del mapa. Tal vez debería hacerse una excepción cya que no puedo imaginar a alguien que quiera usarlo así en un mapa
— FryAmTheEggman
Esto da 0 en la línea superior en la salida de ejemplo en lugar de 980.
— Calvin's Hobbies
13

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]

fes una función que toma la entrada, como una sola cadena de varias líneas, y devuelve la salida de varias líneas como una sola cadena. Probablemente queda mucho para jugar golf aquí.

λ: 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
— MtnViewMark
fuente
7

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

Esto espera ejecutarse como:

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

Tenga en cuenta que puede que tenga que reemplazar cada `a" y cada "to 'si tiene una versión anterior de SWI-Prolog.

Podría ahorrar más de 100 bytes si no tuviera que usar una cadena como entrada.

— Fatalizar
fuente
7

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"

Ejemplo de uso:

*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

Enfoque diferente a la respuesta de @ MtnViewMark : para todas las combinaciones cde los caracteres, encuentre las líneas de la cadena de entrada donde la diferencia cy la lista de las líneas yestá vacía (tenga en cuenta el caso especial donde no hay caracteres en la pantalla (por ejemplo 980) -> cno debe estar vacío o c == y). Extrae el número y la suma.

— nimi
fuente
2

Perl 5 (5.10+), 128 bytes

2 bytes por línea de salida. use feature "say"no incluido en el recuento de bytes.

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

Sin 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;
}
— hobbs
fuente
2

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

Toma una cuerda como "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"
— tmartin
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.