간단한 것 :

양수 받아 N 에서 정수 이하 1,000 미만, 출력 한 것은 하는 N 의 정수 인터리브 없음 을 1 . 숫자를 구분 기호없이 표시하도록 숫자를 연결해야합니다.

테스트 사례 :

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

이것은 코드 골프 이므로 각 언어에서 가장 짧은 바이트 제출이 이깁니다. 설명이 권장됩니다.

자바 스크립트 (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))

파이썬 2 , 46 바이트

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

4 바이트 ovs 덕분에

온라인으로 사용해보십시오!

설명:

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)

Ørjan Johansen 덕분에 -5

하스켈 , 33 바이트

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

온라인으로 사용해보십시오!

배쉬 , 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)첫 번째 행에는 1부터 n까지, 두 번째에는 n부터 1까지의 2 행 행렬을 만듭니다. 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).

루비 , 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'

스택을 올바르게 설정하려면 첫 번째 명령이 필요합니다. 공백의 입력 명령은 힙에 쓰므로 b (입력 값)를 스택에 다시 복사해야합니다. 1 대신 0을 선언하는 것이 더 짧기 때문에 (바이트를 절약하기 때문에) a = 0으로 시작하고 증가 명령을 다시 정렬하기 만하면됩니다. 그 후에 우리는 b를 0에 도달 할 때까지 a를 반복하고 증가시키고, a, 출력 b, 감소 b를 출력합니다.

하스켈, 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람다를이 튜플 목록에 매핑하여 목록 목록을 만듭니다.

[[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])

온라인으로 사용해보십시오!

펄 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~필요 ~그렇지 않으면 공간과 캐릭터 라인 화한다리스트 목록을 생성하기 때문이다.

Z입력 목록이 모두 소진되면 중지 되므로 범위는 1에서 시작하여 제한 할 필요가 없습니다 .
이것은 2 바이트를 절약합니다 (다음에 공백이 필요합니다 $_)

자바 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

클로저, 61 바이트

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

말 그대로 질문을합니다. 나는 덜 사소한 해결책으로도 능가 할 수 있다고 생각합니다.

온라인으로보십시오

아세토 , 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örg Hülsermann 덕분에 1 바이트를 절약했습니다.
Christoph 덕분에 6 바이트를 절약했습니다.

스칼라, 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

공통 리스프, 63 54 바이트

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

온라인으로 사용해보십시오!

Mouse-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