Nhiệm vụ chính

Nhiệm vụ của bạn là in ra các số nguyên theo thứ tự giảm dần, bắt đầu từ 1 và tăng dần khi bạn tiếp tục nhấn 1 lần nữa, cho đến khi đạt được đầu vào đã cho, sau đó, in ra phần còn lại cho đến khi bạn nhấn lại 1 lần nữa. Ví dụ với đầu vào 6:

1
21
321
4321
54321
654321
Without newlines (valid output):
121321432154321654321

Đầu vào

Mã của bạn có thể lấy bất kỳ loại đầu vào nào (đồ họa, STDIN) dưới dạng số nguyên hoặc số.

Đầu ra

Mã của bạn sẽ xuất chuỗi được mô tả ở trên, cho đến khi đạt được số đầu vào, sau đó kết thúc để xuất cho đến khi đạt đến 1 lần nữa. Đầu ra có thể là bất cứ thứ gì, do đó, số, chuỗi, số nguyên hoặc đầu ra đồ họa. Cần phải in ra một số duy nhất (không có dòng mới nếu đó là một chuỗi). Đầu ra của bạn có thể được giới thiệu và xuất hiện với bao nhiêu ký tự bạn cần (ví dụ []).

Vì có một số hiểu lầm, đây là mô hình regex bạn có thể thử kết quả đầu ra của mình.

^(\D*(\d)+\D*)$

Quy tắc

• Đầu ra phải là một số đầy đủ, không bị chia tách bởi bất cứ điều gì, thậm chí không phải là dòng mới.
• Thuật toán không nên kiểm tra phiên bản đầu tiên của N xuất hiện theo bất kỳ cách nào (ví dụ: 21trong 121321), mà thay vào đó, ví dụ đầu tiên của N là số thực tế.
• Một dòng mới duy nhất được cho phép.
• Việc xử lý đầu vào tiêu cực hoàn toàn là sự lựa chọn của bạn, số âm không phải là trường hợp bạn nên kiểm tra.

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

Input: 6
Output: 121321432154321654321


Input: 1
Output: 1

Input: 26
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321222120191817161514131211109876543212322212019181716151413121110987654321242322212019181716151413121110987654321252423222120191817161514131211109876543212625242322212019181716151413121110987654321

Input: 0
Output: 0, Empty, or Error

Input: 21
Output: 121321432154321654321765432187654321987654321109876543211110987654321121110987654321131211109876543211413121110987654321151413121110987654321161514131211109876543211716151413121110987654321181716151413121110987654321191817161514131211109876543212019181716151413121110987654321212019181716151413121110987654321

Người chiến thắng

Người chiến thắng đã được chọn! Đó là câu trả lời của ErikGolfer với 5 byte ấn tượng ! Xin chúc mừng!

Thạch , 5 byte

RRUVV

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

Công thức không phải của tôi.

Tôi nghi ngờ có quá nhiều thứ đang diễn ra ở đây ...

[TRẢ LỜI CHẤP NHẬN] Tôi đã trao 5 đại diện cho Dennis, nhưng đây không phải là Trao đổi danh tiếng. Dennis chỉ cho tôi VVhành vi. Thật ngạc nhiên, nó ngắn hơn 05AB1E.

05AB1E , 6 byte

L€LíJJ

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

Giải trình

Ví dụ đầu vào 4

L       # range [1 ... input]
        # STACK: [1,2,3,4]
 €L     # map: range
        # STACK: [[1],[1,2],[1,2,3],[1,2,3,4]]
   í    # reverse each
        # STACK: [[1],[2,1],[3,2,1],[4,3,2,1]]
    J   # join inner lists
        # STACK: ['1','21','321','4321']
     J  # join list
        # OUTPUT: 1213214321

JavaScript (ES6), 37 byte

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

Bản giới thiệu

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

console.log(f(6))

Phương pháp thay thế cho n <10, 34 byte (không cạnh tranh)

f=(n,s='1')=>--n?s+f(n,++s[0]+s):s

Trong JavaScript, chuỗi là bất biến. Do đó, không thể thay đổi nội dung của ký tự thứ N của chuỗi sbằng cách gán giá trị mới cho s[N].

Tuy nhiên, biểu thức ++s[N]là hợp lệ và được đánh giá như người ta mong đợi, ngay cả khi chuỗi vẫn không thay đổi. Ví dụ:

++"1"[0] // equals 2

Và bằng cách mở rộng:

s = "21"
++s[0] + s // equals "321"

V, 29 28 27 23 19 17 16 byte

8 byte được lưu nhờ @DJMcMayhem

3 byte được lưu nhờ vào @ nmjcman101

"apÀ­ñÄòy$jpkgJ

Nhân vật ẩn:

"apÀ<C-x>ñÄ<C-x>òy$jpkgJ

C-x là Ctrl + x.

Hãy thử trực tuyến! nhận đầu vào thông qua các đối số dòng lệnh

Hexdump:

0000000: 2261 70c0 adf1 c418 f279 246a 706b 674a  "ap......y$jpkgJ

Giải trình

"ap            Paste the argument
À<C-x>         Argument minus 1 times (so that we exclude the 0)
ñ ... ò        Loop (for some weird reason the ò closes the ñ)
Ä<C-x>         paste current line above and decrement it

Bây giờ nó trông giống như:

1
2
...
n

tiếp tục ...

ò             recursively do (until a breaking error)
y$             yank this line
  jp           paste it down
    kgJ        go up and join
              implicit ò end

GIF (lỗi thời)

(cho tranh luận 6)

C #, 72 69 65 byte

n=>{for(int i=0,j;i<n;)for(j=++i;j>0;)System.Console.Write(j--);}

Nếu đầu ra chỉ có thể được trả về chứ không phải được ghi vào bàn điều khiển

C #, 71 68 64 byte

n=>{var s="";for(int i=0,j;i<n;)for(j=++i;j>0;)s+=j--;return s;}

Cảm ơn @VisualMelon đã lưu rất nhiều byte

Kiểm tra nó ở đây (một cách hài hước trình biên dịch trực tuyến phá vỡ bất kỳ số nào trên 420)

Bash tinh khiết, 34

eval eval printf %s \\{{1..$1}..1}

Hai cấp độ mở rộng niềng răng. Với đầu vào 6, cấp độ đầu tiên mở rộng đến {1..1} {2..1} {3..1} {4..1} {5..1} {6..1}. Điều này sau đó mở rộng ra 1 2 1 3 2 1 4 3 2 1 5 4 3 2 1 6 5 4 3 2 1, được kết hợp thành một chuỗi với printf %s. evalYêu cầu ở cả hai cấp độ mở rộng - đối với cấp đầu tiên để $1tham số được mở rộng trước và cho cấp thứ hai để mở rộng sau cấp thứ nhất.

Dùng thử trực tuyến

Perl, 21 byte

Sử dụng -Emà không mất thêm chi phí.

say map$}=$_.$},1..<>

Sử dụng

perl -E 'say map$}=$_.$},1..<>' <<< 6
121321432154321654321

Bình thường, 7 byte

jks}R1S

Một chương trình lấy đầu vào của một số nguyên và in kết quả.

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

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

jks}R1S   Program. Input: Q
jks}R1SQ  Implicit input fill
    R     Map
      SQ  over [1, 2, 3, 4, ..., Q] with i:
   } 1     Yield [i, i-1, i-2, i-3, ..., 1]
  s       Merge
jk        Join
          Implicitly print

GeoGebra , 67 byte

1
InputBox[a]
Sum[Join[Sequence[Sequence[Text[j],j,i,1,-1],i,1,a]]]

Mỗi dòng được nhập riêng vào thanh đầu vào. Đầu vào được lấy từ một hộp đầu vào.

Đây là một gif của việc thực hiện:

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

Nhập 1ngầm định gán acho 1và InputBoxlệnh liên kết một hộp đầu vào với a. Sau đó, với mỗi itrong {1, 2, 3, ..., a}, danh sách {i, i-1, i-2, ..., 1}được tạo bằng Sequencelệnh và mỗi jtrong danh sách đó được chuyển đổi thành một chuỗi bằng cách sử dụng Text. Cuối cùng, Joinhợp nhất tất cả các danh sách và Sumnối tất cả các thành phần với một đối tượng văn bản, được hiển thị.

Python 2, 51 byte

r=s=''
n=0
exec'n+=1;s=`n`+s;r+=s;'*input()
print r

Võng mạc , 26 22 byte

Số lượng byte giả định mã hóa ISO 8859-1.

.+
$*

$`¶
1
$.%'
0?¶

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

Giải trình

.+
$*

Chuyển đổi đầu vào thành unary.

$`¶

Tại mỗi vị trí, chèn tiền tố cho đến thời điểm đó, cũng như nguồn cấp dữ liệu. Điều này tạo ra một phạm vi unary từ 2đến n+1, một giá trị trên mỗi dòng.

1
$.%'

Thay thế mỗi 1bằng số lượng ký tự sau nó trên cùng một dòng. Điều này biến một cái gì đó như 11111thành 43210.

0?¶

Loại bỏ tất cả các nguồn cấp dữ liệu và các số không trước chúng.

Ngôn ngữ GameMaker, 65 byte

b=""for(i=1;i<=argument0;i++){c=i while(j)b+=string(c--)}return b

APL, 10 byte

∊⍕¨∘⌽∘⍳¨∘⍳

Ví dụ:

      (∊⍕¨∘⌽∘⍳¨∘⍳)6
121321432154321654321

Giải trình:

• ⍳: lấy các số từ 1 đến N.
• ⍳¨∘: cho mỗi số đó, lấy các số từ 1 đến N.
• ⌽∘: đảo ngược danh sách đó
• ⍕¨∘: lấy biểu diễn ký tự của từng mục (để nó không xuất ra các số có khoảng trắng ở giữa)
• ∊: làm phẳng mảng kết quả

Python 2, 71 68 byte

Tôi cá là một giải pháp đệ quy có thể ngắn hơn, nhưng tôi gặp khó khăn khi biến nó thành một.

n=input()
i=0
o=""
while i<n:
    i+=1;j=i
    while j:o+=`j`;j-=1
print o

Dùng thử trực tuyến

Thực tế 8 byte

RR♂RΣRεj

Lần đầu tiên đăng một câu trả lời trong thực tế để nó có thể được chơi golf.

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

Program takes implicit input, implicit print at EOF
R           Takes the input and creates a range (1, input)   
                STACK = [1,2,..,n]
 R          Reverse the top stack item (our range)
                STACK = [n,..,2,1]
  ♂R        For each item in our range, create a range (1, rangeitem)
                STACK = [[1,2,..,n], .., [1,2], [1]]
    Σ       Stitch the items of the list together
                STACK = [n,..,1,2,3,1,2,1]
     R      Reverse the top stack item again (our answer)
                STACK = [1,2,1,3,2,1,..n]
      εj    Create an empty string and append each item from the list to it.
            (turns non string items into strings)

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

Brachylog , 8 byte

yb@[rcw\

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

Giải trình

yb         The list [1, ..., Input]
  @[       Take a prefix of that list
    rc     Reverse it and concatenate into an integer
      w    Write to STDOUT
       \   Backtrack: try another prefix

Perl 6 , 22 byte

{[~] flat [\R,] 1..$_}

Một lambda trả về một chuỗi.

( Dùng thử trực tuyến. )

Giải trình:

• 1..$_: Phạm vi số nguyên ... (1 2 3 4)
• [,] 1..$_: Giảm ("gấp") so với toán tử dấu phẩy ... (1 2 3 4)
• [\,] 1..$_: Với kết quả trung gian ( giảm tam giác ) ...((1) (1 2) (1 2 3) (1 2 3 4))
• [\R,] 1..$_: Áp dụng toán tử meta đảo ngược cho dấu phẩy ...((1) (2 1) (3 2 1) (4 3 2 1))
• [~] flat ...: Xóa danh sách lồng nhau và gập lên toán tử concat chuỗi ... 1213214321

Haskell, 35 byte

f x=[1..x]>>= \y->[y,y-1..1]>>=show

Ví dụ sử dụng: f 6-> "121321432154321654321".

Đối với tất cả các số xtrong 1 ... xmột danh sách x,x-1, ... ,1, hãy biến các số thành một chuỗi và nối chúng thành một chuỗi. Một lần nữa, nối các chuỗi đó thành một chuỗi.

C89, 54 byte

i,j;f(n){for(i=1;j<=n;j=i++)while(j)printf("%d",j--);}

56 -2 = 54 nhờ ErikGolfer!

Python 3, 87 92 83 74 byte

lambda n:"".join(["".join([str(i)for i in range(1,k)][::-1])for k in range(1,n+2)])

Câu trả lời ngắn hơn sử dụng đệ quy:

f=lambda n:f(n-1)+"".join([str(i)for i in range(1,n+1)][::-1])if n>0else""

Có thể không phải là ngắn nhất nhưng nó chỉ được thực hiện với sự hiểu biết danh sách của Python!

(Đã chỉnh sửa để thêm chức năng in và xóa \ n)

(Đã chỉnh sửa để xóa chức năng in và thay đổi n + 1, k + 1 thành n, k + 2)

Bình thường, 8 byte

jks_M._S

Giải trình

jks_M._SQ   Implicit input
       SQ   Get the range [1, 2, ..., N]
     ._     Get each prefix
   _M       Reverse each prefix
jks         Join everything as a string

05AB1E , 6 byte

LR.sJJ

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

Toán học, 36 byte

ToString/@(""<>Range[Range@#,1,-1])&

Ném một loạt các cảnh báo có thể được bỏ qua một cách an toàn.

Giải trình

Sử dụng đầu vào 5làm ví dụ:

Range@#

Tạo ra một phạm vi {1, 2, 3, 4, 5}.

Range[...,1,-1]

Rangecó thể liệt kê để chúng tôi có thể cung cấp cho nó một danh sách cho bất kỳ đối số nào của nó và nó sẽ tự động xâu chuỗi đối số đó. Vì vậy, điều này cung cấp cho chúng tôi một loạt các danh sách đảo ngược:

{{1}, {2, 1}, {3, 2, 1}, {4, 3, 2, 1}, {5, 4, 3, 2, 1}}

Kế tiếp:

(""<>...)

Điều này tham gia danh sách lồng nhau với chuỗi rỗng. Vì danh sách lồng nhau không thực sự chứa bất kỳ chuỗi nào, nên nó không thể thực sự tham gia các giá trị (đó là nơi tạo ra các cảnh báo), nhưng ""<>có tác dụng phụ là làm phẳng danh sách. Vì vậy, điều này mang lại cho chúng tôi

1 <> 2 <> 1 <> 3 <> 2 <> 1 <> 4 <> 3 <> 2 <> 1 <> 5 <> 4 <> 3 <> 2 <> 1

Bây giờ đến tính năng tuyệt đẹp của Mathematica mà Mapkhông quan tâm đến cấu trúc mà nó ánh xạ. Bạn thường áp dụng nó vào một danh sách, nhưng nó hoạt động với bất kỳ đầu nào. f /@ h[a, b, c]chỉ đơn giản là cung cấp cho bạn h[f[a], f[b], f[c]]. Trong trường hợp của chúng tôi, phần đầu là StringJoinvà các giá trị là các số nguyên.

ToString/@...

Vì vậy, điều này chỉ đơn giản là biến các số nguyên thành chuỗi. Tại thời điểm đó StringJoin[...]biết phải làm gì với chúng và nối tất cả chúng thành một chuỗi:

"121321432154321"

GolfScript , 14 byte

~,{),{)}%-1%}%

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

Tất nhiên, phương pháp thông thường, nhưng đây là GolfScript.

Giải thích cho đoạn mã VAST này :

~,{),{)}%-1%}% # Code
               # Initial stack.      ["n"]
~              # Eval ToS.           [n]
 ,             # ToS' lowered range. [[0..n)]
  {),{)}%-1%}  # Block. 1 argument.  [a]
   )           # Increment.          [a+1]
    ,          # Range.              [[0..a)]
     {)}       # Block. 1 argument.  [b]
      )        # Increment.          [b+1]
        %      # Map.                [[1..a]]
         -1    # Integer. -1         [[1..a] -1]
           %   # Each nth element.   [[a..1]]
             % # Map.                [[[1],[2,1],...,[n..1]]]
               # Implicit output.    121...n..1

Lưu ý rằng đầu ra là một số duy nhất. Trailing \n.

R, 38 33 44 byte

if((n=scan())>0)for(i in 1:n)cat(i:1,sep="")

Đưa đầu vào vào STDIN và lặp từ 1 đến n, tạo chuỗi i thành 1 cho mỗi bước và in nó.

Chỉnh sửa: được thay thế seq(i,1)bằng cách i:1lưu 5 byte và cho biết lý do tại sao tôi không nên chơi gôn trong các cuộc họp.

MATL , 14 11 byte

:"@:P]v!VXz

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

Giải trình

:      % Input N implicitly. Push range [1 2 ...N]
"      % For each k in [1 2 ...N]
  @:   %   Push range [1 2 ... k]
  P    %   Reverse
]      % End
v!     % Concatenate all arrays horizontally
V      % Convert to string
Xz     % Remove spaces. Display implicitly

Brainfuck, 17 byte

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

Giải trình

>           keep the first cell at 0
 ,          input of the decimal number into the cell
  [>        start a conditionnal loop and go to the next cell
   [+.>]    while it don't find 0, increment each cells and output the value
    +.      increment the new cell and output
     [<]    go to the first cell
      >-]   decrement the second cell and restart

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

Python , 63 57 59 byte

Một giải pháp đệ quy hoạt động trong cả Python 2 và 3. Điều này có thể được đánh gôn hơn nữa. Gợi ý chơi golf chào mừng! Hãy thử trực tuyến!

Chỉnh sửa: -6 byte nhờ Jonathan Allan. +2 byte với lời cảm ơn đến mbomb007 vì đã chỉ ra một vấn đề với câu trả lời của tôi.

f=lambda n:n and f(n-1)+"".join(map(str,range(n,0,-1)))or""

Ungolfing

def f(n):
    s = ""
    for i in range(n+1):
        m = map(str, range(n, 0, -1))
        s += "".join(m)
    return s

PHP, 35 34 33 byte

Đã lưu một byte vì tôi đã nhầm, cảm ơn Titus! Và khác!

while($i++<$argv[1])echo$s=$i.$s;

Chạy từ dòng lệnh với -r.

Câu trả lời khá đơn giản, các vòng lặp từ 1 đến đầu vào của chúng tôi n, xử lý số ở đầu chuỗi và in ra.

CJam, 13 byte

ri,:){,:)W%}%

thông dịch viên