Простой:

Возьмите положительное целое число 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))

Благодаря овам за 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 благодаря Орджану Йохансену

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 секунд, включая компиляцию и вывод на печать.

Expanded:

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

МАТЛ, 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--;

Сохранение одного байта благодаря Jörg Hülsermann.
Сохранено шесть байтов благодаря Кристофу.

Скала, 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

Попробуйте онлайн!

cubified:

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

Pushes 1, читает в input ( I), затем входит в цикл, который меняет вершину стека, выводит его, увеличивает, меняет, выводит верх стека, уменьшает и останавливает, если вершина стека равна 0.

К (нгн / к) , 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