Un simple:

Prendre un entier positif n inférieur à 1000 et sortir les entiers de 1 à n entrelacés avec les entiers de n à 1 . Vous devez concaténer les nombres afin qu’ils apparaissent sans aucun séparateur entre eux.

Cas de test:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

C’est du code-golf, donc la soumission la plus courte en octets dans chaque langue est gagnante. Les explications sont encouragées.

JavaScript (ES6), 30 octets

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

Comment?

C'est assez simple, mais il convient de noter que la chaîne est construite de la queue à la tête. Une chaîne vide au début est ajoutée en dernier et permet la coercition du résultat final sur une chaîne.

Ci-dessous le détail de la récursivité pour 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

Cas de 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 octets

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

Merci aux ovs pour 4 octets

Essayez-le en ligne!

Explication:

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 grâce à Ørjan Johansen

Haskell , 33 octets

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

Essayez-le en ligne!

Bash , 25 octets

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

Essayez-le en ligne!

Imprime une séquence décroissante, augmente le nombre de lignes et printf joint les lignes

Espace délimité, 20 octets: seq $ 1 -1 1 | nl | xargs

R, 35 octets

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

Essayez-le en ligne

rbind(1:n,n:1)crée une matrice à 2 lignes avec 1 à n dans la première ligne et n à 1 dans la seconde. La catfonction réduit cette matrice en lisant chaque colonne.

05AB1E , 6 5 octets

Enregistré un octet en utilisant le nouvel entrelacement intégré comme suggéré par rev

LÂ.ιJ

Essayez-le en ligne!

Explication

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

CJam , 10 octets

ri,:)_W%]z

Essayez-le en ligne!

Explication

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 octets

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

Explication:

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

Essayez-le en ligne!

Espaces blancs , 71 octets

Essayez-le en ligne!

Explication

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'

Les deux premières instructions sont nécessaires pour configurer correctement la pile, les commandes d'entrée de Whitespace écrivant dans le tas, nous devons donc copier b (la valeur d'entrée) dans la pile. Nous commençons avec a = 0 car il est plus court de déclarer 0 au lieu de 1 (enregistre un octet) et il suffit de réordonner l'instruction d'incrémentation pour y faire face. Après cela, on boucle et incrémente a, sortie a, sortie b, décrémente b, jusqu'à ce que b atteigne 0 (vérifié après le décrément).

Haskell, 65 48 47 octets

1 octet économisé grâce à Laikoni:

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

6 octets sauvés grâce à nimi:

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

Réponse précédente et explication:

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

Il y a déjà une meilleure réponse Haskell ici, mais je suis novice en Haskell et en code-golf, alors je peux aussi bien le poster :)

Cette fonction ferme la liste [1..n] avec son verso, ce qui donne une liste de n-uplets.

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

Ensuite, il utilise concatMappour mapper un lambda à cette liste de tuples qui résulte en une liste de listes ...

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

... et le concatène.

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

Ensuite, une dernière concatMapcarte mappe showà la liste et la concatène en une seule chaîne.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Pyth, 7 octets

jksC_BS

Essayez-le en ligne: démonstration

Explication:

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

Octave, 29 octets

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

Essayez-le en ligne!

Perl 6 , 20 octets

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

Essaye-le

Avec une entrée de 100 000, cela prend environ 10 secondes, compilation et impression de la sortie comprises.

Étendu:

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

le Z~ nécessite le ~parce que sinon, il génère une liste de listes qui seront stigmatisées avec des espaces.

Il n'est pas nécessaire de limiter la plage à partir de 1, car Zs'arrête lorsque l'une des listes d'entrées est vide.
Cela économise deux octets (un espace sera nécessaire après $_)

Java 61 octets

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

Gelée , 5 octets

RṚĖVV

Essayez-le en ligne!

Comment ça marche

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 octets

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

Essayez-le en ligne!

C'est une fonction anonyme qui prend une entrée du flux.

Explication

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

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

Fait littéralement ce qui est demandé. Je crois que cela peut être évité par une solution moins triviale.

Voir en ligne

Aceto , 25 22 octets

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

Explication:

Nous lisons un entier et le mettons sur deux piles.

id
r}

Sur l'un, nous appelons range_up ( Z), sur l'autre, range_down ( z), puis nous définissons un repère pour pouvoir revenir à cet endroit plus tard:

  @z
  Z)

Nous vérifions ensuite si la pile actuelle est vide et quittons si c'est le cas:

 X`=
  l0

Sinon, nous imprimons à partir des deux piles et retournons à la cible:

)&
p
(p

R, 41 octets

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

pryr::f()crée une fonction qui prend une entrée. Boucle dessus 1:xet imprime chaque élément de 1:xavec chaque élément de x:1. Imprime sur STDOUT.

Brachylog , 10 à 9 octets

⟦₁g↔ᶻczcc

Essayez-le en ligne!

Explication

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

MATL, 13 11 9 octets

2 octets sauvegardés grâce à @Luis

:tPv1eVXz

Essayez-le sur MATL Online

Explication

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

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

Un octet enregistré grâce à Jörg Hülsermann.
Sauvé six octets grâce à Christoph.

Scala, 43 octets

Ce n'est pas le meilleur mais c'est mon premier code golf.

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

V, 20 bytes

ywo1@"­ñykPjñkògJ

Try it online!

Explain:

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

Try it online!

cubified:

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

Pushes 1, reads in the input (I), then enters the loop which swaps the top of the stack, outputs it, increments, swaps, outputs the top of the stack, decrements, and stops if the top of the stack is 0.

K (ngn/k), 16 bytes

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

Try it online!

MathGolf, 5 bytes

{îkï-

Try it online!

Explanation:

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

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

Try it online!

Mouse-2002, 32 30 bytes

-2 moved conditional to start of loop (z.^ ... ) instead of (... z.0>^)

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

Try it online!

Explanation:

?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

Actually, 9 bytes

R;R@Z♂iεj

Try it online!, or run all test cases

Explanation:

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