Простий:

Візьміть натуральне число n менше 1000 і виведіть цілі числа від 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 завдяки Ørjan Johansen

Haskell , 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)створює 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).

Рубін , 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, поки b не досягає 0 (перевіряється після декременту).

Haskell, 65 48 47 байт

1 байт збережено завдяки Laikoni:

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

6 байт збережено завдяки nimi:

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]

Тоді остаточне 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))))

Буквально робить те, що просять. Я вважаю, що це може бути переможене менш тривіальним рішенням.

Дивіться це в Інтернеті

Ацето , 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.

Брахілог , 10 9 байт

⟦₁g↔ᶻczcc

Спробуйте в Інтернеті!

Пояснення

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

MATL, 13 11 9 байт

2 байти збережено завдяки @Luis

: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--;

Збережено один байт завдяки Йоргу Гюльсерману.
Збережено шість байтів завдяки Крістофу.

Скала, 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 (нг / к) , 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))))

Спробуйте в Інтернеті!

Миша-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