倒数

您应对此代码高尔夫挑战的目标是倒数，同时回收数量。让我解释。

首先，您的应用程序读取数字，可以作为程序参数或使用stdin。接下来，您只需倒计时像这样： 10 9 8 7 6（以降序排列）

但是，等等，还有更多！

回收利用

在某些情况下，我们可以打印每个数字，但不列出每个数字，我们可以进行回收！让我举一个简单的例子：

Input: 110

Output:   11091081071061051041031021010099... etc
Recycled:  10                        1

现在，我们仍然列出了所有数字110、109、108，但是我们回收了0和1。

另一个例子：

Input: 9900

Output:   9900989989897989698959894... etc
Recycled:        9 98  

高尔夫挑战赛

• 读取数字（参数或标准输入）
• 以倒序输出倒计时，同时回收所有可能的数字（到标准输出或文件）
• 达到1或回收0到9的那一刻（无论先发生什么），请停止

一个简单的例子（直到达到1）：

Input: 15
Output: 15141312110987654321

(Notice the 110 instead of 1110)

更高级的示例（全部回收）：

Input: 110
Output:   110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221
Recycled:  10                            9                    8                    7                    6                    5                    4                    3                    2

(We've recycled all 0-9)

T-SQL - 291 277 267 217 199 191 166 158 153 145 142 128 117

在以一种新的方式处理这个问题之后，我设法降到了145（经过几次小的调整后达到了142），而不是太破旧。这意味着我可能能够争夺银牌或铜牌。^^

DECLARE @ INT=100;WITH N AS(SELECT 1A UNION ALL SELECT A+1FROM N WHERE A<@)SELECT LEFT(A,LEN(A)-1+A%11)FROM N ORDER BY-A

这不会打印列表，而是选择结果。这个问题从未详细说明输出，因此应该没问题。输入仍然具有100的相同限制，部分是因为我滥用了一个事实，即100以下的第11个术语都会丢失一个字符，部分是由于公用表表达式的默认100递归限制。

DECLARE @ INT=100;

WITH N AS
(
    SELECT 1A
    UNION ALL
    SELECT A+1
    FROM N
    WHERE A<@
)

SELECT LEFT(A,LEN(A)-1+A%11)
FROM N
ORDER BY-A

Python 143147

def t(n):
 p=o='';r=0 # p is previous string, o is output string, r is recycled bitmap
 while n and r<1023: # 1023 is first 10 bits set, meaning all digits have been recycled
    s=`n`;i=-1 # s is the current string representation of n
       # i is from end; negative offsets count backwards in strings
    while p.endswith(s[:i])-1:i-=1 # find common ending with prev; s[:0] is '',
       # which all strings end with
    for j in s[:i]:r|=1<<int(j) # mark off recycled bits
    o+=s[i:];p=s;n-=1 # concatenate output, prepare for next number
 print o # done

第一级缩进是空格，第二级是制表符。

Haskell中，154 149 147 145 128 120 119 117字节

import Data.List
(r%x)n|n>0&&r<":"=[(r\\t)%(x++(show n\\t))$n-1|t<-tails x,isPrefixOf t$show n]!!0|0<1=x
h=['0'..]%""

增加了回收检查的成本，很多字符...

记得尚未回收哪些数字，并在列表为空时停止播放，从而打了一下球。然后转向显式递归和其他一些技巧，从而打更多的高尔夫球。

示例输出：

*Main> h 110
"110910810710610510410310210100998979695949392919089887868584838281807978776757473727170696867665646362616059585756554535251504948474645443424140393837363534332313029282726252423221"

Python 2：119 117

将其标记为社区Wiki，因为它只是Will's answer的一个更高版本。

n=input()
d=s,={''}
exec"t=`n`;i=len(t)\nwhile(s*i)[-i:]!=t[:i]:i-=1\ns+=t[i:];d|=set(t[:i]);n-=len(d)<11;"*n
print s

红宝石，145个 139 130字节

n=gets.to_i
d=*?0..?9
s=''
n.times{|i|j=(t=(n-i).to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d}

与Will的方法类似，除了我不使用位掩码，而是使用未使用的数字组成的类似集合的数组。通过STDIN输入。

有一个替代版本，使用while代替，times但是无论我尝试什么，字节数都是相同的：

n=gets.to_i
d=*?0..?9
s=''
(j=(t=n.to_s).size;j-=1 while s[-j,j]!=u=t[0,j];d-=u.chars;s=t;$><<t[j..-1];exit if[]==d;n-=1)while 0<n

CJam，80 77 65 57 54个字符

大概根本没有优化，但是经过大量的优化和调试之后，我的C6am中的ES6答案直接转换为：

Mr{s:C_,{:H<M_,H->=!_CH@-@}g:T>+:MCT<_O@-+:O,A<Ci(*}h;

在这里在线尝试。该函数将数字作为STDIN并输出循环倒计时，如果循环完成，则在倒计时之间停止。

我将尝试进一步打高尔夫球。

怎么运行的：

基本思想是，对于每个倒数C，请检查前H个数字是否等于结果字符串的后H个数字，其中H从C中的数字变为0

Mr                                    "Put an empty string and input on stack";
  { ... }h;                           "Run while top element of stack is true, pop when done";
s:C                                   "Store string value of top stack element in C"
   _,                                 "Put the number of characters in C to stack";
     { ... }g                         "Run while top element of stack is true";
:H<                                   "Store the digit iteration in H and slice C";
   M                                  "M is the final output string in making";
    _,H-                              "Take length of M and reduce H from it";
        >                             "Take that many digits of M from end and..."
         =!_                          "Compare with first H digits of C, negate and copy";
            CH@                       "Put C and H on stack and bring the above result to top of stack";
               -                      "Reduce H if the matched result was false";
                @                     "Bring the matched result on top in order continue or break the loop"
             :T                       "Store top stack element in T after the loop";
               >+:M                   "Take everything but first T digits of C and add it to M and update M";
                   CT<_               "Take first T digits of C and copy them";
                       O@             "Put saved digits on stack, and rotate top three elements";
                         -            "Remove all occurence of first T digits of C from O";
                          +:O         "Add first T digits of C to O and update O";
                             ,A<      "Compare number of saved digits with 10";
                                Ci(   "Decrement integer value of C and put it on stack";
                                   *  "If number of saved digits greater than 9, break loop";

JavaScript的ES6，149 146个字符

这么冗长，很多字符，哇。

C=n=>{s=c='';while(n>0&s.length<10){j=1;while(t=(n+'').slice(0,-j++))if(c.endsWith(t)){s+=~s.search(t)?'':t;break}c+=(n--+'').slice(1-j)}return c}

在最新的Firefox的Web控制台中运行它。

运行后，它会创建一个方法C，您可以像

C(12)
12110987654321

更新：有时，普通旧代码return比箭头函数闭包短:)