소개

예를 들어, 숫자를 보자 7. 그런 다음 이것을 복제하고 사이에 7 개의 공백을 넣습니다. 우리는 이것을 얻습니다 :

7_______7

그 후 공백이 없어 질 때까지 숫자를 줄이려고합니다. 우리는 숫자 7에 대해 다음을 얻습니다.

7_______7    
 6543210

그런 다음 둘 중 하나만 병합하면됩니다.

7_______7    
 6543210  becomes

765432107

이것은 N = 7에 대한 출력입니다 .

쉽게 보입니까? 이제 N = 12를 봅시다 . 두 숫자 사이에 12 개의 공백을 다시 삽입하면 다음과 같이됩니다.

12____________12

그런 다음 감소를 시작합니다.

12____________12
  111098765432

그리고 이것은 마침내 우리에게줍니다 :

1211109876543212

보다시피, 내림차순 부분 은 0이 아니라 2에서 끝납니다 .

직무

1보다 큰 정수가 주어지면 위와 같이 내림차순을 출력합니다.

테스트 사례

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

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

CJam, 11 10 바이트

q4*~,W%s<\

온라인으로 사용해보십시오. 입력에 후행 줄 바꿈이 있다고 가정합니다. (바이트를 저장해 준 @ jimmy23013에게 감사합니다.)

설명

각 줄의 끝에 스택이 그 시점에서 보이는 모습이 있습니다 ( 4예를 들어 사용).

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]

줄리아, 30 바이트

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

이것은 정수를 허용하고 문자열을 반환하는 익명 함수입니다. 호출하려면 변수에 지정하십시오.

우리는 n -1에서 0 까지 내림차순을 구성하고 결합 하고 결과 문자열에서 처음 n 자를 가져옵니다. 입력 앞에 문자열을 추가하고 추가합니다.

모든 테스트 사례를 온라인으로 확인

하스켈, 44 바이트

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

사용 예 : f 14-> "141312111098765414".

자바 스크립트 (ES6), 55 52 바이트

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

편집 : @WashingtonGuedes 덕분에 3 바이트가 절약되었습니다.

파이썬 2, 82 72 58 53 바이트

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

여기 사용해보십시오!

저를 가르치는 @ 알렉스 덕분에 repr(x)= `x`나에게 바이트의 무리를 저장!

Pyth, 11 바이트

++Q<jk_UQQQ

11 바이트 ( sigh ) 인 두 가지 대체 버전 :

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

여기에서 시도하십시오.

apt, 13 바이트

U+Uo w ¬¯U +U

온라인으로 테스트하십시오!

작동 원리

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

젤리, 10 바이트

Ȯ’r0DFḣ³Ḍ³

온라인으로 사용해보십시오!

작동 원리

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

망막 , 98 (110)

가장 긴 답변 :-/

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

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

온라인으로 사용해보십시오.

Vitsy, 35 바이트

Vitsy는 숫자로 문자열을 만드는 방법을 알지 못하므로 두 번째 줄에서 소수점 이하 자릿수를 찾는 것을 구현했습니다.

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

설명:

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.

온라인으로 사용해보십시오!

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;

퓨어 배쉬, 49

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

또는:

배쉬 + 코어 유틸리티, 48

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

레티 나, 63 바이트

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

여전히 골프를 할 여지가 꽤 있습니다 ...

온라인으로 사용해보십시오!

MATL , 15 바이트

VG:qPVXvG:)GVhh

편집 (2016 년 5 월 20 일) 링크의 코드는 최근 언어 변경으로 인해 Xz대신 Xv에을 (를) 사용 합니다.

온라인으로 사용해보십시오!

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    

자바, 93 바이트

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

루비, 41 바이트

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

은하수 1.6.5 , 27 25 바이트

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

설명

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

용법

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

펄 6 , 31 바이트

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

용법:

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

2102
32103
765432107
1211109876543212
1009998979695949392919089888786858483828180797877767574737271706968676665646362616059585756555453525150100

펄, 43 + 2 = 45 바이트

내가 사용하지 않았다 행복 해요 reverse그리고 어느 쪽도 substr:

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

-pl플래그가 필요합니다 .

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

작동 방식 :

                                            # '-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 바이트

#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 버전 (설명 포함) :

#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

내재적으로 double에서 int로 캐스트 h=floor(...)하면 #define p(x)5 바이트 를 절약 할 수 있습니다 .

이데온에서 테스트하십시오.

R, 67 바이트 (기능)

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

R, 63 바이트 (STDIN에서 입력)

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

Brainfuck, 265 바이트

이것은 숫자 <10에서만 작동합니다.

골프 버전을 여기에서 보십시오 :

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

언 골프. 여기에서 보십시오 :

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