ASCII 문자열이 주어지면 그 접미사를 출력하십시오. 예를 들어 문자열이 abcde인 경우 가장 긴 순서부터 가장 짧은 순서로 접미사가 5 개 있습니다.

abcde
bcde
cde
de
e

그런 다음 각 접미사가 분해됩니다 . 즉, 각 문자는 해당 접미사에서 색인이 생성 된 한 위치만큼 여러 번 복사됩니다. 예를 들어,의 접미사를 폭발 abcde,

abcde
12345
abbcccddddeeeee

bcde
1234
bccdddeeee

cde
123
cddeee

de
12
dee

e
1
e

전부의 폭발 접미사가 abcde있습니다

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

규칙

• 이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.
• 입력은 인쇄 가능한 ASCII 문자로 구성됩니다. (이것은 줄 바꿈은 제외하지만 공백을 포함합니다.)
• 출력에는 각 문자열이 별도의 줄에 있습니다.
• 각 줄에는 후행 공백이 허용되며 끝에 줄 바꿈이 추가 될 수 있습니다.

테스트 사례

''

'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

젤리 , 5 바이트

ṫJxJY

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

작동 원리

ṫ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 바이트

14 바이트를 절약 해 주셔서 감사합니다!

(#~#\)\.

이제 이것은 정말 좋은 해결책입니다. 꽤 간결하다.

입력 #~#\의 접미사 ( \.)에 적용되는 후크 입니다. input y에서 호출되면 후크 는 다음과 같이 분해됩니다.

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

중간 결과는 다음과 같습니다.

   ]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

테스트 사례

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

파이썬, 61 바이트

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

대안 63 :

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

파이썬 3, 91 68 65 바이트

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

원하는 출력을 인쇄 한 후 오류와 함께 종료됩니다. Ideone에서 테스트하십시오 .

작동 원리

f 가 재귀 적으로 호출 되기 전에 인덱스를 s[1:...]계산해야합니다.

우선 enumerate(s[0]+s)수율 모든 쌍 (I, C)를 문자의 (C) 의 (S)를 - 첫 문자가 중복 - 상기 대응하는 인덱스 나 . Prepending s[0]은 두 가지 목적으로 사용됩니다.

• s 의 첫 문자는 한 번 반복해야하지만 첫 번째 인덱스는 0 입니다.

• 모든 문자가 처리되면 s[0]올릴 IndexError을 일으키는 F가 아닌 재귀 한계에 도달 할 때까지 인쇄를 바꿈보다 오류로 종료.

''.join(i*c for i,c in ...)각 평면 문자열 빌드 C 반복 I 되는 회 printSTDOUT에 에코.

마지막으로, None을print 반환 하고 간단히 이므로, 재귀 호출 은 첫 번째 문자없이 s에 대해 위의 프로세스를 반복합니다 .s[1:None]s[1:]f(s[1:...])

펄 6 , 38 바이트

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

-n명령 행 스위치의 경우 37 바이트 + 1

예:

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

넓히는:

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

@]Elyk:Erz:jac@w\

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

설명

@]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 바이트

.sRvyvyN>×}J,

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

설명

.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 바이트

Sl+{_eee~n1>}h

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

설명

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

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

재귀 익명 함수는 선행 줄 바꿈을 인쇄합니다. 선행 줄 바꿈이 허용되지 않으면 3 바이트가 추가 줄 바꿈 문자로 바뀝니다.

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

ungolfed 방법 및 테스트 사례가 포함 된 전체 프로그램 :

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

하스켈, 48 바이트

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

에 의해 인터페이스

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'

펄, 36 + 1 ( -n) = 37 바이트

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

실행할 필요 -n및 -E(또는 -M5.010) :

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

$.행을 읽을 때마다 증가 하는 변수 를 사용하므로 행을 읽을 때마다 증가 하는 변수 를 사용하므로 행을 읽을 때마다 하나의 인스턴스에서만 작동합니다 1. (그러나 여기서 문제는 없습니다. ^D다시 실행하십시오!)

망막 , 31 바이트

바이트 수는 ISO 8859-1 인코딩을 가정합니다.

M&!`.+

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

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

자바, (150) 127 바이트

편집하다:

• -23 바이트 꺼짐 @Kevin Cruijssen에게 감사합니다

스 니펫 :

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

언 골프 드 :

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

라켓 184 바이트

(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))))]))

언 골프 드 :

(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")

산출:

abbcccddddeeeee
bccdddeeee
cddeee
dee
e

xyyzzz
yzz
z

자바 스크립트 (ES6), 65 바이트

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>

이전 시도 :

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 바이트 (99 개 짧은 태그)

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

나는 이것이 가장 짧은 대답이 아니라고 확신합니다.

MATL , 12 바이트

&+gYRYs"G@Y"

따옴표가 모일 때 나는 그것을 좋아합니다!

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

설명

이것은 열을 하나씩 사용하여 입력을 실행 길이 디코딩하는 행렬을 작성하여 작동합니다. 예를 들어, 입력을 'abcde'위해 행렬은

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

암호:

&+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

파이썬 3, 95 바이트

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

이것은 내가 예상했던 것보다 놀라 울 정도로 어려웠다. 전체 기능을 4 번 반복했습니다.

자바 7,140 바이트

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

언 골프

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

다음 줄은 매우 고통 스럽습니다. 나는 어떻게 골프를 칠 수 있는지 모르겠습니다 ( "\n"인쇄 진술 에 넣을 조건을 깨는 두 개의 루프가 있기 때문에 ).
System.out.println();

파이크, 12 바이트

VilS],A*s
}t

여기 사용해보십시오!

루비, 51 바이트

-n+1 바이트에 플래그를 사용합니다 .

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

R, 108 바이트

stdin에서 입력을 읽고 stdout으로 인쇄

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="")

나는 do.call여기 에서 사용 이 적절 하다고 느꼈다 . 기본적으로 두 가지 입력이 있습니다. 1. 문자열 형식의 함수 이름 ( rep여기) 및 인수 목록. 2. 반복적으로 목록의 인수를 사용하여 함수를 호출합니다.

예 :

• rep("c",3) 벡터를 생성 "c" "c" "c"
• do.call("rep",list(c("a","b","c"),1:3)) 벡터를 생성 "a" "b" "b" "c" "c" "c"
• 이는 연속적으로 호출하는 것과 rep("a",1), rep("b",2)및rep("c",3)

Vim, 43 바이트

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

첫 번째 매크로는 접미사를 분리하고 두 번째 매크로는 접미사를 "폭발"시킵니다. 아마 이길 수 있습니다. 공간이 성가시다.

C, 186 바이트

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

이것은 아마도 약간 단축 될 수 있지만, 나는 그것을 시도하고 싶었습니다. 골프에서 두 번째 시도이므로 할 수있는 포인터 (* lol)를 알려주십시오. 문자열을 매개 변수로 사용하여 거기서 폭발합니다. u는 분해 된 문자열을 저장하는 버퍼로 사용됩니다.

언 골프 드 :

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

stdin에서 입력을 예상하고 탭 문자로 종료합니다.

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
}

설명

이것은 실제로 Acc 에게는 꽤 좋은 작업입니다 ! , 문자열을 읽고 중첩 루프로 반복해야하기 때문에. 우리는 문자열을 누산기로 읽어서 하위 128 자릿수의 첫 번째 문자와 함께 기본 128 자릿수의 시퀀스로 취급합니다. 오프닝 Count c루프 후 누산기 값은 다음과 같이 개념화 될 수 있습니다 ( xyz예제 입력으로 사용).

128^   3  2  1  0
     tab  z  y  x

(이 예제의 실제 누산기 값은 9*128^3 + 122*128^2 + 121*128 + 120= 20888824입니다.)

그런 다음 128의 거듭 제곱을 반복하여 문자열을 반복 할 수 있습니다. 그리고 반복 할 때마다 누산기를 128로 나누어 문자를 잘라내어 접미사를 반복 할 수 있습니다.

들여 쓰기 및 의견 :

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