这项挑战与翻转薄煎饼有关。

您可能听说过煎饼分类，将一叠煎饼按大小分类，方法是将锅铲插入堆栈中，然后将所有煎饼翻转到锅铲上方，直到煎饼在盘上从最小到最大被分类。煎饼烧焦的问题略有不同。现在，所有薄煎饼的一面都被烧过，一旦分类完成，每个薄煎饼的烧过的一面必须面对盘子。

例如，给定以下堆栈（左侧的煎饼大小。右侧0为糊状，右侧1为糊状）：

1 0
3 1
2 1

您可以翻转整个堆栈以获取20 30 11，翻转前两个31 21 11堆栈以获取10 20 30，然后再次翻转整个堆栈以获取，是一叠烧焦的煎饼。翻转3，翻转2，翻转3的移动顺序可以表示为3 2 3。

挑战

• 给定一组煎饼的大小（不一定是唯一的）和它们的方向，输出任何有效的烧饼分类顺序，即一系列翻转，导致从薄饼到烧饼的面朝下从最小到最大的顺序排列。
• 输入和输出可以是任何带有分隔符的理智的格式，但是请指定要使用的格式，并指出输入格式的哪一端是堆栈的顶部（TOS）。
• 允许翻转零煎饼。
• 允许在输入/输出中混合分隔符。

测试用例

对于以下所有测试用例，输入是一个列表，输出是一个用空格分隔的字符串，TOS在左侧。

[[1, 0], [3, 1], [2, 1]]
"3 2 3"

[[5, 1], [3, 0], [4, 1], [2, 1], [1, 0]]
"5 3 4 1 3 2 1"

[[5, 1], [3, 0], [3, 0], [1, 1]]
"4 3 2 3"

与往常一样，如果有任何不清楚或不正确的地方，请在评论中告知我。祝你好运，打高尔夫球！

Python 2，83

输入应该是（大小，方向）元组的列表，且堆栈的顶部位于末尾。输出是要翻转的大小列表，这些大小被各种空白隔开。

a=input()
while a:i=a.index(max(a));print len(a)-i,a[i][1],len(a),i;a=a[i+1:]+a[:i]

CJam（37字节）

q~{__$W>#)_p/(W%\M*2,f.^+(1=p_,)pW%}h

输入是stdin上CJam格式的数组；输出是标准输出上以换行符分隔的新行列表。堆栈的顶部在索引处0；0表示燃烧面朝上，1表示燃烧面朝下。

在线演示

解剖

输出总是3n翻转长，这n是薄煎饼的数量。首先，我们将剩下的最大的煎饼翻到顶部。然后，如果它的面朝下燃烧，我们将那个薄煎饼翻转过来；然后将其翻转至底部，然后重复进行，好像一叠煎饼要短一堆。

q~         e# Parse input into array
{          e# Loop...
  __$W>#)  e#   Find 1-based index of largest element in array
  _p       e#   Dup and print
  /(       e#   Split into chunks that long, and pull off the first
  W%       e#   Reverse the first chunk. Note that we don't flip the burnt/unburnt bit
  \M*      e#   Merge the remaining chunks into a single array
  2,f.^    e#   Flip *their* burnt/unburnt bits
  +        e#   Concatenate, prepending the first chunk
  (1=p     e#   Pull off the first (largest) element and print its burnt/unburnt bit
  _,)p     e#   Print the number of remaining elements plus 1 (to account for the largest)
  W%       e#   Reverse. Note that the first chunk has now been flipped twice, which is
           e#   why we have left its burnt/unburnt bit alone
}h         e# ... until we get down to an empty array

Ruby，101 95 93字节

不是很高尔夫，我只是想做一个波哥大的变种。这是一个匿名函数，它接受一个数组数组，并将随机翻转显示到stdout，直到煎饼被排序为止。

->a{(p r=-~rand(a.size)
a[0,r]=a[0,r].reverse.map{|x,b|[x,1-b]})while a!=a.sort||a.rassoc(1)}

例如，您可以将其分配给f并说f.call [[1, 0], [3, 1], [2, 1]]

@Jordan的-5个rassoc
字节与@ Sherlock9 的-2个字节的出色用法