Cho một chuỗi ASCII, xuất ra các hậu tố bùng nổ của nó. Ví dụ: nếu chuỗi là abcde, có 5 hậu tố, được sắp xếp dài nhất đến ngắn nhất:

abcde
bcde
cde
de
e

Mỗi hậu tố sau đó được phát nổ , có nghĩa là mỗi ký tự được sao chép nhiều lần như vị trí một chỉ mục của nó trong hậu tố đó. Ví dụ: phát nổ các hậu tố của abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

Nhìn chung, các hậu tố bùng nổ abcdelà

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

Quy tắc

• Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng.
• Đầu vào sẽ bao gồm các ký tự ASCII có thể in được. (Điều này không bao gồm các dòng mới nhưng bao gồm khoảng trắng.)
• Đầu ra sẽ có mỗi chuỗi trên một dòng riêng biệt.
• Không gian lưu trữ được cho phép trên mỗi dòng và có thể có thêm một dòng mới ở cuối.

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

''

'a'
a

'bc'
bcc
c

'xyz'
xyyzzz
yzz
z

'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

Thạch , 5 byte

ṫJxJY

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

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

ṫJxJY  Main link. Argument: s (string)

 J     Indices; yield I := [1, ..., len(s)].
ṫ      Tail; get the suffixes of s starting at indices [1, ..., len(s)].
   J   Indices; yield I again.
  x    Repeat. The atom 'x' vectorizes at depth 1 (1D arrays of numbers/characters)
       in its arguments. This way, each suffix t gets repeated I times, meaning
       that the first character of t is repeated once, the second twice, etc.
       If left and right argument have different lengths, the longer one is
       truncated, so I can safely be applied to all suffixes.
    Y  Join, separating by linefeeds.

J, 22 12 8 byte

Nhờ dặm cho tiết kiệm 14 byte!

(#~#\)\.

Bây giờ đây là một giải pháp thực sự tốt đẹp. Khá ngắn gọn, quá.

Đây là hook #~#\được áp dụng cho hậu tố ( \.) của đầu vào. Móc, khi được gọi trên đầu vào y, được phân tách như vậy:

(#~#\) y
y #~ #\ y

Dưới đây là một số kết quả trung gian:

   ]s =: 's p a c e'
s p a c e
   #\ s
1 2 3 4 5 6 7 8 9
   (quote) s
's p a c e'
   (quote;#)\ s
+-----------+-+
|'s'        |1|
+-----------+-+
|'s '       |2|
+-----------+-+
|'s p'      |3|
+-----------+-+
|'s p '     |4|
+-----------+-+
|'s p a'    |5|
+-----------+-+
|'s p a '   |6|
+-----------+-+
|'s p a c'  |7|
+-----------+-+
|'s p a c ' |8|
+-----------+-+
|'s p a c e'|9|
+-----------+-+
   1 2 3 # '123'
122333
   3 3 3 # '123'
111222333
   ]\. s
s p a c e
 p a c e
p a c e
 a c e
a c e
 c e
c e
 e
e
   quote\. s
's p a c e'
' p a c e'
'p a c e'
' a c e'
'a c e'
' c e'
'c e'
' e'
'e'
   (#~#\) s
s  ppp    aaaaa      ccccccc        eeeeeeeee
   (#~#\)\. s
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

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

   f =: (#~#\)\.
   f
(#~ #\)\.
   f ''
   f 'a'
a
   f 'bc'
bcc
c
   f 'xyz'
xyyzzz
yzz
z
   f 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f
   f 's p a c e'
s  ppp    aaaaa      ccccccc        eeeeeeeee
 pp   aaaa     cccccc       eeeeeeee
p  aaa    ccccc      eeeeeee
 aa   cccc     eeeeee
a  ccc    eeeee
 cc   eeee
c  eee
 ee
e

   ]tc =: <;._1 '|' , '|a|bc|xyz|code-golf|s p a c e'
++-+--+---+---------+---------+
||a|bc|xyz|code-golf|s p a c e|
++-+--+---+---------+---------+
   ,. f &. > tc
+---------------------------------------------+
+---------------------------------------------+
|a                                            |
+---------------------------------------------+
|bcc                                          |
|c                                            |
+---------------------------------------------+
|xyyzzz                                       |
|yzz                                          |
|z                                            |
+---------------------------------------------+
|coodddeeee-----ggggggooooooollllllllfffffffff|
|oddeee----gggggoooooolllllllffffffff         |
|dee---ggggooooollllllfffffff                 |
|e--gggoooolllllffffff                        |
|-ggooollllfffff                              |
|goolllffff                                   |
|ollfff                                       |
|lff                                          |
|f                                            |
+---------------------------------------------+
|s  ppp    aaaaa      ccccccc        eeeeeeeee|
| pp   aaaa     cccccc       eeeeeeee         |
|p  aaa    ccccc      eeeeeee                 |
| aa   cccc     eeeeee                        |
|a  ccc    eeeee                              |
| cc   eeee                                   |
|c  eee                                       |
| ee                                          |
|e                                            |
+---------------------------------------------+

Python, 61 byte

f=lambda s,i=0:s[i:]and-~i*s[i]+f(s,i+1)or s and'\n'+f(s[1:])

Phương án 63:

f=lambda s,b=1:s and f(s[:-1],0)+s[-1]*len(s)+b*('\n'+f(s[1:]))

Python 3, 91 68 65 byte

def f(s):f(s[1:print(''.join(i*c for i,c in enumerate(s[0]+s)))])

Chấm dứt với một lỗi sau khi in đầu ra mong muốn. Kiểm tra nó trên Ideone .

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

Trước khi f có thể tự gọi đệ quy, các chỉ số s[1:...]phải được tính toán.

Đầu tiên enumerate(s[0]+s)mang lại tất cả các cặp (i, c) của các ký tự c của s - với ký tự đầu tiên được nhân đôi - và các chỉ số tương ứng i . Chuẩn bị s[0]phục vụ hai mục đích ở đây.

• Ký tự đầu tiên của s phải được lặp lại một lần, nhưng chỉ số đầu tiên là 0 .

• Khi tất cả các ký tự đã được xử lý, s[0]sẽ tăng IndexError , khiến f chấm dứt với một lỗi thay vì in các dòng mới cho đến khi đạt đến giới hạn đệ quy.

''.join(i*c for i,c in ...)xây dựng một chuỗi phẳng của mỗi c lặp đi lặp lại i lần, printlặp lại với STDOUT.

Cuối cùng, vì printtrả về Không và s[1:None]chỉ đơn giản s[1:], cuộc gọi đệ quy f(s[1:...])lặp lại quy trình trên cho s mà không có ký tự đầu tiên.

Perl 6 , 38 byte

m:ex/.+$/.map:{put [~] .comb Zx 1..*}

37 byte + 1 cho -nchuyển đổi dòng lệnh

Thí dụ:

$ perl6 -ne 'm:ex/.+$/.map:{put [~] .comb Zx 1..*}' <<< 'code-golf'
coodddeeee-----ggggggooooooollllllllfffffffff
oddeee----gggggoooooolllllllffffffff
dee---ggggooooollllllfffffff
e--gggoooolllllffffff
-ggooollllfffff
goolllffff
ollfff
lff
f

Mở rộng:

# -n command line switch takes each input line and places it in ｢$_｣

# You can think of it as surrounding the whole program with a for loop
# like this:
for lines() {

  # match
  m
  :exhaustive # every possible way
  / .+ $/     # at least one character, followed by the end of the string

  .map:

  {
    put           # print with newline
      [~]         # reduce using string concatenation ( don't add spaces between elements )
        .comb     # split into individual chars
        Z[x]      # zip using string repetition operator
        1 .. *    # 1,2,3,4 ... Inf
  }

}

Brachylog , 17 byte

@]Elyk:Erz:jac@w\

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

Giải trình

@]E                 E is a suffix of the Input
   lyk              The list [0, ..., length(E) - 1]
      :Erz          The list [[0th char of E, 0], ..., [Last char of E, length(E) - 1]]
          :ja       For all elements of that list, concatenate the Ith char I times to itself
             c      Concatenate the list into a string
              @w    Write followed by a line break
                \   False: backtrack to another suffix of the Input

05AB1E , 13 byte

.sRvyvyN>×}J,

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

Giải trình

.s              # push list of suffixes of input
  R             # reverse the list
   vy           # for each string
     vy   }     # for each char in string
       N>×      # repeat it index+1 times
           J,   # join and print with newline

CJam , 14 byte

Sl+{_eee~n1>}h

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

Giải trình

Sl+   e# Read input and prepend a space.
{     e# While the string is non-empty...
  _   e#   Make a copy.
  ee  e#   Enumerate. Gives, e.g. [[0 ' ] [1 'a] [2 'b] [3 'c]].
  e~  e#   Run-length decode. Gives "abbccc".
  n   e#   Print with trailing linefeed.
  1>  e#   Discard first character.
}h

C #, 101 byte

f=s=>{var r="\n";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+f(s.Substring(1));};

Hàm ẩn danh đệ quy, cũng in một dòng mới hàng đầu. Nếu dòng mới hàng đầu không được phép, 3 byte thêm sẽ biến nó thành dòng mới theo sau:

f=s=>{var r="";for(int i=0;i<s.Length;)r+=new string(s[i],++i);return""==s?r:r+"\n"+f(s.Substring(1));};

Chương trình đầy đủ với phương pháp vô căn cứ và các trường hợp thử nghiệm:

using System;

namespace ExplodedSuffixes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string, string> f = null;
            f = s =>
            {
                var r = "\n";
                for (int i = 0; i < s.Length; )
                    r += new string(s[i], ++i);
                return "" == s ? r : r + f(s.Substring(1));
            };

            // test cases:
            string x = "abcde";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "a";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "bc";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "xyz";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "code-golf";
            Console.WriteLine("\'" + x + "\'" + f(x));
            x = "s p a c e";
            Console.WriteLine("\'" + x + "\'" + f(x));
        }
    }
}

Haskell, 48 byte

e=map(concat.zipWith replicate[1..]).scanr(:)[] 

được giao thoa bởi bất kỳ

ghc exploded_suffixes.hs -e 'e"abcde"'
ghc exploded_suffixes.hs -e 'mapM_ putStrLn.e=<<getLine' <<<code-golf
ghc exploded_suffixes.hs -e 'Control.Monad.forever$putStr.unlines.e=<<getLine'

Perl, 36 + 1 ( -n) = 37 byte

/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/

Cần -nvà -E(hoặc -M5.010) để chạy:

perl -nE '/.+$(?{$.=say$&=~s%.%$&x$.++%rge})^/' <<< "code-golf"

Lưu ý rằng nó chỉ hoạt động trên một phiên bản mỗi lần bạn chạy nó (bởi vì nó sử dụng biến $.được tăng lên mỗi khi một dòng được đọc, vì vậy nó giữ1 chỉ lần đầu tiên khi một dòng được đọc). (Nhưng không có vấn đề gì ở đây, chỉ cần ^Dchạy lại nó!)

Võng mạc , 31 byte

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

M&!`.+

$.%`$*»
%+r`»($|.)
$1$1

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

Java, 150 127 byte

Chỉnh sửa:

• -23 byte tắt. Cảm ơn @Kevin Cruijssen

Bắn tỉa:

f->{String s[]=f.split(""),o="";int i=-1,j,l=s.length;for(;++i<l;)for(j=-2;++j<i;o+=s[i]);return l<1?"":o+"\n"+f.substring(1);}

Ung dung:

public static String explodeSuff(String suff){
  char [] s = suff.toCharArray();
  String out = "";
  if(s.length==0)return "";
  for(int i=-1;++i<s.length;){
    for(int j=-2;++j<i;){
      out+=s[i];
    }
  }
  return out+"\n"+suff.subString(1);
}

Vợt 184 byte

(let p((l(string->list s))(ol'()))(cond[(null? l)(display(list->string(flatten ol)))]
[else(p(cdr l)(append ol(list #\newline)(for/list((i l)(n(length l)))(for/list((j(+ 1 n)))i))))]))

Ung dung:

(define(f s)
 (let loop((l(string->list s))
             (outl '()))
    (cond
      [(null? l)
       (display
        (list->string
         (flatten outl)))]
      [else
       (loop
        (rest l)
        (append outl
                (list #\newline)
                (for/list ((i l)
                           (n (length l)))
                  (for/list ((j (add1 n)))
                    i
                    ))))]  )))


(f "abcde")
(f "xyz")

Đầu ra:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

JavaScript (ES6), 65 byte

f=s=>s?[s.replace(/./g,(c,i)=>c.repeat(i+1)),...f(s.slice(1))]:[]

<input oninput=o.textContent=f(this.value).join`\n`><pre id=o>

Những nỗ lực trước đây:

67: s=>[...s].map((_,i)=>s.slice(i).replace(/./g,(c,i)=>c.repeat(i+1)))
84: s=>s.replace(/./g,`$&$'
    `).match(/.+/g).map(s=>s.replace(/./g,(c,i)=>c.repeat(i+1)))
89: f=(s,t=s.replace(/./g,(c,i)=>c.repeat(i+1)))=>t?[]:[t,...f(s,t.replace(/(.)(?=\1)/g,''))]

PHP, 103 byte (99 với các thẻ ngắn)

<?php for($s=$argv[1];""!=$s[$i++];$o.="
")for($j=0;""!=$l=$s[$j+$i-1];)$o.=str_pad('',++$j,$l);echo$o;

Tôi khá chắc chắn đây không phải là câu trả lời ngắn nhất có thể.

MATL , 12 byte

&+gYRYs"G@Y"

Tôi thích nó khi dấu ngoặc kép đến với nhau!

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

Giải trình

Điều này hoạt động bằng cách xây dựng một ma trận có các cột được sử dụng, từng cái một, để giải mã chiều dài đầu vào. Ví dụ, đối với đầu vào 'abcde'ma trận là

1 0 0 0 0
2 1 0 0 0
3 2 1 0 0
4 3 2 1 0
5 4 3 2 1

Mã số:

&+g    % Implicit input. NxN matrix of ones, where N is input size
YR     % Set entries above diagonal to zero
Ys     % Cumulative sum of each column. This gives the desired matrix 
"      % For each column
  G    %   Push input (for example 'abcde')
  @    %   Push current column (for example [0;0;1;2;3])
  Y"   %   Run-length decode (example output 'cddeee')
       % Implicit end
       % Implicit display

Python 3, 95 byte

def f(s):return'\n'.join(''.join(s[j:][i]*(i+1)for i in range(len(s)-j))for j in range(len(s)))

Điều này là đáng ngạc nhiên khó khăn hơn tôi mong đợi nó được. Tôi làm lại toàn bộ chức năng của tôi có thể 4 lần.

Java 7.140 byte

void c(char[]a,int l,int j){if(l<1)return;c(a,--l,++j);for(int i=0,k;i<j;i++)for(k=0;k++<=i;)System.out.print(a[i+l]);System.out.println();}

Ung dung

 void c(char[]a,int l,int j)
{
if (l < 1) 
return ;
c(a , --l , ++j) ;
for(int i = 0 , k; i < j ; i++)
for(k = 0 ; k++ <= i ;)
System.out.print(a[i+l]);
System.out.println();
}

Theo dõi dòng cho tôi rất đau. Tôi không biết làm thế nào tôi có thể đánh gôn (vì có hai vòng để phá vỡ điều kiện để đưa "\n"vào tuyên bố in).
System.out.println();

Pyke, 12 byte

VilS],A*s
}t

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

Ruby, 51 byte

Sử dụng -ncờ cho byte 1.

(k=0;puts$_.gsub(/./){$&*k+=1};$_[0]="")while$_>$/

R, 108 byte

Đọc đầu vào từ stdin và in ra thiết bị xuất chuẩn

s=scan(,"");n=nchar(s);for(i in 1:n)cat(do.call("rep",list(strsplit(s,"")[[1]][i:n],1:(n-i+1))),"\n",sep="")

Tôi cảm thấy việc sử dụng do.calllà phù hợp ở đây. Về cơ bản, nó có hai đầu vào: 1. một tên hàm dưới dạng một chuỗi ( repở đây) và một danh sách các đối số và 2. áp dụng lặp lại gọi hàm sử dụng các đối số trong danh sách.

Ví dụ:

• rep("c",3) tạo ra các vectơ "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) tạo ra các vectơ "a" "b" "b" "c" "c" "c"
• tương đương với liên tiếp kêu gọi rep("a",1), rep("b",2)vàrep("c",3)

Vim, 43 byte

qqYlpx@qq@qqr0<C-H><C-V>{$:s/\v%V(.)\1*/&\1/g<CR>@rq@r

Macro đầu tiên phân tách các hậu tố, macro thứ hai "phát nổ" chúng. Có khả năng bị đánh bại. Không gian là khó chịu.

C, 186 byte

#include <string.h>
#define S strlen
p(char* s){char *t=s;char u[999]="";for(int i=0;i<S(s);i++){for(int j=i+1;j>0;j--){sprintf(u+S(u),"%c",*t);}t++;}printf("%s\n",u);if(S(s)>1)p(s+1);}

Điều này có lẽ có thể được rút ngắn khá nhiều, nhưng tôi chỉ muốn thử nó. Đây là lần thử thứ hai của tôi tại golf, vì vậy hãy cho tôi bất kỳ gợi ý nào (* lol) bạn có thể. Nó lấy một chuỗi làm tham số và thực hiện việc phát nổ từ đó. u được sử dụng như một bộ đệm lưu trữ chuỗi đã nổ.

Ung dung:

#include <string.h>
#define S strlen 
p(char* s){
    char *t=s;
    char u[999]="";
    for(int i=0;i<S(s);i++){
        for(int j=i+1;j>0;j--){
            sprintf(u+S(u),"%c",*t);
        }
        t++;
    }
    printf("%s\n",u);
    if(S(s)>1)p(s+1);
}

Acc !! , 150 byte

Yêu cầu đầu vào trên stdin, kết thúc bằng một ký tự tab.

N
Count c while _/128^c-9 {
_+N*128^(c+1)
}
Count i while _-9 {
Count j while _/128^j-9 {
Count k while j+1-k {
Write _/128^j%128
}
}
Write 10
_/128
}

Giải trình

Đây thực sự là một nhiệm vụ khá tốt cho Acc !! , vì nó chỉ yêu cầu đọc một chuỗi và lặp qua nó với một số vòng lặp lồng nhau. Chúng tôi đọc chuỗi vào bộ tích lũy, coi nó như một chuỗi gồm 128 chữ số cơ bản, với ký tự đầu tiên ở đầu thứ tự thấp. Sau Count cvòng lặp mở , giá trị bộ tích lũy có thể được khái niệm hóa như thế này (sử dụng xyzlàm ví dụ đầu vào):

128^   3  2  1  0
     tab  z  y  x

(Giá trị tích lũy thực tế cho ví dụ này là 9*128^3 + 122*128^2 + 121*128 + 120= 20888824.)

Sau đó, chúng ta có thể lặp lại chuỗi bằng cách lặp lại các lũy thừa tăng 128. Và chúng ta có thể lặp lại các hậu tố bằng cách chia bộ tích lũy cho 128 sau mỗi lần lặp, cắt bỏ một ký tự.

Với sự thụt lề và bình luận:

# Initialize the accumulator with the first input character
N
# Loop until most recent input was a tab (ASCII 9)
Count c while _/128^c - 9 {
    # Input another character and add it at the left end (next higher power of 128)
    _ + N * 128^(c+1)
}

# Loop over each suffix, until only the tab is left
Count i while _ - 9 {
    # Loop over powers of 128 until the tab
    Count j while _/128^j - 9 {
        # Loop (j+1) times
        Count k while j + 1 - k {
            # Output the j'th character
            Write _ / 128^j % 128
        }
    }
    # Output a newline
    Write 10
    # Remove a character
    _/128
}