说到吃糖果，我比一般的外行人坚持更高的标准。在“混合使用”与“保存最佳结果到最后”之间存在微妙的平衡。

在此挑战中，您将获得一个字符串，其中每个字符代表一块糖果。不同的字符（区分大小写）代表不同类型的糖果。然后，您的程序必须根据以下步骤确定正确的糖果消费顺序。您可以编写一个完整的程序（STDIN / STDOUT）或一个命名函数来完成此任务。

假设我的糖果藏起来了oroybgrbbyrorypoprr。首先，我使用较低的ASCII字符值作为平局，将糖果分成相同类型的堆，顶部数量较大。

rrrrrr
oooo
bbb
yyy
pp
g

然后，我拿走每一排糖果，并按一定间隔将它们等距放置。例如，如果有3块糖果，则将1个放置在方式的1/3处，将2/3的方式放置在末尾。

.r.r.r.r.r.r
..o..o..o..o
...b...b...b
...y...y...y
.....p.....p
...........g

然后，我逐列向下创建最终的糖果订单rorbyroprbyorrobypg。

输入值

包含糖果存放区的字符串。上面示例的输入可能是：

oroybgrbbyrorypoprr

输出量

包含糖果的细绳重新组织成正确的食用顺序。

rorbyroprbyorrobypg

计分

这是代码高尔夫。以字节为单位的最短答案将获胜。适用标准代码高尔夫球规则。

CJam，78 68 61 45 42 39 31 30字节

l$:L{L\/,~}${:DM+:MD/,LD/,d/}$

通过STDIN获取输入字符串

受到递归方法的启发，但有所不同。根本不需要移调或矩形！

怎么运行的：

l$:L                              "Sort the input line and store it in L";
    {     }$                      "Sort the string based on this code block output";
     L\/,~                        "Sort based on number of occurrences of each";
                                  "character in the full string";
            {               }$    "Sort the sorted string again";
             :DM+:M               "Store each character in D, add to M and update M";
                   D/,            "Count occurrences of D in M";
                      LD/,        "Count occurrences of D in L";
                          d/      "Sort string based on the ratio of two occurrences";

（可悲的是，由于语法过于膨胀，CJam无法再用Pyth完成）

在这里尝试

珀斯 25

shCoc/NhN/zhNm>o_/zZSzdUz

受此答案启发，使用了全新的算法。

(implicit)          z = input()
(implicit)          print
s                   combine list of strings into one string
 h                  first list in
  C                 matrix transpose of (e.g. first characters in first list, etc.)
   o                order_by(lambda N:
    c                        float_div(
     /NhN                              N.count(N[0]),
     /zhN                              z.count(N[0])),
    m                        map(lambda d:
     >                           slice_head(
      o                                     order_by(lambda Z:
       _/zZ                                          -1*z.count(Z),
       Sz                                            sorted(z)),
      d                                     d),
     Uz                          range(len(z))

一步步：

1. 首先，我们按字符的共性对字符进行排序，并按字母顺序打断领带。这是o_/zZSz。o与Python的相同sorted(<stuff>,key=<stuff>)，但键将使用lambda表达式，但将其保留为字符串。

2. 然后，我们生成该字符串的前缀列表，从长度len(z)到长度1。>等效于python的<stuff>[<int>:]。

3. 然后，我们按问题中看到的矩形布局上前缀的第一个字符的分数位置对前缀字符串列表进行重排序，0为左边缘，而1为右。/NhN计算前缀中的第一个字符出现在前缀中/zhN的次数，同时给出字符串中前缀中的第一个字符出现的次数（孔）。这会为组中每个字符所引导的每个前缀分配不同的分数，从1/k该字符出现的最右边到最k/k左边。通过此数字重新排序前缀列表将在布局中提供适当的位置。使用先前的顺序打破关系，根据需要先按顺序，然后按字母顺序。

4. 最后，我们需要从每个前缀字符串中提取第一个字符，将它们组合为一个字符串，然后将其打印出来。提取第一个字符为hC。C实际上zip(*x)在Python 3中对列表执行矩阵转置。h提取结果矩阵的第一行。实际上，这是唯一的行，因为1字符前缀的存在会阻止形成任何其他完整的行。s将这个元组中的字符加到一个字符串中。打印是隐式的。

测试：

$ pyth -c 'shCoc/NhN/zhNm>o_/zZSzdUz' <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg

增量程序片段oroybgrbbyrorypoprr：

Sub-Piece                  Output

Sz                         bbbgoooopprrrrrryyy
o_/zNSz                    rrrrrroooobbbyyyppg      (uses N because o uses N on first use.)
m>o_/zNSzdUz               ['rrrrrroooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrroooobbbyyyppg', 'rrroooobbbyyyppg', 'rroooobbbyyyppg', 'roooobbbyyyppg', 'oooobbbyyyppg', 'ooobbbyyyppg', 'oobbbyyyppg', 'obbbyyyppg', 'bbbyyyppg', 'bbyyyppg', 'byyyppg', 'yyyppg', 'yyppg', 'yppg', 'ppg', 'pg', 'g']
oc/NhN/zhNm>o_/zZSzdUz     ['roooobbbyyyppg', 'obbbyyyppg', 'rroooobbbyyyppg', 'byyyppg', 'yppg', 'rrroooobbbyyyppg', 'oobbbyyyppg', 'pg', 'rrrroooobbbyyyppg', 'bbyyyppg', 'yyppg', 'ooobbbyyyppg', 'rrrrroooobbbyyyppg', 'rrrrrroooobbbyyyppg', 'oooobbbyyyppg', 'bbbyyyppg', 'yyyppg', 'ppg', 'g']
Coc/NhN/zhNm>o_/zZSzdUz    [('r', 'o', 'r', 'b', 'y', 'r', 'o', 'p', 'r', 'b', 'y', 'o', 'r', 'r', 'o', 'b', 'y', 'p', 'g')]
shCoc/NhN/zhNm>o_/zZSzdUz  rorbyroprbyorrobypg

旧答案：

珀斯，34岁

ssCm*+t*u*G/zHS{-zd1]kd/zdo_/zNS{z

该程序通过计算复制某个子列表多少次来工作。子列表如下所示['', '', '', '', ... , 'r']。该子列表的总长度是所有其他糖果的出现次数的乘积，即u*G/zHS{-zd1。完整的子列表是通过]k多次复制空字符串的列表来构造的，然后使用删除和元素，然后将t糖果名称添加到末尾+d。

然后，该子列表被复制的次数与在输入中找到糖果的次数相同，从而/zd确保每个糖果列表的长度相等。

现在，通过将此函数以正确的排序顺序（o_/zNS{z）映射到所有唯一糖果上，我们有一个类似于问题语句中的矩形的矩形，但其中包含空字符串而不是句点。进行矩阵转置（C），然后进行两个求和（ss），即可得到最终的字符串。

验证：

$ pyth programs/candy.pyth <<< 'oroybgrbbyrorypoprr'
rorbyroprbyorrobypg

Perl 5-62

61个代码+ 1个标志。

#!perl -n
print map/(.$)/,sort map/(.$)/*$_/$$1.~$_.$1,map++$$_.$_,/./g

首先将输入分成字符数组- /./g。

将出现索引添加到每个字母，然后将计数保留在变量$a.. $z中map++$$_.$_。现在，数组为：

1o
1r
2o
1y
1b
1g
2r
2b
3b
2y
3r
3o
4r
3y
1p
4o
2p
5r
6r

然后将其转换为连接的排序键：比率$_/$$1，计数平局~$_和ASCII值平局$_。这将导致（为清楚起见，此处添加了空格）。

0.25 18446744073709551614 o
0.166666666666667 18446744073709551614 r
0.5 18446744073709551613 o
0.333333333333333 18446744073709551614 y
0.333333333333333 18446744073709551614 b
1 18446744073709551614 g
0.333333333333333 18446744073709551613 r
0.666666666666667 18446744073709551613 b
1 18446744073709551612 b
0.666666666666667 18446744073709551613 y
0.5 18446744073709551612 r
0.75 18446744073709551612 o
0.666666666666667 18446744073709551611 r
1 18446744073709551612 y
0.5 18446744073709551614 p
1 18446744073709551611 o
1 18446744073709551613 p
0.833333333333333 18446744073709551610 r
1 18446744073709551609 r

可以按字典顺序（默认）排序。最后提取最后一个字符并打印：print map/(.$)/

Python 3.x-124字节

C=input()
print("".join(s[1]for s in sorted(enumerate(C),key=lambda
t:((C[:t[0]].count(t[1])+1+1e-10)/C.count(t[1]),t[1]))))

数学，123个 119 118字节

f=FromCharacterCode[s=SortBy;#&@@@s[Join@@(s[Tally@ToCharacterCode@#,-Last@#&]/.{x_,n_}:>({x,#/n}&~Array~n)),{Last}]]&

定义一个命名函数f。取消高尔夫：

f = FromCharacterCode[
   s = SortBy;
   # & @@@ s[
     Join @@ (
       s[
         Tally@ToCharacterCode@#,
         -Last@# &
         ] /. {x_, n_} :> ({x, #/n} &~Array~n)
       ),
     {Last}
     ]
   ] &

为此，使用内置的有理类型似乎是个好主意。当然，这离CJam不远。基本上，我将挑战中显示的网格表示为对列表。该对中的第一件事是字符代码，第二件事是它的位置，其分数小于或等于1（最后一列为1）。确保各个字符的顺序正确之后，我只需要按所述分数对它进行稳定排序即可获得所需的结果。

Pyth 45 47 48 51

这几乎也可以肯定进一步打下去；）

Ko_/zNS{zFGK~Y]*+*t/u*GHm/zdK1/zG]k]G/zG)ssCY

通过构建列表列表来工作，其中每个内部列表都是一排空字符串和糖果的名称。转换此列表，然后合并内部列表，然后再合并这些列表。

感谢@isaacg提醒我有关总和的信息！

APL：38

v⌷⍨⊂⍋⌽(n/-n),⍪∊+\¨n⍴¨÷n←{≢⍵}⌸v←{⍵[⍋⍵]}

说明：

v←{⍵[⍋⍵]}    orders input string
n←{≢⍵}⌸v     counts how many times each element appears in v
∊+\¨n⍴¨÷n     makes incremental sums in each letter "group" 
⍋⌽(n/-n),⍪   appends number of elements in letter group and orders the obtained matrix
v⌷⍨⊂         orders vector v with computed indices

可以在tryapl.org上进行测试

R-166个字符

library("plyr");s=function(a){l=table(strsplit(a,s="")[[1]]);l=ldply(l[order(-l,names(l))],function(n)data.frame(seq_len(n)/n));paste(l[order(l[[2]]),1],collapse="")}

非高尔夫版本

library("plyr")
s <- function(a) {
    tbl <- table(strsplit(a, split = "")[[1]])
    tbl <- tbl[order(-tbl, names(tbl))]
    tbl <- ldply(tbl, function(n) {data.frame(seq_len(n)/n)})
    paste(tbl[order(tbl[[2]]),1], collapse = "")
}

说明：

• 分成单个字符
• 列出每个字符的数量
• 将表按频率高低排序，然后按词汇顺序排序
• 用于选择1 / n，2 / n，3 / n，... n-1 / n，1的索引位置，其中n是糖果的数量
• 按索引对糖果名称进行排序（order排序稳定，因此在索引中并列时将保持最频繁/词汇的命名顺序，对于最后的糖果尤为重要）
• 将糖果名称连接在一起以形成输出字符串

问题的矩阵性质使我认为R可能对此有所了解，但是我能做的算法的最佳字面解释是211个字符：

l=function(a){l=table(strsplit(a,s="")[[1]]);l=l[order(-l,names(l))];o=Reduce(`*`,l);m=matrix("",nc=o,nr=length(l));for(r in seq_along(l)){x=l[r];for(c in seq_len(x)*o/x){m[r,c]<-names(x)}};paste(m,collapse="")}

松散：

l <- function(a) {
    tbl <- table(strsplit(a, split = "")[[1]])
    tbl <- tbl[order(-tbl, names(tbl))]
    o <- Reduce(`*`, tbl)
    m <- matrix("", ncol = o, nrow = length(tbl))
    for (r in seq_along(tbl)) {
        for (c in seq_len(tbl[r])*o/tbl[r]) {
            m[r,c] <- names(tbl[r])
        }
    }
    paste(m, collapse="")
}

Pyth，29个字节

这是我的CJam answe r在Pyth中的直接翻译

oc/|$Y.append(N)$YN/zNo_/zZSz

在这里在线尝试

这个解决方案背后有一个很长的故事，@ isaacg帮助我在理解这种新语言方面起到了很大的作用。

理想情况下，这是我的CJam代码（17个字节）的精确词对词翻译：

oc/~kNN/zNo_/zZSz

意思是：

o         order_by(lambda N:
 c                 div(
  /                    count(
   ~kN                       k+=N,                #Update k (initially ""), add N
   N                         N),                  #Count N in updated k
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))

但是遗憾的是，Python不会在+=调用中返回任何内容，因此那不是有效的Python代码，因此也是无效的Pyth代码，就像在Pyth中一样，lambda只能是return语句。

然后，我研究了各种方法，最后发现Python list.append返回了一个None可以使用的值。使代码成为（19个字节）：

oc/|aYNYN/zNo_/zZSz

意思是：

o         order_by(lambda N:
 c                 div(
  /                    count(
   |aYN                      (Y.append(N) or
    Y                         Y)                 #Update Y (initially []), append N
   N                         N),                 #Count N in updated Y
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))

但是可悲的是，a（append）的支持已从Pyth中删除，并且有支持的版本，没有对的支持o。

更新：a现在，Pyth已经增加了对支持的支持，因此上述19字节代码将在在线编译器中运行。但是，由于这是在OP之后添加的一项新功能，因此我没有将其作为评分，而是让29字节代码作为解决方案。

因此，在这种情况下，我不得不依靠原始Python，使代码成为

o         order_by(lambda N:
 c                 div(
  /                    count(
   |$Y.append(N)$            (Y.append(N) or
    Y                         Y)                 #Update Y (initially []), append N
   N                         N),                 #Count N in updated Y
  /zN                  count(z, N)),
 o                 order_by(lambda Z:
  _                         neg(
   /zZ                          count(z, Z)),
  Sz                        sorted(z)))