Una simple:

Tome un entero positivo n menor que 1000, y genere los enteros de 1 a n entrelazados con los enteros de n a 1 . Debe concatenar los números para que aparezcan sin delimitadores entre ellos.

Casos de prueba:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

Este es el código de golf, por lo que gana el envío más corto en bytes en cada idioma. Se alientan las explicaciones.

JavaScript (ES6), 30 bytes

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

¿Cómo?

Esto es bastante sencillo, pero vale la pena señalar que la cadena se construye de la cola a la cabeza. Una cadena vacía al principio se agrega al final y permite que ocurra la coerción del resultado final a una cadena.

A continuación se detalla la recursividad de 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

Casos de prueba

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 bytes

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

Gracias a ovs por 4 bytes

Pruébalo en línea!

Explicación:

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 gracias a Ørjan Johansen

Haskell , 33 bytes

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

Pruébalo en línea!

Bash , 25 bytes

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

Pruébalo en línea!

Imprime la secuencia decreciente, las líneas numéricas aumentan y printf une las líneas

Delimitado por espacios, 20 bytes: seq $ 1 -1 1 | nl | xargs

R, 35 bytes

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

Pruébalo en línea

rbind(1:n,n:1)crea una matriz de 2 filas con 1 a n en la primera fila yn a 1 en la segunda. La catfunción colapsa esta matriz, leyendo cada columna.

05AB1E , 6 5 bytes

Se guardó un byte usando el nuevo intercalado incorporado como lo sugiere rev

LÂ.ιJ

Pruébalo en línea!

Explicación

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

CJam , 10 bytes

ri,:)_W%]z

Pruébalo en línea!

Explicación

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 bytes

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

Explicación:

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

Pruébalo en línea!

Espacio en blanco , 71 bytes

Pruébalo en línea!

Explicación

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'

Las primeras instrucciones son necesarias para configurar la pila correctamente, los comandos de entrada de Whitespace escriben en el montón, por lo que debemos copiar b (el valor de entrada) nuevamente en la pila. Comenzamos con a = 0 ya que es más corto declarar 0 en lugar de 1 (guarda un byte) y solo necesitamos reordenar la instrucción de incremento para hacer frente. Después de eso, simplemente repetimos e incrementamos a, salida a, salida b, decremento b, hasta que b llega a 0 (verificado después del decremento).

Haskell, 65 48 47 bytes

1 byte guardado gracias a Laikoni:

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

6 bytes guardados gracias a nimi:

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

Respuesta previa y explicación:

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

Ya hay una mejor respuesta de Haskell aquí, pero soy nuevo tanto en Haskell como en el golf de código, así que también puedo publicarlo :)

Esta función comprime la lista [1..n] con su reverso, lo que resulta en una lista de tuplas.

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

Luego se usa concatMappara asignar una lambda a esta lista de tuplas que da como resultado una lista de listas ...

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

... y lo concatena.

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

Luego, un concatMapmapa final se asigna showa la lista y se concatena en una sola cadena.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Pyth, 7 bytes

jksC_BS

Pruébelo en línea: demostración

Explicación:

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

Octava, 29 bytes

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

Pruébalo en línea!

Perl 6 , 20 bytes

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

Pruébalo

Con una entrada de 100000, esto lleva aproximadamente 10 segundos, incluida la compilación y la impresión de la salida.

Expandido:

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

El Z~necesita el ~porque de lo contrario genera una lista de listas que se encadenarán con espacios.

No hay necesidad de limitar el Rango a partir de 1, porque se Zdetiene cuando se acaba cualquiera de las listas de entrada.
Esto ahorra dos bytes (se necesitaría un espacio después $_)

Java 61 bytes

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

Jalea , 5 bytes

RṚĖVV

Pruébalo en línea!

Cómo funciona

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 bytes

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

Pruébalo en línea!

Esta es una función anónima que toma datos de la secuencia.

Explicación

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

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

Literalmente hace lo que se le pide. Creo que puede ser superado por una solución menos trivial.

Véalo en línea

Aceto , 25 22 bytes

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

Explicación:

Leemos un número entero y lo ponemos en dos pilas.

id
r}

En uno, llamamos a range_up ( Z), en el otro a range_down ( z), luego establecemos una marca de captura para poder regresar a este lugar más tarde:

  @z
  Z)

Luego verificamos si la pila actual está vacía y salimos si es así:

 X`=
  l0

De lo contrario, imprimimos desde ambas pilas y volvemos a la marca de captura:

)&
p
(p

R, 41 bytes

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

pryr::f()crea una función que toma una entrada. Recorre 1:xe imprime cada elemento 1:xjunto con cada elemento de x:1. Imprime en STDOUT.

Brachylog , 10 9 bytes

⟦₁g↔ᶻczcc

Pruébalo en línea!

Explicación

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

MATL, 13 11 9 bytes

2 bytes guardados gracias a @Luis

:tPv1eVXz

Pruébalo en MATL Online

Explicación

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

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

Salvado un byte gracias a Jörg Hülsermann.
Guardado seis bytes gracias a Christoph.

Scala, 43 bytes

No es el mejor, pero es mi primer código de golf.

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

V , 20 bytes

ywo1@"­ñykPjñkògJ

Pruébalo en línea!

Explique:

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 bytes

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

Pruébalo en línea!

Cubicado:

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

Empuja 1, lee en la entrada ( I), luego ingresa al bucle que intercambia la parte superior de la pila, lo genera, incrementa, intercambia, genera la parte superior de la pila, disminuye y se detiene si la parte superior de la pila es 0.

K (ngn / k) , 16 bytes

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

Pruébalo en línea!

MathGolf , 5 bytes

{îkï-

Pruébalo en línea!

Explicación:

{      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 común, 63 54 bytes

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

Pruébalo en línea!

Ratón-2002 , 32 30 bytes

-2 se movió condicional al inicio del ciclo en (z.^ ... )lugar de(... z.0>^)

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

Pruébalo en línea!

Explicación:

?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

Actualmente , 9 bytes

R;R@Z♂iεj

Pruébalo en línea! o ejecutar todos los casos de prueba

Explicación:

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