Ein einfaches:

Nehmen Sie eine positive ganze Zahl n kleiner als 1000 und geben Sie die ganzen Zahlen von 1 bis n aus, die mit den ganzen Zahlen von n bis 1 verschachtelt sind . Sie müssen die Zahlen so verketten, dass sie ohne Trennzeichen angezeigt werden.

Testfälle:

n = 1
11

n = 4
14233241

n = 26
12622532442352262172081991810171116121513141413151216111710189198207216225234243252261

n = 100
110029939849759669579489399210911190128913881487158616851784188319822081218022792378247725762675277428732972307131703269336834673566366537643863396240614160425943584457455646554754485349525051515052495348544755465645574458435942604161406239633864376536663567346833693270317130722973287427752676257724782379228021812082198318841785168615871488138912901191109299389479569659749839921001

Dies ist Codegolf, daher gewinnt die kürzeste Übermittlung in Bytes in jeder Sprache. Erklärungen sind erwünscht.

JavaScript (ES6), 30 Byte

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

Wie?

Das ist ziemlich einfach, aber es ist erwähnenswert, dass die Saite vom Schwanz bis zum Kopf aufgebaut ist. Eine leere Zeichenkette am Anfang wird zuletzt angehängt und ermöglicht das Erzwingen des Endergebnisses zu einer Zeichenkette.

Unten ist das Detail der Rekursion für 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

Testfälle

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

Danke an ovs für 4 Bytes

Probieren Sie es online!

Erläuterung:

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 Dank an Ørjan Johansen

Haskell , 33 Bytes

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

Probieren Sie es online!

Bash , 25 Bytes

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

Probieren Sie es online!

Druckt die absteigende Reihenfolge, die Anzahl der Zeilen erhöht sich und printf verbindet die Zeilen

Leerzeichen begrenzt, 20 Bytes: seq $ 1 -1 1 | nl | xargs

R, 35 Bytes

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

Probieren Sie es online aus

rbind(1:n,n:1)Erstellt eine 2-Zeilen-Matrix mit 1 bis n in der ersten Zeile und n bis 1 in der zweiten. Die catFunktion reduziert diese Matrix und liest jede Spalte aus.

05AB1E , 6 5 Bytes

Es wurde ein Byte mit dem neuen integrierten Interleave gespeichert, wie von rev vorgeschlagen

LÂ.ιJ

Probieren Sie es online!

Erläuterung

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

CJam , 10 Bytes

ri,:)_W%]z

Probieren Sie es online!

Erläuterung

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

Erläuterung:

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

Probieren Sie es online!

Leerzeichen , 71 Bytes

Probieren Sie es online!

Erläuterung

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'

Die ersten Anweisungen sind erforderlich, um den Stapel korrekt einzurichten. Die Whitespace-Eingabebefehle schreiben in den Heap, sodass wir b (den Eingabewert) zurück in den Stapel kopieren müssen. Wir beginnen mit a = 0, da es kürzer ist, 0 anstelle von 1 zu deklarieren (spart ein Byte) und wir nur die Inkrement-Anweisung neu anordnen müssen, um damit fertig zu werden. Danach schleifen und inkrementieren wir einfach a, geben a aus, geben b aus, dekrementieren b, bis b 0 erreicht (überprüft nach dem Dekrementieren).

Haskell, 65 48 47 Bytes

Dank Laikoni 1 Byte gespart:

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

6 Bytes gespart dank nimi:

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

Vorherige Antwort und Erklärung:

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

Hier gibt es bereits eine bessere Antwort von Haskell, aber ich bin neu sowohl bei Haskell als auch beim Code-Golfen, also kann ich es auch posten :)

Diese Funktion zippt die Liste [1..n] mit der Umkehrung, was zu einer Liste von Tupeln führt.

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

Dann wird concatMapein Lambda auf diese Liste von Tupeln abgebildet, was zu einer Liste von Listen führt ...

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

... und verkettet es.

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

Anschließend concatMapwird showder Liste ein endgültiger Wert zugeordnet und zu einer einzelnen Zeichenfolge verkettet.

f 26 "12622532442352262172081991810171116121513141413151216111710189198207216225234243252261"

Pyth, 7 Bytes

jksC_BS

Probieren Sie es online aus: Demonstration

Erläuterung:

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

Oktave, 29 Bytes

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

Probieren Sie es online!

Perl 6 , 20 Bytes

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

Probier es aus

Bei einer Eingabe von 100000 dauert dies ungefähr 10 Sekunden, einschließlich des Zusammenstellens und Druckens der Ausgabe.

Erweitert:

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

Das Z~braucht der, ~weil es sonst eine Liste von Listen erzeugt, die sich mit Leerzeichen auszeichnen.

Es ist nicht erforderlich, den Bereich ab 1 zu begrenzen, da er Zstoppt, wenn eine der Eingabelisten abläuft.
Das spart zwei Bytes (ein Leerzeichen würde danach benötigt $_)

Java 61 Bytes

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

Gelee , 5 Bytes

RṚĖVV

Probieren Sie es online!

Wie es funktioniert

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}

Probieren Sie es online!

Dies ist eine anonyme Funktion, die Eingaben aus dem Stream entgegennimmt.

Erläuterung

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

Tut buchstäblich was gefragt wird. Ich glaube, es kann durch eine weniger triviale Lösung übertroffen werden.

Sehen Sie es online

Aceto , 25 22 Bytes

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

Erläuterung:

Wir lesen eine ganze Zahl und legen sie auf zwei Stapel.

id
r}

Zum einen rufen wir range_up ( Z) auf, zum anderen range_down ( z) und setzen dann eine Fangmarke , um später an diesen Ort zurückkehren zu können:

  @z
  Z)

Wir prüfen dann, ob der aktuelle Stack leer ist und beenden ihn, wenn dies der Fall ist:

 X`=
  l0

Andernfalls drucken wir aus beiden Stapeln und springen zur Fangmarke zurück:

)&
p
(p

R, 41 Bytes

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

pryr::f()Erstellt eine Funktion, die eine Eingabe annimmt. Durchläuft 1:xund druckt jedes Element von 1:xzusammen mit jedem Element von x:1. Druckt nach STDOUT.

Brachylog , 10 9 Bytes

⟦₁g↔ᶻczcc

Probieren Sie es online!

Erläuterung

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

MATL, 13 11 9 Bytes

2 Bytes gespart dank @Luis

:tPv1eVXz

Probieren Sie es bei MATL Online aus

Erläuterung

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

Ein Byte gespart dank Jörg Hülsermann.
Dank Christoph sechs Bytes gespart.

Scala, 43 Bytes

Es ist nicht das Beste, aber es ist mein erster Code Golf.

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

V , 20 Bytes

ywo1@"­ñykPjñkògJ

Probieren Sie es online!

Erklären:

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

Probieren Sie es online!

kubisch:

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

Drückt 1, liest die Eingabe ( I) ein und tritt dann in die Schleife ein, die die Oberseite des Stapels vertauscht, gibt sie aus, inkrementiert, vertauscht, gibt die Oberseite des Stapels aus, dekrementiert und stoppt, wenn die Oberseite des Stapels 0 ist.

K (ngn / k) , 16 Bytes

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

Probieren Sie es online!

MathGolf , 5 Bytes

{îkï-

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online!

Mouse-2002 , 32-30 Bytes

-2 verschoben bedingt zum Schleifenstart (z.^ ... )statt(... z.0>^)

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

Probieren Sie es online!

Erläuterung:

?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

Eigentlich 9 Bytes

R;R@Z♂iεj

Probieren Sie es online! oder führen Sie alle Testfälle aus

Erläuterung:

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