Giới thiệu

Ví dụ, hãy lấy số 7. Sau đó chúng tôi nhân đôi cái này và đặt 7 khoảng trắng ở giữa. Chúng tôi nhận được điều này:

7_______7

Sau đó, chúng tôi sẽ giảm số lượng, cho đến khi không còn chỗ trống. Chúng tôi nhận được những điều sau đây cho số 7:

7_______7    
 6543210

Sau đó, chúng tôi chỉ hợp nhất hai người họ, vì vậy:

7_______7    
 6543210  becomes

765432107

Đây sẽ là đầu ra cho N = 7 .

Trông dễ nhỉ? Bây giờ hãy lấy N = 12 . Chúng tôi lại chèn 12 khoảng trắng giữa hai số, cung cấp cho chúng tôi:

12____________12

Sau đó, chúng tôi bắt đầu giảm dần:

12____________12
  111098765432

Và điều này cuối cùng đã cho chúng ta:

1211109876543212

Như bạn có thể thấy, phần giảm dần kết thúc ở 2, không phải ở 0 .

Bài tập

Cho một số nguyên, lớn hơn 1 , xuất ra chuỗi giảm dần như được hiển thị ở trên.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy bài nộp có số byte ít nhất sẽ thắng!

CJam, 11 10 byte

q4*~,W%s<\

Hãy thử trực tuyến. Giả sử có một dòng mới trong đầu vào. (Cảm ơn @ jimmy23013 vì đã lưu một byte.)

Giải trình

Ở cuối mỗi dòng là ngăn xếp trông như thế nào tại điểm đó (sử dụng 4làm ví dụ).

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 byte

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

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một chuỗi. Để gọi nó, gán nó cho một biến.

Chúng tôi xây dựng và tham gia chuỗi giảm dần từ n -1 đến 0 và lấy n đầu tiên ký tự từ chuỗi kết quả. Chúng tôi bổ sung và nối thêm phần này với đầu vào dưới dạng chuỗi.

Xác nhận tất cả các trường hợp kiểm tra trực tuyến

Haskell, 44 byte

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

Ví dụ sử dụng: f 14-> "141312111098765414".

JavaScript (ES6), 55 52 byte

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

Chỉnh sửa: Đã lưu 3 byte nhờ @WashingtonGuedes.

Python 2, 82 72 58 53 byte

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

Hãy thử nó ở đây!

Cảm ơn @Alex đã dạy tôi điều đó repr(x)= `x`tiết kiệm cho tôi một loạt byte!

Bình thường, 11 byte

++Q<jk_UQQQ

Hai phiên bản thay thế, tất cả cũng là 11 byte ( thở dài ):

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

Hãy thử nó ở đây.

Japt, 13 byte

U+Uo w ¬¯U +U

Kiểm tra nó trực tuyến!

Làm thế nào nó hoạt động

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

Thạch, 10 byte

Ȯ’r0DFḣ³Ḍ³

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ȯ’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.

Võng mạc , 98 110

Câu trả lời dài nhất cho đến nay: - /

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

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

Hãy thử trực tuyến.

Vitsy, 35 byte

Vì Vitsy không biết cách tạo ra các chuỗi số, tôi đã triển khai tìm độ dài của số ở vị trí thập phân trong dòng thứ hai.

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

Giải trình:

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.

Hãy thử trực tuyến!

Chế độ dài cho 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;

Bash thuần khiết, 49

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

Hoặc là:

Bash + coreutils, 48

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

Võng mạc, 63 byte

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

Vẫn còn khá nhiều chỗ để chơi gôn ...

Hãy thử trực tuyến!

MATL , 15 byte

VG:qPVXvG:)GVhh

EDIT (ngày 20 tháng 5 năm 2016) Mã trong liên kết sử dụng Xzthay vì Xv, do những thay đổi gần đây trong ngôn ngữ.

Hãy thử trực tuyến!

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 byte

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 byte

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

Dải ngân hà 1.6.5 , 27 25 byte

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

Giải trình

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

Sử dụng

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

Perl 6 , 31 byte

{$_~([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
  ~
  $_
}

Sử dụng:

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

2102
32103
765432107
1211109876543212
1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

Perl, 43 + 2 = 45 byte

Tôi rất vui vì tôi đã không sử dụng reversevà cũng không substr:

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

Yêu cầu các -plcờ.

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

Làm thế nào nó hoạt động:

                                            # '-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 125 byte

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

Phiên bản Ungolfed (có giải thích):

#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

Việc truyền ngầm từ double sang int in h=floor(...)cho phép sử dụng #define p(x)tiết kiệm 5 byte.

Thử nghiệm trên ideone.

R, 67 byte (dưới dạng hàm)

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

R, 63 byte (đầu vào từ STDIN)

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

Brainfuck, 265 byte

Điều này chỉ hoạt động với số <10

Hãy thử phiên bản chơi gôn tại đây :

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

Ung dung. Hãy thử nó ở đây :

>
,
---------- 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
++++++++++
++++++++++
++++++++++
++++++++
.