主要任务

您的任务是按从1开始的降序打印整数，并在您再次击中1时逐渐增大，直到达到给定的输入为止，然后打印其余部分，直到再次击中1。输入示例6：

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

输入项

您的代码可以采用整数或数字形式的任何形式的输入（图形，STDIN）。

输出量

您的代码应该输出上述序列，直到达到输入数字为止，然后完成输出直到再次达到1。输出可以是任何东西，因此可以是数字，字符串，整数或图形输出。必须打印出一个数字（如果是字符串，则不能换行）。您的输出可以输入和输出任意数量的字符（例如[]）。

由于存在一些误解，因此您可以尝试以下正则表达式模式。

^(\D*(\d)+\D*)$

规则

• 输出必须是一个完整的数字，不能被任何东西分割，甚至不能换行。
• 该算法不应检查以任何方式出现的N的第一个实例（例如21in 121321），而应检查N 的第一个实例作为实际数字。
• 允许使用一条尾随的换行符。
• 负输入的处理完全由您选择，负数不是您应该测试的情况。

测试用例

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

优胜者

获胜者已被选中！这是ErikGolfer的答案，令人印象深刻的5个字节！恭喜你！

果冻，5个字节

RRUVV

在线尝试！

公式不是我的。

我怀疑这里发生了太多事情...

[接受答复]我给了丹尼斯5名代表，但这不是名誉交易所。丹尼斯向我展示了这种VV行为。令我惊讶的是，它比05AB1E短。

05AB1E，6个字节

L€LíJJ

在线尝试！

说明

示例输入4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

JavaScript（ES6），37个字节

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

演示版

f=(n,k=1)=>k>n?n--?f(n):'':f(n,k+1)+k

console.log(f(6))

n <10、34个字节的替代方法（无竞争）

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

在JavaScript中，字符串是不可变的。因此，不可能s通过为分配新的值来更改字符串的第N个字符的内容s[N]。

但是，++s[N]即使字符串保持不变，该表达式也是有效的，并且计算结果与预期的一样。例如：

++"1"[0] // equals 2

通过扩展：

s = "21"
++s[0] + s // equals "321"

V，29 28 27 23 19 17 16字节

@DJMcMayhem节省了8个字节

@ nmjcman101节省了3个字节

"apÀ­ñÄòy$jpkgJ

隐藏字符：

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x 是Ctrl + x。

在线尝试！通过命令行参数接受输入

十六进制转储：

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

说明

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

现在看起来像：

1
2
...
n

继续...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF（已过时）

（对于arg 6）

C＃，72 69 65字节

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

如果仅可以返回输出而不是将其写入控制台

C＃，71 68 64字节

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

感谢@VisualMelon节省了大量字节

在此处进行测试（很遗憾，在线编译器会在420以上的任何数字处中断）

纯扑34

eval eval printf %s \\{{1..$1}..1}

大括号扩展的两个级别。通过输入6，第一级扩展到{1..1} {2..1} {3..1} {4..1} {5..1} {6..1}。然后将1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1其扩展为，然后将其与串在一起printf %s。 eval在扩展的两个级别上都需要s-对于第一个级别，以便首先$1扩展参数，对于第二个级别，则使其在第一级之后扩展。

在线尝试

Perl，21个字节

用途-E无需支付额外费用。

say map$}=$_.$},1..<>

用法

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

Pyth，7个字节

jks}R1S

接受整数输入并打印结果的程序。

在线尝试！

这个怎么运作

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

GeoGebra，67个字节

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

每行分别输入到输入栏中。输入来自输入框。

这是执行的gif：

这个怎么运作

输入1隐式分配a给1，InputBox命令将输入​​框与关联a。然后，对于每个iin {1, 2, 3, ..., a}，{i, i-1, i-2, ..., 1}使用Sequence命令创建列表，然后使用将该j列表中的每个转换为字符串Text。最后，Join合并所有列表，并将Sum所有元素连接到一个显示的文本对象上。

Python 2，51字节

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r

视网膜，26 22字节

字节数假定为ISO 8859-1编码。

.+
$*

$`¶
1
$.%'
0?¶

在线尝试！

说明

.+
$*

将输入转换为一元。

$`¶

在每个位置，插入前缀到该位置，以及换行符。这将创建一个一元范围2到n+1，每行一个值。

1
$.%'

将每行替换1为同一行后的字符数。这变成像11111东西43210。

0?¶

删除所有换行符和它们前面的零。

GameMaker语言，65个字节

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

APL，10个字节

∊⍕¨∘⌽∘⍳¨∘⍳

例如：

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

说明：

• ⍳：获取从1到N的数字。
• ⍳¨∘：对于其中的每个数字，请获取从1到N的数字。
• ⌽∘：反转该列表
• ⍕¨∘：获取每个项目的字符表示形式（因此它不会输出数字，中间没有空格）
• ∊：展平结果数组

Python 2，71 68字节

我敢打赌递归解决方案可能会更短一些，但是我很难将其公式化为一个。

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

在线尝试

实际上是8个字节

RR♂RΣRεj

第一次在“实际上”中发布答案，因此很可能会打高尔夫球。

这个怎么运作

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

在线尝试！

Brachylog，8个字节

yb@[rcw\

在线尝试！

说明

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

Perl 6、22字节

{[~] flat [\R,] 1..$_}

返回字符串的lambda。

（在线尝试。）

说明：

• 1..$_：整数范围... (1 2 3 4)
• [,] 1..$_：通过逗号运算符减少（“倍数”）... (1 2 3 4)
• [\,] 1..$_：中间结果（三角形缩小）...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_：将反向元运算符应用于逗号...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...：删除列表嵌套，并折叠字符串concat运算符... 1213214321

Haskell，35个字节

f x=[1..x]>>= \y->[y,y-1..1]>>=show

用法示例：f 6-> "121321432154321654321"。

对于所有数字x在1 ... x做一个清单x,x-1, ... ,1，把数字转换成字符串并连接成一个单一的字符串。同样，将这些字符串连接为单个字符串。

C89，54个字节

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54感谢ErikGolfer！

Python 3，87 92 83 74字节

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

使用递归的简短答案：

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

也许不是最短的一个，但它只能由Python的列表理解来完成！

（已编辑以添加打印功能并删除\ n）

（已编辑以删除打印功能，并将n + 1，k + 1更改为n，k + 2）

Pyth，8个字节

jks_M._S

说明

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string

05AB1E，6个字节

LR.sJJ

在线尝试！

Mathematica，36个字节

ToString/@(""<>Range[Range@#,1,-1])&

抛出一堆可以安全忽略的警告。

说明

以输入5为例：

Range@#

创建一个范围{1, 2, 3, 4, 5}。

Range[...,1,-1]

Range是可列出的，因此我们可以为它提供任何参数的列表，它将自动在该参数上传递。因此，这给了我们一系列反向列表：

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

下一个：

(""<>...)

这会将嵌套列表与空字符串连接在一起。由于嵌套列表实际上不包含任何字符串，因此它不能真正连接值（这是生成警告的位置），但是""<>具有使列表变平的副作用。所以这给了我们

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

现在出现了Mathematica的漂亮功能，Map它不在乎其映射的结构。您通常将其应用于列表，但它适用于任何头部。f /@ h[a, b, c]简单地给你h[f[a], f[b], f[c]]。在我们的例子中，head是StringJoin，值是整数。

ToString/@...

因此，这只是将整数转换为字符串。到那时，StringJoin[...]知道了如何处理它们，并将它们全部合并为一个字符串：

"121321432154321"

GolfScript，14个字节

~,{),{)}%-1%}%

在线尝试！

当然可以使用通常的方法，但这是GolfScript。

此VAST代码的说明：

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

请注意，输出为单个数字。尾随\n。

R，38 33 44字节

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

将输入输入到STDIN，并从1循环到n，为每个步骤创建序列i到1并打印。

编辑：替换seq(i,1)为i:1节省5个字节，并显示为什么我在会议期间不应该打高尔夫球。

MATL，14 11字节

:"@:P]v!VXz

在线尝试！

说明

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

Brainfuck，17个字节

>,[>[+.>]+.[<]>-]

说明

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

在线尝试！

蟒蛇，63 57 59字节

一个在Python 2和3中都可以使用的递归解决方案。欢迎打高尔夫球！在线尝试！

编辑： -6字节感谢乔纳森·艾伦。+2个字节，感谢mbomb007指出我的答案有问题。

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

开球

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

PHP，35岁 34 33字节

因为我记错了，所以节省了一个字节，谢谢提多！还有一个！

while($i++<$argv[1])echo$s=$i.$s;

从命令行运行 -r。

答案很简单，从1到我们的输入循环n，将数字添加到字符串的开头并打印出来。

CJam，13个字节

ri,:){,:)W%}%

口译员