Đưa ra một chuỗi văn bản, xuất nó dưới dạng 'tháp'.

Mỗi lát của chuỗi (có dạng 0:n) được lặp lại nhiều 5*nlần, do đó, ký tự đầu tiên được lặp lại 5 lần, sau đó lần đầu tiên và 10 lần thứ hai, v.v.

Ví dụ:

'hello' ->

['h']  
['h']  
['h']  
['h']  
['h']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  
['h', 'e', 'l', 'l', 'o']  


'cat' ->

['c']  
['c']  
['c']  
['c']  
['c']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  
['c', 'a', 't']  

Quy tắc:

Bạn có thể xuất ra mỗi lớp dưới dạng một danh sách các ký tự hoặc chỉ một chuỗi chúng được nối với nhau.

R , 48 byte

function(s)substring(s,1,rep(x<-1:nchar(s),x*5))

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

Trả về một danh sách các chuỗi.

05AB1E , 6 byte

ηā5*ÅΓ

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

Trả về một danh sách các chuỗi.

Giải trình

     ÅΓ # Run-length decode...
η       # ... the prefixes of the input
 ā5*и   # ... with the length range multiplied by 5 -- [5, 10, 15, 20, 25]

Haskell , 36 byte

f""=[]
f s=f(init s)++(s<$s<*[1..5])

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

Stax , 8 byte

äï▄;♫├W^

Chạy và gỡ lỗi nó

Giải nén, không được chỉnh sửa và nhận xét, nó trông như thế này.

|[F for each prefix of the input
  i^5*  5*(i+1) where i is the iteration index
  DQ    that many times, peek and print to output

Chạy cái này

TI-Basic (TI-84 Plus CE), 29 byte (27 mã thông báo)

For(A,1,length(Ans
For(B,1,5A
Disp sub(Ans,1,A
End
End

Giải trình:

For(A,1,length(Ans # 9 bytes, 8 tokens: for A from 1 to the length of the string
For(B,1,5A         # 8 bytes, 8 tokens:  5*A times
Disp sub(Ans,1,A   # 9 bytes, 8 tokens:   Print the first A characters of the string 
End                # 2 bytes, 2 tokens:  end loop
End                # 1 byte,  1 token:  end loop

Võng mạc , 15 byte

.
$.>`*5*$($>`¶

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

.

Ghép từng ký tự trong chuỗi.

$.>`*5*$($>`¶

$`là tiền tố của trận đấu. Retina sau đó cung cấp hai bộ sửa đổi, >sửa đổi nó trong bối cảnh của chuỗi giữa các trận đấu liên tiếp, trong khi .mất độ dài. Do đó, chúng tôi bắt đầu với tiền tố của hậu tố, tương đương với kết quả khớp bao gồm tiền tố của nó. Điều này tiết kiệm 2 byte bằng cách sử dụng các kết quả trùng lặp. Sau $(đó kết hợp rằng với một dòng mới, 5*lặp lại nó, và sau đó $.>`lặp lại nó một số lần nữa được đưa ra bởi chiều dài của nó.

Canvas , 6 byte

［³５×＊Ｐ

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

Giải trình:

[      for each prefix
 ³5×     1-indexed counter * 5
    *    repeat the prefix vertically that many times
     P   and print that

Brachylog , 15 byte

a₀ᶠ⟨gj₎{l×₅}⟩ᵐc

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

Trận chung kết ccó thể được gỡ bỏ nếu OP trả lời tích cực cho câu hỏi về việc xuất các mảng 2D.

Khối ,  44  40 byte

i.!?@UBqwW_#/>u...;B^...?qo;;q*n5;oN/./)

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

Điều này vẫn còn rất nhiều no-op, nhưng nó là một chút tốt hơn so với trước đây.

Như một mô tả rất ngắn gọn, một ký tự được lấy từ đầu vào và được kiểm tra EOI (-1), dừng lại nếu có. Các ngăn xếp sau đó được đảo ngược. Lấy số lượng vật phẩm trên ngăn xếp và nhân với -5. Thả nó xuống dưới cùng của ngăn xếp và làm sạch. Vòng qua ngăn xếp, in, cho đến khi một số âm. In dòng mới, tăng số, nếu 0 thả số 0, đảo ngược ngăn xếp và bắt đầu lại từ đầu vào, nếu không thì lặp qua ngăn xếp, in, cho đến khi số âm ...

Hình khối giống như

      i . !
      ? @ U
      B q w
W _ # / > u . . . ; B ^
. . . ? q o ; ; q * n 5
; o N / . / ) . . . . .
      . . .
      . . .
      . . .

Xem nó trực tuyến

Thạch , 8 byte

¹Ƥx'J×5Ɗ

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

J×5x'@¹Ƥ

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

¹Ƥx'Jx'5

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

Đây có khả năng là golf.

JavaScript, 48 46 byte

(cảm ơn @redundancy)

Chỉnh sửa: Tác giả đã làm rõ và câu trả lời này hiện không hợp lệ, nhưng tôi sẽ để nó ở đây không thay đổi.

Trả về một chuỗi các chuỗi nhiều dòng.

s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`)

Thử nó

f = s=>[...s].map(c=>(q+=c).repeat(5*++i),i=q=`
`);

console.log( f("hello").join`` );

Chiến lược tiềm năng:

Nó không giúp tôi nhiều, nhưng có lẽ ai đó có thể sử dụng cái này:

Số lượng ký tự ở dòng (0-index) ilà floor(sqrt(2/5*i+1/4)+1/2), được đánh gôn bằng JavaScript (.4*i+.25)**.5+.5|0.

Đối với một chuỗi chiều dài n, có n*(n+1)*5/2các dòng.

Có lẽ: s=>{for(i=0;(n=(.4*i+++.25)**.5+.5|0)<=s.length;)console.log(s.slice(0,n))}

Python 3 , 43 41 byte

Cảm ơn ovs đã tiết kiệm 2 byte!

Mã

f=lambda x:[*x]and f(x[:-1])+[x]*5*len(x)

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

C (gcc) , 67 byte

i,j;f(char*s){for(i=0;s[i++];)for(j=5*i;j--;)printf("%.*s\n",i,s);}

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

Husk , 8 byte

ΣzoR*5Nḣ

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

Giải trình

Σz(R*5)Nḣ  -- example input: "ab"
        ḣ  -- non-empty prefixes: ["a","ab"]
 z(   )N   -- zip with [1..]
    *5     -- | multiply by 5
   R       -- | replicate
           -- : [["a","a","a","a","a"],["ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]]
Σ          -- concat: ["a","a","a","a","a","ab","ab","ab","ab","ab","ab","ab","ab","ab","ab"]

Haskell, 46 43 42 byte

f s=do n<-[1..length s];take n s<$[1..n*5]

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

Đáng buồn là initsđòi hỏi import Data.List, vì vậy

import Data.List
((<$)<*>(>>[1..5])=<<).inits

với 45 byte của nó dài hơn.

Chỉnh sửa: -1 byte nhờ @BWO.

Than , 11 byte

Ｆ⊕ＬθＥ×⁵ι…θι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Đầu ra bao gồm 0 lần lặp lại của chuỗi con có độ dài bằng không. Giải trình:

   θ          Input string
  Ｌ           Length
 ⊕            Incremented
Ｆ             Loop over implicit range
      ⁵       Literal 5
       ι      Current index
     ×        Multiply
    Ｅ         Map over implicit range
         θ    Input string
          ι   Current index
        …     Chop to length
              Implicitly print each string on its own line

Ruby , 46 42 byte

->s{(1..s.size).map{|i|puts [s[0,i]]*i*5}}

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

PowerShell , 40 20 25 byte

^{Điểm số giảm một nửa nhờ vào mazzy
+5 byte nhờ vào admBorkBork chỉ ra thông số kỹ thuật}

$args|%{,($s+=$_)*5*++$i}

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

Đưa đầu vào thông qua ghép hình. Hoạt động bằng cách xây dựng chuỗi bằng cách thêm ký tự tiếp theo vào chính nó, chuyển đổi nó thành một mảng một phần tử và sau đó lặp lại 5*ilần đó .

MATL , 12 byte

f"G@:)@5*1X"

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

f               % Get the indices of input i.e. range 1 to length(input)
 "              % For loop over that
   G            % Push input string
    @           % Push current loop index
     :          % Range 1 to that
      )         % Index at those positions (substring 1 to i)
       @5*      % Multiply loop index by 5
          1X"   % Repeat the substring that many times rowwise
                % Results collect on the stack and are 
                %  implicitly output at the end

V , 17 byte

òïç$îî/6Ä
Hl$xòxú

Mong đợi đầu vào mà không có dòng mới, và đầu ra với dòng mới hàng đầu không cần thiết.

Tôi có thể xóa mục này nếu đầu vào / đầu ra vi phạm thông số thử thách.

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

21 byte

òïç$îî/6Ä
Hl$xòxíîî/ò

Yêu cầu đầu vào không có dòng mới, nhưng đầu ra chỉ có một dòng mới hàng đầu và dấu.

Giải trình

Các chuỗi con khác nhau được phân tách bằng hai dòng mới liên tiếp để sao chép theo dòng chỉ áp dụng cho các dòng khớp với biểu thức chính quy $\n\n.

Khi lệnh sao chép ( Ä) được cung cấp một số đếm, ví dụ: 6Ä(tôi nghĩ) nó sẽ xóa dòng hiện tại trước khi dán nlần, do đó chỉ xuất hiện để chắp thêm các n - 1bản sao.

ò         | recursively...
 ï        | . append newline
  ç       | . globally search lines matching...
   $îî    | . . compressed version of $\n\n regex
      /6Ä | . . duplicate to create 6 copies
H         | . go to first line
 l        | . move cursor right 1 char
          | . . if current line is 1 char long, errors out of recursion
  $x      | . delete 1 char from end of current line
    ò     | ...end
     x    | delete extra 1-char substring
      ú   | sort so that newlines rise to top

Perl 5 , 29 byte

map{say}($x.=$_)x($y+=5)for@F

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

Perl 6 , 25 byte

{(1..*X*5)RZxx[\~] .comb}

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

Khối mã ẩn danh trả về danh sách các chuỗi.

Nếu bạn muốn nó là mảng 1D, bạn có thể nối thêm flatvào trước như sau:

{flat (1..*X*5)RZxx[\~] .comb}

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

Giải trình:

{                       }  # Anonymous code block
                   .comb   # Split the string into a list of characters
              [\~]         # Triangular reduce the list of characters with the concatenate operator
          RZxx             # Multiply each list by:
 (1..*X*5)                 # A sequence of 5,10,15 etc.

Ngoài ra,

{($+=5)xx*RZxx[\~] .comb}

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

Cũng hoạt động với cùng số lượng byte.

Japt, 10 byte

Đang chờ xác nhận xem định dạng đầu ra có được chấp nhận hay không (+2 byte nếu không).

å+ £T±5 ÇX

Thử nó

Japt , 15 12 byte

-3 byte từ @Shaggy

£¯°Y +R pY*5

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

JavaScript, 76 byte

s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f=s=>{for(i=1;i<=s.length;i++)for(j=0;j<5*i;j++)console.log(s.substring(0,i))}

f("cat")

Forth (gforth) , 48 byte

: f 1+ 1 do i 5 * 0 do dup j type cr loop loop ;

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

Giải trình

1. Vòng lặp từ 1 đến độ dài chuỗi
2. cho mỗi lần lặp:
   1. Vòng lặp (chỉ số vòng lặp 5 *) lần
   2. Chuỗi in từ đầu đến chỉ số vòng ngoài

Giải thích mã

: f                \ start a new word definiton
  1+ 1             \ set up to the loop paramers from 1 to str-length
  do               \ start a counted loop
    i 5 * 0 do     \ start a second counted loop from 0 to 5*index - 1
      dup j        \ duplicate the string address and set the length to the outer index
      type         \ print character from start of string to loop index
      cr           \ output a newline
    loop           \ end inner counted loop
  loop             \ end outer counted loop
;                  \ end word definition

Java 10, 120 92 90 89 byte

s->{for(int j=1,i=1;i<=s.length();i+=++j>i*5?j=1:0)System.out.println(s.substring(0,i));}

-28 byte nhờ @ OlivierGrégoire .
-1 byte nhờ @ceilingcat .

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

Giải trình:

s->{                      // Method with String parameter and no return-type
  for(int j=1,            //  Repeat-integer, starting at 1
      i=1;i<=s.length()   //  Loop `i` in the range [1,length_input]
      ;                   //    After every iteration:
       i+=++j>i*5?        //     Increase `j` by 1 first with `++j`
                          //     If `j` is now larger than `i` multiplied by 5:
           j=1            //      Increase `i` by 1, and reset `j` to 1
          :               //     Else:
           0)             //      Leave `i` the same by increasing it with 0
    System.out.println(   //   Print with trailing newline:
      s.substring(0,i));} //    The prefix of size `i`

Brainfuck , 40 byte

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

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

[Tape: 10 (newline), [characters], 0, rowcounter]

++++++++++> 10 (newline)
,[          for each input character
  >>+++++     add 5 to number of rows
  [           for each row
    <<[<]       go to start
    >[.>]       print newline and all previous characters
    >>+         add 1 to next rowcounter cell
    <-          decrement current rowcounter cell
  ]
  <,          input next character
]

APL (Dyalog Unicode) , 14 byte ^SBCS

{↑(5×⍳≢⍵)/,\⍵}

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

Bài đăng apl đầu tiên của tôi vì vậy xin vui lòng cho tôi biết nếu bạn có bất kỳ đề xuất nào

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

{↑(5×⍳≢⍵)/,\⍵}
          ,\⍵  - Prefixes of the input
         /      - Repeated
     ⍳≢⍵        - By a list of indices the same length as the input
   5×           - Times 5
 ↑              - Separate into rows         

Ruby , 37 byte

f=->s{s[0]?f[s.chop]+[s]*s.size*5:[]}

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