一个简单的：

取小于1000 的正整数n，并输出从1到n的整数与从n到1的整数交织在一起。您必须连接数字，以便它们之间没有任何定界符出现。

测试用例：

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

这是代码高尔夫球，因此每种语言中以字节为单位的最短提交胜出。鼓励解释。

JavaScript（ES6），30个字节

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

怎么样？

这非常简单，但是值得注意的是，字符串是从尾到头构建的。开头的空字符串会附加在最后，并允许将最终结果强制转换为字符串。

以下是的递归的详细信息f(4)：

f(4) =                                            // initial call
f(4, 1) =                                         // applying the default value to k
f(3, 2) + 4 + 1 =                                 // recursive call #1
(f(2, 3) + 3 + 2) + 4 + 1 =                       // recursive call #2
((f(1, 4) + 2 + 3) + 3 + 2) + 4 + 1 =             // recursive call #3
(((f(0, 5) + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =   // recursive call #4
((('' + 1 + 4) + 2 + 3) + 3 + 2) + 4 + 1 =        // n = 0 --> end of recursion
'' + 1 + 4 + 2 + 3 + 3 + 2 + 4 + 1 =              // final sum
'14233241'                                        // final result

测试用例

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

console.log(f(1))
console.log(f(4))
console.log(f(26))
console.log(f(100))

Python 2，46个字节

lambda n:''.join(`x+1`+`n-x`for x in range(n))

感谢ovs 4个字节

在线尝试！

说明：

lambda n:''.join(`x+1`+`n-x`for x in range(n))
lambda n:                                      # anonymous lambda taking one parameter n
                 `x+1`+`n-x`                   # `x` is repr(x) which is equivalent to str(x) for integers less than INT_MAX
                            for x in range(n)  # integers x in [0, n)

-5感谢ØrjanJohansen

Haskell，33个字节

f n=do a<-[1..n];[a,n-a+1]>>=show

在线尝试！

Bash，25个字节

printf %s`seq $1 -1 1|nl`

在线尝试！

打印顺序减少，行数增加，printf连接行

用空格分隔的20个字节：seq $ 1 -1 1 | nl | xargs

R，35个字节

n=scan();cat(rbind(1:n,n:1),sep="")

在线尝试

rbind(1:n,n:1)创建一个2行矩阵，第一行从1到n，第二行从n到1。该cat功能崩溃这个矩阵，向下读取每列。

05AB1E，6 5字节

使用rev建议的内置新交错方式保存字节

LÂ.ιJ

在线尝试！

说明

L        # range [1 ... input]
 Â       # create a reversed copy
  .ι     # interleave the lists
    J    # join

CJam，10个字节

ri,:)_W%]z

在线尝试！

说明

ri   e# Read input and convert to integer N.
,    e# Turn into range [0 1 ... N-1].
:)   e# Increment to get [1 2 ... N].
_W%  e# Duplicate and reverse the copy.
]    e# Wrap both in an array to get [[1 2 ... N] [N ... 2 1]]
z    e# Transpose to get [[1 N] [2 N-1] ... [N-1 2] [N 1]]
     e# This list is printed implicitly at the end of the program,
     e# but without any of the array structure (so it's essentially flattened,
     e# each number is converted to a string and then all the strings
     e# are joined together and printed).

Ruby，29个字节

->n{n.times{|x|$><<x+1<<n-x}}

说明：

->n{n.times{|x|                # x in range [0..n-1]
               $><<            # output on console
                   x+1<<n-x}}  # x+1, then n-x

在线尝试！

空格，71字节

在线尝试！

说明

sssn  ; push 0 - seed the stack with 0 (this will be our 1->n counter, a)
sns   ; dup
tntt  ; getnum - read n (stored on the heap)
sns   ; dup
ttt   ; retr - pull n onto the stack (this will be our n->1 counter, b)
nssn  ; label 'loop'
snt   ; swap - bring a to the top
ssstn ; push 1
tsss  ; add - increment a
sns   ; dup
tnst  ; putnum - output a as a number
snt   ; swap - bring b to the top
sns   ; dup
tnst  ; putnum - output b as a number
ssstn ; push 1
tsst  ; sub - decrement b
sns   ; dup
ntstn ; jez 'exit' if b is 0
nsnn  ; jmp 'loop'

需要第一对指令来正确设置堆栈，Whitespace的输入命令将写入堆栈，因此我们需要将b（输入值）复制回堆栈。我们从a = 0开始，因为它声明0而不是1（节省一个字节）要短一些，并且我们只需要对递增指令进行重新排序即可。之后，我们仅循环并递增a，输出a，输出b，将b减1，直到b达到0（在减量后检查）。

Haskell，65 48 47字节

感谢Laikoni，节省了1个字节：

f n=show=<<(\(l,r)->[l,r])=<<zip[1..][n,n-1..1]

感谢nimi，节省了6个字节：

f n=show=<<(\(l,r)->[l,r])=<<zip[1..n][n,n-1..1]

先前的答案和解释：

f n=concatMap show$concatMap(\(l,r)->[l,r])(zip[1..n][n,n-1..1])

这里已经有了更好的Haskell答案，但是我对Haskell和代码高尔夫都是陌生的，所以我也可以发布它:)

此函数将列表[1..n]反向压缩，形成一个元组列表。

[(1,n),(2,n-1),(3,n-2)..(n,1)]

然后它用于concatMap将lambda映射到该元组列表，从而生成列表列表...

[[1,n],[2,n-1],[3,n-2]..[n,1]]

...并将其串联。

[1,n,2,n-1,3,n-2..n,1]

然后，final concatMap映射show到该列表并将其连接为单个字符串。

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Pyth，7个字节

jksC_BS

在线尝试：演示

说明：

jksC_BSQ   implicit Q (=input number) at the end
      SQ   create the range [1, ..., Q]
    _B     bifurcate by inversion, this gives [[1, ..., Q], [Q, ..., 1]]
  sC       zip and flatten result
jk         join to a string

八度，29字节

@(n)printf("%d",[1:n;n:-1:1])

在线尝试！

Perl 6，20个字节

{[~] 1..*Z~($_...1)}

测试一下

输入100000，大约需要10秒钟，包括编译和打印输出。

展开：

{                # bare block lambda with implicit parameter ｢$_｣

  [~]            # reduce using concatenation operator ｢&infix:«~»｣
                 # (shorter than ｢join '',｣)

    1 .. *       # Range from 1 to infinity

    Z~           # zip using concatenation operator

    ( $_ ... 1 ) # deduced sequence starting at the input
                 # going down to 1
}

的Z~需要~，因为否则产生清单将与空间字符串化的列表。

无需将范围限制为从1开始，因为Z在任何输入列表用完时都会停止。
这样可以节省两个字节（后面需要一个空格$_）

Java 61字节

(int n)->{for(int i=0;i<n;System.out.print(i+1+""+(n-i++)));}

果冻，5个字节

RṚĖVV

在线尝试！

怎么运行的

RṚĖVV  Main link. Argument: n

R      Range; yield [1, ..., n].
 Ṛ     Reverse; yield [n, ..., 1].
  Ė    Enumerate; yield [[1, n], ..., [n, 1]].
   V   Eval; convert each flat array to a string, interpret it as a Jelly program,
       and yield the output. This concatenates the integers in each pair, yielding
       a flat array of integers
    V  Repeat the previous step, concatenating the intgegers from before.

罗达（21岁） 19字节

{seq 1,_<>seq _1,1}

在线尝试！

这是一个匿名函数，从流中获取输入。

说明

{seq 1,_<>seq _1,1}               Anonymous function, takes integer n from the stream
        <>                        Interleave
 seq 1,_                            the range 1 .. n with
          seq _1,1                  the range n .. 1

Clojure，61个字节

#(let[a(range 1(+ 1 %))](apply str(interleave a(reverse a))))

从字面上看是做什么的。我相信可以通过一个不那么琐碎的解决方案来解决它。

在线观看

Aceto，25 22字节

)&
pX`=
(pl0
id@z
r}Z)

说明：

我们读取一个整数并将其放在两个堆栈中。

id
r}

一方面，我们调用range_up（Z），另一方面，调用range_down（），z然后设置一个捕获标记，以便以后可以返回到该位置：

  @z
  Z)

然后，我们检查当前堆栈是否为空，如果是，则退出：

 X`=
  l0

否则，我们将从两个纸堆中打印并跳回到捕捉标记：

)&
p
(p

R，41个字节

pryr::f(for(i in 1:x){cat(i);cat(x-i+1)})

pryr::f()创建一个需要一个输入的函数。循环1:x并打印的每个元素1:x以及的每个元素x:1。打印到STDOUT。

Brachylog，10 9字节

⟦₁g↔ᶻczcc

在线尝试！

说明

⟦₁           [1, …, Input]
  g↔ᶻc       [[1, …, Input],[Input, …, 1]]
      z      Zip
       cc    Concatenate twice

MATL，13 11 9字节

@Luis节省了2个字节

:tPv1eVXz

在MATL Online上尝试

说明

        % Implicitly grab input as a number, N
:       % Create an array from 1..N
tP      % Create a reversed copy
v       % Vertically concatenate the two
1e      % Reshape it into a row vector
V       % Convert to a string
Xz      % Remove whitespace and implicitly display

PHP，36 35 29字节

for(;$argn;)echo++$i,$argn--;

感谢JörgHülsermann，节省了一个字节。
感谢克里斯多夫，节省了六个字节。

Scala，43个字节

这不是最好的，但这是我第一次打高尔夫。

n=>1.to(n).foldLeft("")((s,x)=>s+x+(n-x+1))

V，20字节

ywo1@"­ñykPjñkògJ

在线尝试！

说明：

yw                    ' Copy the input number (for looping later)
  o1                 ' Insert a 1 under the input (on a newline)
     @"               ' [Copy register] number of times
       ­ñ      ñ       ' Do the thing inside of this loop
        ykP           ' Copy the current line and line above it, and paste above both
           j        ' decrement the current (top) number, and increment the one below
               k      ' Go to the top line
                ògJ   ' recursively join all of the lines

Cubix，17个字节

....1I>sO)su.@?(O

在线尝试！

小结：

    . .
    . .
1 I > s O ) s u
. @ ? ( O . . .
    . .
    . .

压1入，读入输入（I），然后进入循环，该循环交换堆栈的顶部，输出，递增，交换，输出堆栈的顶部，递减，如果堆栈的顶部为0，则停止。

K（ngn / k），16字节

{,//$r,'|r:1+!x}

在线尝试！

MathGolf，5个字节

{îkï-

在线尝试！

说明：

{      Run a for loop over implicit input
 î     Push 1 based index of loop
  k    Push inputted number
   ï-  Subtract 0 based index of loop
       Implicitly output all this joined together

Common Lisp，63 54字节

(lambda(n)(dotimes(i n)(format t"~a~a"(1+ i)(- n i))))

在线尝试！

鼠标2002年，32 30个字节

-2有条件地移动到循环的开始(z.^ ... )而不是(... z.0>^)

?n:n.z:(z.^a.1+a:a.!z.!z.1-z:)

在线尝试！

说明：

?n:                                 ~ get input and store in n
   n.z:                             ~ copy n into z
       (z.^                         ~ stop if z equals 0
           a.1+a:                   ~ add 1 to a
                 a.!                ~ print a
                    z.!             ~ print z
                       z.1-z:)      ~ substract 1 from z

实际上，9个字节

R;R@Z♂iεj

在线尝试！，或运行所有测试用例

说明：

R;R@Z♂iεj
R          range(1, n+1)
 ;R        duplicate and reverse
   @Z      swap and zip
     ♂i    make 1D
       εj  join with empty string