Einführung

Nehmen wir als Beispiel die Nummer 7. Wir duplizieren dies und platzieren 7 Leerzeichen dazwischen. Wir bekommen das:

7_______7

Danach werden wir die Zahl verringern, bis keine Leerzeichen mehr übrig sind. Für die Nummer 7 bekommen wir folgendes:

7_______7    
 6543210

Dann verschmelzen wir einfach die beiden, also:

7_______7    
 6543210  becomes

765432107

Dies wird für N = 7 ausgegeben .

Sieht einfach aus, oder? Nehmen wir nun N = 12 . Wir fügen wieder 12 Leerzeichen zwischen den beiden Zahlen ein, was uns ergibt:

12____________12

Dann starten wir die Dekrementierung:

12____________12
  111098765432

Und das gibt uns schließlich:

1211109876543212

Wie Sie sehen, endet der absteigende Teil bei 2 und nicht bei 0 .

Aufgabe

Bei einer Ganzzahl größer als 1 wird die absteigende Reihenfolge wie oben gezeigt ausgegeben.

Testfälle

Input   Output

2       2102
3       32103
4       432104
5       5432105
6       65432106
7       765432107
8       8765432108
9       98765432109
10      10987654321010
11      111098765432111
12      1211109876543212
13      13121110987654313
14      141312111098765414
15      1514131211109876515
20      201918171615141312111020
99      9998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150499
100     1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

CJam, 11 10 Bytes

q4*~,W%s<\

Probieren Sie es online aus. Angenommen, die Eingabe enthält eine nachgestellte Newline. (Danke an @ jimmy23013 für das Speichern eines Bytes.)

Erläuterung

Am Ende jeder Zeile steht, wie der Stapel an diesem Punkt aussieht (am 4Beispiel).

q4*  e# Push input x 4 times, separated by newlines. ["4\n4\n4\n4\n"]
~    e# Evaluate, separating the 4's and converting them to numbers. [4 4 4 4]
,W%  e# Take the range of x and reverse it. [4 4 4 [3 2 1 0]]
s<   e# Cast to string and take the first x characters. [4 4 "3210"]
\    e# Swap the top two to get the final result. [4 "3210" 4]

Julia, 30 Bytes

n->"$n"join(n-1:-1:0)[1:n]"$n"

Dies ist eine anonyme Funktion, die eine Ganzzahl akzeptiert und eine Zeichenfolge zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu.

Wir konstruieren und verknüpfen die absteigende Folge von n -1 bis 0 und nehmen die ersten n Zeichen aus der resultierenden Zeichenfolge. Wir stellen die Eingabe als Zeichenfolge voran und hängen sie an.

Überprüfen Sie alle Testfälle online

Haskell, 44 Bytes

s=show
f n=s n++take n(s=<<[n-1,n-2..])++s n

Anwendungsbeispiel: f 14-> "141312111098765414".

JavaScript (ES6), 55 52 Byte

n=>n+[...Array(m=n)].map(_=>--m).join``.slice(0,n)+n

Bearbeiten: 3 Bytes dank @WashingtonGuedes gespeichert.

Python 2, 82 72 58 53 Bytes

lambda x:`x`+''.join(map(str,range(x)[::-1]))[:x]+`x`

Probieren Sie es hier aus!

Vielen Dank an @Alex, der mir das beigebracht hat repr(x)= `x`mir ein paar Bytes gespart zu haben!

Pyth, 11 Bytes

++Q<jk_UQQQ

Zwei alternative Versionen, die alle auch 11 Bytes umfassen ( seufz ):

s[Q<jk_UQQQ
pQp<jk_UQQQ

  Q           the input
       UQ     [0, 1, ..., input-2, input-1]
      _       reverse
    jk        join on empty string
   <     Q    first (input) characters
          Q   the input again
++            concatenate everything so it prints on one line

Probieren Sie es hier aus.

Japt, 13 Bytes

U+Uo w ¬¯U +U

Online testen!

Wie es funktioniert

               // Implicit: U = input integer
  Uo           // Create the range [0..U).
     w         // Reverse.
       ¬       // Join.
        ¯U     // Slice to the first U chars.
U+         +U  // Append U on either end.

Gelee, 10 Bytes

Ȯ’r0DFḣ³Ḍ³

Probieren Sie es online!

Wie es funktioniert

Ȯ’r0DFḣ³Ḍ³  Main link. Input: n

Ȯ           Print n.
 ’          Decrement to yield n - 1.
  r0        Create a range from n - 1 to 0.
    D       Convert each integer to base 10 (array of decimal digits).
     F      Flatten the resulting array.
      ḣ³    Keep the first n elements.
        Ḍ   Convert from base 10 to integer.
         ³  Print the integer and set the return value to n.
            (implicit) Print the return value.

Retina 98, 110

Längste Antwort bisher: - /

.+
$&;$&$*:
+`:(:+)$
$& $1
 (:)*
$#1
\d+$
$&0 $&0
T`d`,`\d+$
+`:(.*),
$1
+`. ,

(.+);(.*) 
$1$2$1

Probieren Sie es online aus.

Vitsy, 35 Bytes

Da Vitsy nicht weiß, wie man aus Zahlen Strings macht, habe ich es implementiert, die Länge der Zahl in Dezimalstellen in der zweiten Zeile zu finden.

V0VVNHVv[XDN1mv$-DvD);]VN
1a/+aL_1+

Erläuterung:

V0VVNHVv[XDN1mv$-DvD);]VN
V                          Save the input as a global final variable.
 0V                        Push 0, push input.
   VN                      Output the input.
     H                     Push the range 0...intput.
      Vv                   Push the input, then save it as a temp variable.
        [             ]    Do the stuff in brackets infinitely or until exited.
         X                 Remove the top item of the stack.
          DN               Duplicate, then pop as output.
            1m             Calls the first line index, retrieving length.
              v            Pop the temp var and push it to the stack.
               $           Switch the top two items of the stack. 
                -          Subtract them.
                 Dv        Duplicate, then pop one as a temp var.
                   D);     If it's zero, exit the loop.
                       VN  Output the global var.

1a/+aL_1+
1a/+       Add .1. This makes sure we don't throw errors on input 0.
    a      Push ten.
     L     Pop the top item as n, push the log base n of second to top.
      _    Make it an int.
       1+  Add 1.

Probieren Sie es online!

Ausführlicher Modus für lols:

save top as permanent variable;
push 0;
save top as permanent variable;
save top as permanent variable;
output top as number;
push all ints between second to top and top;
save top as permanent variable;
save top as temporary variable;
begin recursive area;
remove top;
duplicate top item;
output top as number;
push 1;
goto top method;
save top as temporary variable;
switch the top two items;
subtract top two;
duplicate top item;
save top as temporary variable;
duplicate top item;
if (int) top is not 0;
generic exit;
end recursive area;
save top as permanent variable;
output top as number;
:push 1;
push 10;
divide top two;
add top two;
push 10;
push ln(top);
replace top with int(top);
push 1;
add top two;

Pure Bash, 49

eval printf -va %s {$[$1-1]..0}
echo $1${a::$1}$1

Oder:

Bash + Coreutils, 48

echo $1$(seq $[$1-1] -1 0|tr -d \\n|head -c$1)$1

Retina, 63 Bytes

.+
$0,y$0$*y$0$*x
x
$'_
(x)*_
$#1
+`(y+)y(.)
$2$1
,(\d+).*
$1$`

Es gibt noch einiges an Platz zum Golfen ...

Probieren Sie es online!

MATL , 15 Bytes

VG:qPVXvG:)GVhh

BEARBEITEN (20. Mai 2016) Der Code im Link wird Xzanstelle von verwendetXv , in der Sprache , auf die jüngsten Veränderungen zurückzuführen ist .

Probieren Sie es online!

V                 % input n. Convert to string
 G:               % range [1,2,...,n]
   qP             % convert into [n-1,n-2,...,0]
     VXv          % convert to string, no spaces
        G:)       % take first n characters only
           GV     % push input as a string, again
             hh   % concat horizontally twice    

Java, 93 Bytes

String x(int v){String o=""+v;for(int i=v-1,c=o.length();o.length()-c<v;i--)o+=i;return o+v;}

Ruby, 41 Bytes

->n{[n]*2*(r=0...n).to_a.reverse.join[r]}

Milchstraße 1.6.5 , 27 25 Bytes

I'::%{K£BCH=}<ΩHG<+<;+!

Erläuterung

I                        ` empty the stack
 '::                     ` push 3 copies of the input
    %{K£BCH=}            ` dump digits of reversed range(n) as strings [n-1...0]
             <ΩHG<+<;+   ` select the first nth digits and pad them with n
                      !  ` output

Verwendung

$ ./mw <path-to-code> -i <input-integer>

Perl 6 , 31 Bytes

{$_~([R~] ^$_).substr(0,$_)~$_}

{
  $_ # input
  ~  # string concatenated with
  ([R~] ^$_)    # all numbers up to and excluding the input concatenated in reverse
  .substr(0,$_) # but use only up to the input number of characters
  ~
  $_
}

Verwendung:

for 2,3,7,12,100 {
  say {$_~([R~] ^$_).substr(0,$_)~$_}( $_ )
}

2102
32103
765432107
1211109876543212
1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

Perl, 43 + 2 = 45 Bytes

Ich bin froh, dass ich es nicht benutzt habe reverseund auch nicht substr:

"@{[1-$_..0]}"=~s.\D..gr=~/.{$_}/;$_.=$&.$_

Benötigt die -plFahnen.

$ perl -ple'"@{[1-$_..0]}"=~s.\D..gr=~/.{$_}/;$_.=$&.$_' <<< 12
1211109876543212

Wie es funktioniert:

                                            # '-p' read first line into `$_` and
                                            # auto print at the end
"@{[1-$_..0]}"                              # Create a list from -1-n..0 and
                                            # join it on space. This becomes:
                                            #   "-11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 0"
              =~s.\D..gr                    # Remove all but digits:
                                            #   "11109876543210"
                        =~/.{$_}/;          # Match the n first characters from
                                            # the generated string
                                  $_.=$&.$_ # Append the match and the input

C 130 bis 125 Bytes

#define p(x) printf("%i",x);
i,y,h;f(x){for(i=y=x;(i-=h)>=0;){p(y--)h=floor(log10(y))+1;}if(i+=h)p(h=floor(y/pow(10,i)))p(x)}

Ungolfed Version (mit Erklärung):

#define p(x) printf("%i",x);     // alias to print an integer
i,y,h;                           // helper variables
f(x){                            // function takes an integer x as arg
    for(i=y=x;(i-=h)>=0;){       // i -> the remaining space
                                 // y -> the current descending number
        p(y--)                   // print y (at first y==x)
        h=floor(log10(y))+1;     // h -> the number of digits in y-1
    }                            // do it until there is no more empty space
    if(i+=h)                     // if needs to chop the last number
        p(h=floor(y/pow(10,i)))  // chop and print (implicitly cast of double to int)
    p(x)                         // print x at the end
}                                // end function

Die implizite Umwandlung von double in int h=floor(...)ermöglichte die #define p(x)Speicherung von 5 Byte.

Test auf Ideone.

R, 67 Bytes (als Funktion)

# usage example : f(7)
f=function(i)cat(i,substr(paste((i-1):0,collapse=''),1,i),i,sep='')

R, 63 Bytes (Eingabe von STDIN)

i=scan();cat(i,substr(paste((i-1):0,collapse=''),1,i),i,sep='')

Brainfuck, 265 Bytes

Dies funktioniert nur mit Zahlen <10

Probieren Sie die Golfversion hier aus :

>,------------------------------------------------[->+>+<<]>>[-<<+>>]<[[->+>+<<]>>[-<<+>>]<-]<[<]>[>[>]>+<<[<]>-]>[++++++++++++++++++++++++++++++++++++++++++++++++.>]++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++.

Ungolfed. Probieren Sie es hier aus :

>
,
---------- Convert to base 10
----------
----------
----------
-------- 


[->+>+<<]>>[-<<+>>]<

Fill up the grid
[
[->+>+<<]>>[-<<+>>] //duplicate number like [5][0] -> [5][5]
<-
]

<[<]> Go to cell 1
[

>[>] Scan for zero
> Move one more
+ Add one
<< Move two back
[<] Scan for zero
> Move one forward
- Subtract One
]

> Move one forward into actual numbers
[
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.
>
]
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.
>
++++++++++ Convert to ascii
++++++++++
++++++++++
++++++++++
++++++++
.