Semplice:

Prendi un numero intero positivo n inferiore a 1000 e genera gli interi da 1 a n interlacciati con gli interi da n a 1 . È necessario concatenare i numeri in modo che appaiano senza delimitatori tra di loro.

Casi test:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

Questo è code-golf, quindi vince l'invio più breve in byte in ogni lingua. Le spiegazioni sono incoraggiate.

JavaScript (ES6), 30 byte

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

Come?

Questo è piuttosto semplice ma vale la pena notare che la corda è costruita dalla coda alla testa. Una stringa vuota all'inizio viene aggiunta per ultima e consente la coercizione del risultato finale a una stringa.

Di seguito è riportato il dettaglio della ricorsione per 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

Casi test

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

Grazie a ovs per 4 byte

Provalo online!

Spiegazione:

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

Haskell , 33 byte

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

Provalo online!

Bash , 25 byte

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

Provalo online!

Stampa la sequenza decrescente, le linee numeriche aumentano e printf unisce le linee

Spazio delimitato, 20 byte: seq $ 1 -1 1 | nl | xargs

R, 35 byte

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

Provalo online

rbind(1:n,n:1)crea una matrice di 2 righe con 1 a n nella prima riga e n a 1 nella seconda. La catfunzione comprime questa matrice, leggendo ogni colonna.

05AB1E , 6 5 byte

Salvato un byte usando il nuovo interleave incorporato come suggerito da rev

LÂ.ιJ

Provalo online!

Spiegazione

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

CJam , 10 byte

ri,:)_W%]z

Provalo online!

Spiegazione

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).

Rubino , 29 byte

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

Spiegazione:

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

Provalo online!

Spazio bianco , 71 byte

Provalo online!

Spiegazione

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'

Le prime due istruzioni sono necessarie per impostare correttamente lo stack, i comandi di input di Whitespace scrivono nell'heap quindi dobbiamo copiare b (il valore di input) nuovamente nello stack. Iniziamo con a = 0 poiché è più breve dichiarare 0 invece di 1 (salva un byte) e dobbiamo solo riordinare l'istruzione di incremento per farcela. Dopodiché eseguiamo semplicemente il loop e l'incremento a, output a, output b, decremento b, fino a quando b raggiunge 0 (controllato dopo il decremento).

Haskell, 65 48 47 byte

1 byte salvato grazie a Laikoni:

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

6 byte salvati grazie a nimi:

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

Risposta e spiegazione precedenti:

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

C'è già una risposta migliore di Haskell qui, ma sono nuovo sia per Haskell che per giocare a golf, quindi posso anche pubblicarlo :)

Questa funzione consente di comprimere l'elenco [1..n] con il suo contrario, risultando in un elenco di tuple.

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

Quindi utilizza concatMapper mappare un lambda a questo elenco di tuple che risulta in un elenco di elenchi ...

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

... e lo concatena.

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

Quindi un finale viene concatMapmappato showall'elenco e lo concatena in una singola stringa.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Pyth, 7 byte

jksC_BS

Provalo online: dimostrazione

Spiegazione:

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

Ottava, 29 byte

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

Provalo online!

Perl 6 , 20 byte

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

Provalo

Con un input di 100000 sono necessari circa 10 secondi, inclusa la compilazione e la stampa dell'output.

Allargato:

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

Il Z~bisogno è ~perché altrimenti genera un elenco di liste che si stringerà con spazi.

Non è necessario limitare l'intervallo a partire da 1, poiché si Zinterrompe quando si esauriscono gli elenchi di input.
Ciò consente di risparmiare due byte (dopo sarebbe necessario uno spazio $_)

Java 61 byte

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

Gelatina , 5 byte

RṚĖVV

Provalo online!

Come funziona

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}

Provalo online!

Questa è una funzione anonima che accetta input dallo stream.

Spiegazione

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

Fa letteralmente ciò che viene chiesto. Credo che possa essere superato da una soluzione meno banale.

Guardalo online

Aceto , 25 22 byte

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

Spiegazione:

Leggiamo un numero intero e lo mettiamo su due pile.

id
r}

Su uno, chiamiamo range_up ( Z), sull'altro range_down ( z), quindi impostiamo un contrassegno di cattura per poter tornare in questo luogo in seguito:

  @z
  Z)

Quindi controlliamo se lo stack corrente è vuoto e in tal caso uscire:

 X`=
  l0

Altrimenti, stampiamo da entrambe le pile e torniamo indietro al segno di cattura:

)&
p
(p

R, 41 byte

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

pryr::f()crea una funzione che accetta un input. Passa sopra 1:xe stampa ogni elemento di 1:xinsieme a ciascun elemento di x:1. Stampa su STDOUT.

Brachylog , 10 9 byte

⟦₁g↔ᶻczcc

Provalo online!

Spiegazione

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

MATL, 13 11 9 byte

2 byte salvati grazie a @Luis

:tPv1eVXz

Provalo su MATL Online

Spiegazione

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

Salvataggio di un byte grazie a Jörg Hülsermann.
Hai salvato sei byte grazie a Christoph.

Scala, 43 byte

Non è il migliore ma è il mio primo codice golf.

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

V , 20 byte

ywo1@"­ñykPjñkògJ

Provalo online!

Spiegare:

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 byte

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

Provalo online!

cubified:

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

Spinge 1, legge nell'input ( I), quindi entra nel loop che scambia la parte superiore dello stack, lo emette, incrementa, scambia, emette la parte superiore dello stack, diminuisce e si arresta se la parte superiore dello stack è 0.

K (ngn / k) , 16 byte

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

Provalo online!

MathGolf , 5 byte

{îkï-

Provalo online!

Spiegazione:

{      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 comune, 63 54 byte

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

Provalo online!

Mouse-2002 , 32 30 byte

-2 è stato spostato a condizione che inizi il ciclo (z.^ ... )anziché(... z.0>^)

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

Provalo online!

Spiegazione:

?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

In realtà , 9 byte

R;R@Z♂iεj

Provalo online! o eseguire tutti i casi di test

Spiegazione:

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