哪些“朋友”角色确实是最好的朋友？

30

美国情景喜剧之友的六个主要演员均同意，在整个系列的整个过程中（至少在第二季之后），他们将获得相同的薪水。但这并不意味着他们都具有相同的播放时间，也不意味着它们在屏幕上彼此交互的时间相同。

在这个挑战中，您将编写一个程序来帮助确定哪些Friends朋友确实是最好的。

设定

考虑观看“ 朋友”的情节或场景，并准确记录每次相机拍摄期间谁在屏幕上显示多长时间。

我们将缩写每个字符的名称：

然后，对于每个相机镜头（或角色每次进入/退出镜头），我们都会列出屏幕上的人物。例如：

504 CRS
200 J
345 MP
980
2000 CJMPRS

这就是说：

  • 在504毫秒内，钱德勒，雷切尔和罗斯出现在屏幕上。
  • 然后持续200毫秒，乔伊就呆了。
  • 然后持续345毫秒，莫妮卡和菲比都在。
  • 然后持续980毫秒，屏幕上没有显示6个主要角色。
  • 然后两秒钟，所有的人都。

（这不是来自实际剪辑，而是由我组成的。）

请注意，以下内容是等效的：

504 CRS
1 J
199 J
345 MP
980
2000 CJMPRS

为了分析哪些字符组合具有最大的屏幕显示时间，我们查看了6个字符的所有64个可能子集，并总计了它们的屏幕显示时间。如果在拍摄镜头期间某个子集中的每个人都出现在屏幕上，即使其中的字符比该子集中的人物更多，该镜头拍摄的时间也会添加到该子集的总屏幕时间中。

空子集有一个例外-仅计算不包含6个主要角色的场景。

因此，以上示例的分析将是：

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

我们可以看到J（仅Joey）有2200ms的屏幕显示时间，因为他自己有200个屏幕，每个人都有2000个屏幕时间。

挑战

编写一个包含字符串或文本文件的程序，例如

504 CRS
200 J
345 MP
980
2000 CJMPRS

其中每行的格式为[time in ms] [characters on screen]，并输出屏幕上6个字符的64个子集中的每个子集在屏幕上所花费的总时间，其中每行的格式为[total time in ms for subset] [characters in subset]（如上所述）。

输入可以作为标准输入，命令行或函数的字符串，也可以是包含数据的文本文件的名称。

  • 毫秒数将始终为正整数。
  • 字符字母将始终CJMPRS按字母顺序排列。
  • 您可以选择假设场景中没有字符时存在尾随空格（例如980 ）。
  • 您可以选择假定尾随换行符。
  • 输入将至少有1行，并且可能有许多行。

输出应作为64行字符串打印或返回或写入另一个文本文件。

  • 这些行可以以任何顺序排列。
  • 字符字母不必按CJMPRS顺序排列。
  • 确实需要列出总时间为0毫秒的子集。
  • 在空子集总数之后可以有一个尾随空格。
  • 可能会有尾随换行符。

（这个问题当然可以推广到更多的字符，但是我们将继续使用6个CJMPRS Friends字符。）

以字节为单位的最短代码获胜。

请注意，我实际上很喜欢Friends，并不认为某些角色比其他角色更重要。统计数据将是有趣的。;）

code-golf  arithmetic  combinatorics 
— 卡尔文的爱好
source
7
如果发布系列分析结果，我们是否会得到赏金？;）
— Beta Decay 2015年
5
我可能看过几十集，也可能没有看过每一集，并拥有全部10个季节...
— Alex A.15年
@AlexA。我可能知道您在说什么...
— bolov
空集是一种特殊情况-它不遵循“即使字符数大于子集中的字符数”规则，否则在示例中得分为4029（总时间至少为0）一个是在屏幕上），而不是980
— 霍布斯
1
@BetaDecay实际上，很可能！
— 加尔文的爱好

Answers:

10

Pyth，37个字节

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

在线尝试：演示

说明：

  "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
— 雅库比
source
这是很难甚至值得尝试当我写我的解决方案的一个行，它比整个Pyth答案:-P已经不再
— 霍布斯
4
@hobbs这是混合语言竞赛的缺点。但是不要害怕，其他语言的解决方案通常会获得更多的选票。只需看一下Haskell解决方案即可。
— 2015年
3
缩短了36％，使我意识到我的代码中有一个错误……
— Dennis
不幸的是，cM使用了.*地图扩展功能。也许应该做一个例外，c因为我无法想象有人想要在地图上那样使用它
— FryAmTheEggman 2015年
这对在示例输出，而不是980的顶部行给出0
— 加尔文的爱好
13

Haskell，187个字节

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]

f是将输入作为单个多行字符串，然后将多行输出作为单个字符串返回的函数。这里可能剩下很多高尔夫球场。

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

SWI-Prolog，381字节

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

预期将以以下方式运行：

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

请注意，您可能需要替换每个`to "和每个"to'如果你有一个旧版本SWI-的Prolog。

如果不必使用String作为输入，我可以节省100多个字节。

— 致命
source
7

Haskell中，150个 136字节

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"

用法示例：

*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

与@MtnViewMark答案不同的方法：对于c字符的所有组合，请找到输入字符串的行，其中的区别c和与行的列表y为空（请注意屏幕上没有字符的特殊情况（例如980）-> c不能为空或c == y）。提取数字和总和。

— 妮米
source
2

Perl 5（5.10 +），128个字节

每行输出2个字节。use feature "say"不包括在字节数中。

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

未打高尔夫球：

# 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;
}
— 霍布斯
source
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"}

像这样的字符串 "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"
— 马丁
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.