Một đơn giản:

Lấy số nguyên dương n nhỏ hơn 1000 và xuất ra các số nguyên từ 1 đến n xen kẽ với các số nguyên từ n đến 1 . Bạn phải nối các số sao cho chúng xuất hiện mà không có bất kỳ dấu phân cách nào giữa chúng.

Các trường hợp thử nghiệm:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

Đây là môn đánh gôn, vì vậy bài nộp ngắn nhất theo byte trong mỗi ngôn ngữ sẽ thắng. Giải thích được khuyến khích.

JavaScript (ES6), 30 byte

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

Làm sao?

Điều này khá đơn giản nhưng đáng chú ý là chuỗi được xây dựng từ đuôi đến đầu. Một chuỗi trống ở đầu được nối thêm lần cuối và cho phép ép buộc kết quả cuối cùng thành chuỗi.

Dưới đây là chi tiết của đệ quy cho 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

Các trường hợp thử nghiệm

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 byte

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

Cảm ơn ovs cho 4 byte

Hãy thử trực tuyến!

Giải trình:

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 cảm ơn Ørjan Johansen

Haskell , 33 byte

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

Hãy thử trực tuyến!

Bash , 25 byte

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

Hãy thử trực tuyến!

In chuỗi giảm, số dòng tăng và printf nối các dòng

Giới hạn không gian, 20 byte: seq $ 1 -1 1 | nl | xargs

R, 35 byte

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

Dùng thử trực tuyến

rbind(1:n,n:1)tạo ma trận 2 hàng với 1 đến n ở hàng đầu tiên và n đến 1 trong hàng thứ hai. Các catchức năng sụp đổ ma trận này, đọc xuống mỗi cột.

05AB1E , 6 5 byte

Đã lưu một byte bằng cách sử dụng xen kẽ mới được tích hợp theo đề xuất của rev

LÂ.ιJ

Hãy thử trực tuyến!

Giải trình

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

CJam , 10 byte

ri,:)_W%]z

Hãy thử trực tuyến!

Giải trình

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 byte

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

Giải trình:

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

Hãy thử trực tuyến!

Khoảng trắng , 71 byte

Hãy thử trực tuyến!

Giải trình

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'

Cần có một vài hướng dẫn đầu tiên để thiết lập ngăn xếp một cách chính xác, các lệnh đầu vào của Whitespace ghi vào heap để chúng ta cần sao chép b (giá trị đầu vào) trở lại ngăn xếp. Chúng tôi bắt đầu với a = 0 vì nó ngắn hơn để khai báo 0 thay vì 1 (lưu một byte) và chúng tôi chỉ cần sắp xếp lại thứ tự tăng dần để đối phó. Sau đó, chúng ta chỉ lặp và tăng a, đầu ra a, đầu ra b, giảm b, cho đến khi b đạt 0 (được kiểm tra sau khi giảm).

Haskell, 65 48 47 byte

Lưu 1 byte nhờ Laikoni:

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

6 byte được lưu nhờ nimi:

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

Câu trả lời và giải thích trước:

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

Đã có câu trả lời Haskell tốt hơn ở đây, nhưng tôi chưa quen với cả Haskell và chơi golf mã, vì vậy tôi cũng có thể đăng nó :)

Hàm này nén danh sách [1..n] với đảo ngược của nó, dẫn đến một danh sách các bộ dữ liệu.

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

Sau đó, nó sử dụng concatMapđể ánh xạ lambda vào danh sách các bộ dữ liệu này dẫn đến một danh sách các danh sách ...

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

... và nối nó lại.

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

Sau đó, một concatMapbản đồ cuối cùng showvào danh sách và ghép nó thành một chuỗi duy nhất.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Bình thường, 7 byte

jksC_BS

Dùng thử trực tuyến: Trình diễn

Giải trình:

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

Octave, 29 byte

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

Hãy thử trực tuyến!

Perl 6 , 20 byte

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

Kiểm tra nó

Với đầu vào là 100000, việc này mất khoảng 10 giây, bao gồm biên dịch và in đầu ra.

Mở rộng:

{                # 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
}

Các Z~ nhu cầu ~vì nếu không nó sẽ tạo ra một danh sách liệt kê mà sẽ stringify với không gian.

Không cần giới hạn Phạm vi bắt đầu từ 1, vì Zdừng khi bất kỳ danh sách đầu vào nào hết.
Điều này tiết kiệm hai byte (sẽ cần một không gian sau $_)

Java 61 byte

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

Thạch , 5 byte

RṚĖVV

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Röda , 21 19 byte

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

Hãy thử trực tuyến!

Đây là một chức năng ẩn danh nhận đầu vào từ luồng.

Giải trình

{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 byte

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

Nghĩa đen làm những gì được yêu cầu. Tôi tin rằng nó có thể bị vượt qua bởi một giải pháp ít tầm thường hơn.

Xem nó trực tuyến

Aceto , 25 22 byte

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

Giải trình:

Chúng tôi đọc một số nguyên và đặt nó trên hai ngăn xếp.

id
r}

Trên một, chúng tôi gọi phạm vi_up ( Z), trên phạm vi khác_down ( z), sau đó chúng tôi đặt dấu bắt để có thể quay lại vị trí này sau:

  @z
  Z)

Sau đó chúng tôi kiểm tra xem ngăn xếp hiện tại có trống không và thoát nếu vậy:

 X`=
  l0

Mặt khác, chúng tôi in từ cả hai ngăn xếp và nhảy trở lại dấu bắt:

)&
p
(p

R, 41 byte

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

pryr::f()tạo một hàm lấy một đầu vào. Vòng lặp 1:xvà in từng phần tử 1:xcùng với mỗi phần tử của x:1. In sang STDOUT.

Brachylog , 10 9 byte

⟦₁g↔ᶻczcc

Hãy thử trực tuyến!

Giải trình

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

TOÁN, 13 11 9 byte

Lưu 2 byte nhờ @Luis

:tPv1eVXz

Dùng thử tại MATL Online

Giải trình

        % 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 byte

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

Đã lưu một byte nhờ vào Jörg Hülsermann.
Lưu sáu byte nhờ Christoph.

Scala, 43 byte

Nó không phải là tốt nhất nhưng đó là golf mã đầu tiên của tôi.

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

V , 20 byte

ywo1@"­ñykPjñkògJ

Hãy thử trực tuyến!

Giải thích:

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

Khối , 17 byte

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

Hãy thử trực tuyến!

lập phương

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

Đẩy 1, đọc trong đầu vào ( I), sau đó vào vòng lặp hoán đổi đỉnh của ngăn xếp, xuất nó, tăng, hoán đổi, xuất ra đỉnh của ngăn xếp, giảm và dừng nếu đỉnh của ngăn xếp là 0.

K (ngn / k) , 16 byte

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

Hãy thử trực tuyến!

MathGolf , 5 byte

{îkï-

Hãy thử trực tuyến!

Giải trình:

{      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

Lisp thường gặp, 63 54 byte

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

Hãy thử trực tuyến!

Chuột-2002 , 32 30 byte

-2 di chuyển có điều kiện để bắt đầu vòng lặp (z.^ ... )thay vì(... z.0>^)

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

Hãy thử trực tuyến!

Giải trình:

?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

Trên thực tế , 9 byte

R;R@Z♂iεj

Hãy thử trực tuyến!hoặc chạy tất cả các trường hợp thử nghiệm

Giải trình:

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