从AZSPCS：

假设您有一个包含n张牌的卡组。每张卡包含一个从1到n的数字，并且每个数字恰好出现在一张卡上。您查看顶部卡上的数字-假设它是k-然后颠倒顶部k卡的顺序。您可以继续执行此过程-读取最高卡号，然后反转相应的卡数-直到最高卡为1。

编写最快的程序以计算给定卡座的冲销数量。请注意，如果您参加比赛，则不允许发布代码（因此，我不会发布代码）。

的JavaScript

function(d){for(t=0;x=(n=d[0])-1;t++)for(i=0;i<n/2;i++){m=d[x-i];d[x-i]=d[i];d[i]=m}return t}

您将其通过甲板，如下所示：

f([3, 2, 1]) // 1
f([2, 3, 1]) // 2
f([1, 2, 3]) // 0

Scala ：（这不是高尔夫-是吗？）

def transform (l: List[Int], sofar: Int = 0) : Int =
  if (l(0) == 1) sofar else transform (l.take (l(0)).reverse ::: l.drop (l(0)), sofar + 1)

带有测试用例和秒表的完整应用程序，包括甲板的改组：

object DeckReverse extends Application {

  def transform (l: List[Int], sofar: Int = 0) : Int = 
    if (l(0) == 1) sofar else transform (l.take (l(0)).reverse ::: l.drop (l(0)), sofar + 1)

  def stopwatch (count: Int, size: Int) = {
    val li = (1 until size).toList 
    val r = util.Random 

    val start = System.currentTimeMillis ()
    (0 until count).foreach (_ => transform (r.shuffle (li)))
    val stop = System.currentTimeMillis ()

    println ("count: " + count + "\tsize: " + size + "\tduration: " + (stop - start) + " msecs") 
  }

  stopwatch (1000, 100)
}

数：1000大小：100持续时间：1614毫秒机器：单奔腾M 2Ghz

Python，84个字符

无论如何打高尔夫球...我使用的数字是0到n-1。假设数组存储在变量x中，则需要我84个字符的Python。

while x[0]:x[:x[0]+1]=x[x[0]::-1]

但是，由于内存滥用，性能非常差。

C

int revno(int* deck, int n) {
  int k,j,r=0;
  for(;;) {
    k=*deck;
    if (k==1) {
      return r;
    }
    for (j=0; j<k/2; j++) {
      int tmp=deck[j];
      deck[j]=deck[k-j];
      deck[k-j]=tmp;
    }
    r++;
  }
}

deck是指向代表卡片组的整数数组的指针。n是卡的数量。显然，内存安全是调用者的任务。

它可能接近最近的计算机和高级语言上最快的算法。只有使用asm级别的技巧，它才能变得更快，但即使使用它们也不能使它更快。

Perl 5、58 + 2（-ap）= 60字节

++$\&&(@F[0..$F[0]-1]=reverse@F[0..$F[0]-1])while$F[0]-1}{

在线尝试！