소개

이 예제에서는 string Hello, World!과 array을 가져 옵니다 [3, 2, 3]. 부분 문자열 체인을 찾으려면 다음 프로세스를 수행하십시오.

배열의 첫 번째 숫자는 3우리가 문자열 수 있도록 [0 - 3]이다 Hel. 그 후, 우리 3는 초기 문자열에서 첫 번째 문자를 제거합니다 lo, World!.

배열의 두 번째 숫자는 2이므로 [0 - 2]새 문자열에서 하위 문자열 을 가져옵니다 lo. 남은 문자열은 , World!입니다.

마지막 번호는입니다 3우리를 준다, , W. 하위 문자열 체인이 우리에게주는 결합 된 문자열의 모든입니다 :

['Hel', 'lo', ', W']

보다 시각적 인 예를 들면 다음과 같습니다.

[3, 2, 3], 'Hello, World!'
3 -> Hel
2 ->    lo
3 ->      , W

작업

감안 비어 문자열 과 비어 배열 만 이루어진 양의 정수 ( ), 출력 스트링 체인 . 배열의 모든 정수의 합이 문자열의 길이를 초과하지 않는다고 가정 할 수 있습니다.> 0

또한 문자열에 줄 바꿈이 포함되지 않는다고 가정 할 수 있습니다.

테스트 사례

Input: abcdefghijk, [2, 1, 3]
Output: ['ab', 'c', 'def']

Input: Code Golf, [4, 1]
Output: ['Code', ' ']

Input: Ayyy, [3]
Output: ['Ayy']

Input: lexicographically, [2, 2, 2, 7, 4]
Output: ['le', 'xi', 'co', 'graphic', 'ally']

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

05AB1E , 1 바이트

£

이것은 부속 문자열 (0, N) 명령입니다.
목록에 적용되면 문자열의 나머지 부분에서 반복적으로 작동합니다.

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

파이썬 2, 42 바이트

s,a=input()
for n in a:print s[:n];s=s[n:]

때때로 당신은 그냥 지루한 방법으로합니다.

Brachylog , 20 13 바이트

h@[~c.:la~t?,

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

이는 마지막 테스트 사례에서 TIO에서 매우 비효율적이고 시간 초과됩니다.

설명

Input = [String, List of integers]

h@[            Take a prefix of the string
   ~c.         Take a possible list of strings which when concatenated results in that prefix
      :la      Take the lengths of each element of that list
         ~t?,  This list of lengths is equal to the list of integers of the Input

약간 더 효율적인 버전, 15 바이트

t : {~ l} a.,? h @ [~ c

파이썬 3, 45 바이트

f=lambda s,a:f(s[a[0]:print(s[:a.pop(0)])],a)

줄당 하나의 하위 문자열을 인쇄하고 a 가 소진되면 오류와 함께 종료됩니다 .

repl.it에서 테스트하십시오 .

파이썬, 52 , 46 바이트

f=lambda a,s:a and[s[:a[0]]]+f(a[1:],s[a[0]:])

재귀 람다 함수.

6 바이트를 줄여준 Dennis에게 감사합니다!

젤리 , 6 바이트

Jx$ĠịY

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

        The implicit working value is the first argument.
Jx$     Given a list L, repeat (x) an element of [1..len(n)] (J)
        as many times as the corresponding value in L.
   Ġ    Group indices by values. This turns [1, 1, 1, 2, 2, 3, 3]
        into [[1, 2, 3], [4, 5], [6, 7]].
    ị   Index into the second argument.
     Y  Join by newlines.

하스켈, 34 바이트

s#(a:b)=take a s:drop a s#b
_#_=[]

사용 예 : "lexicographically" # [2,2,2,7,4]->["le","xi","co","graphic","ally"]

간단한 재귀.

또는 내장을 통한 지루한 29 바이트 솔루션 :

import Data.Lists
splitPlaces

루비, 26 바이트

->w,a{a.map{|n|w.shift n}}

문자열은 문자 배열로 표시됩니다.

PowerShell v2 +, 46 바이트

param($a,$b)$b|%{-join$a[$i..($i+=$_-1)];$i++}

입력 문자열 $a과 배열을 가져 와서 $b반복합니다 $b. 각 반복 $a은 $i(기본값은 $null또는 0) 및 현재 숫자 를 기준으로 배열 슬라이스를 수행합니다 . 요구는 할 일 -1및 $i++PowerShell의 문자열이기 때문에 제로 인덱스.

예

(여기서 출력은 배열의 기본 문자열 화 방법이므로 공백으로 구분됩니다)

PS C:\Tools\Scripts\golfing> @('abcdefghijk',@(2,1,3)),@('Code Golf',@(4,1)),@('Ayyy',@(3)),@('lexicographically',@(2,2,2,7,4))|%{""+$_[0]+" -> "+(.\substring-chainification.ps1 $_[0] $_[1])}
abcdefghijk -> ab c def
Code Golf -> Code  
Ayyy -> Ayy
lexicographically -> le xi co graphic ally

펄, 28 바이트

에 +1 포함 -n

STDIN의 입력 문자열과 각 행을 별도의 줄에 따라 실행하십시오.

(echo "Hello, World!"; echo 3; echo 2; echo 3) | perl -nE 'say for/(??{"."x<>||"^"})/g'

코드 만 :

say for/(??{"."x<>||"^"})/g

23 바이트 버전 ||"^"도 작동 하지 않지만 가짜 후행 줄 바꿈을 인쇄합니다.

"^"$_문자열에 정규식 메타 문자가 포함되지 않은 경우 바꿀 수 있습니다

MATL , 8 바이트

ys:)1bY{

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

설명

y    % Implicitly take the two inputs: numerical array, string. Duplicate the array
s    % Sum of the array, say n
:    % Range from 1 to n
)    % Take first n characters of the string
1    % Push 1
b    % Bubble up the original copy of the string to the top
Y{   % Split into pieces of lengths given by the numerical array. The pieces are 
     % stored in a cell array, which is implicitly displayed, one cell per line

자바 스크립트 (ES6), 39 38 35 바이트

ETH 프로덕션 덕분에 3 바이트 절약 :

s=>a=>a.map(v=>s.slice(t,t+=v),t=0)

예:

//Definition
f=
s=>a=>a.map(v=>s.slice(t,t+=v),t=0)

//Call
f('lexicographically')([2, 2, 2, 7, 4]);

//Output
Array [ "le", "xi", "co", "graphic", "ally" ]

s=>a=>a.map(v=>s.substr(t,v,t+=v),t=0)

39 바이트 :

(s,a)=>a.map(v=>s.substr(t,v,t+=v),t=0)

배치, 74 바이트

@set/ps=
@for %%i in (%*)do @call echo %%s:~0,%%i%%&call set s=%%s:~%%i%%

나는 C를 때리고있다? 맞지 않아요! STDIN의 문자열과 배열을 명령 행 인수로 사용합니다.

자바, 119 바이트

String[] substringChainification(String s, int[] i) {
    String[] r = new String[i.length];
    int j = 0, f = 0;
    for (int t : i)
        r[j++] = s.substring(f, f += t);
    return r;
}

골프 :

String[]s(String s,int[]i){String[]r=new String[i.length];int j=0,f=0;for(int t:i)r[j++]=s.substring(f,f+=t);return r;}

Roman Gräf의 답변 ( /codegolf//a/93992/59935 )을 수정 했지만 의견을 말할 충분한 담당자가 없습니다.

루프 구현을 변경하고 모든 반복에서 소스 문자열을 다른 하위 문자열로 설정하는 대신 하위 문자열을 얻는 인덱스를 변경했습니다.

파이크, 10 바이트

FQR<
Ki?>Q

여기 사용해보십시오!

sed (82 + 2 -rn) 84

s,^,\n,;:l;N;s,\n\n,\n,;:
s,^([^\n]*)\n(.)([^\n]*\n)1,\1\2\n\3,
t;P;s,^[^\n]*,,;tl

입력의 첫 번째 줄은 문자열입니다. 그런 다음 그 뒤에 각 줄은 unary 의 하위 문자열 크기입니다 .

예:

$ cat test.txt:
lexicographically
11
11
11
1111111
1111

$ cat hold | sed -rnf sed.txt
le
xi
co
graphic
ally

CJam , 11 바이트

lq~{/(ns}/;

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

설명

l    e# Read input string.
q~   e# Read array of lengths and eval.
{    e# For each length...
  /  e#   Split the string into chunks of the given size.
  (  e#   Pull off the first chunk.
  n  e#   Print with linefeed.
  s  e#   Flatten the remaining chunks into a single string again.
}/
;    e# Discard any remainder of the input string.

C, 81 바이트

i,j;f(s,l,k)char*s;int*l;{for(i=j=0;i<k;){write(1,s+j,l[i]);puts("");j+=l[i++];}}

write()출력은 버퍼링되지 않기 때문에 온라인 컴파일러는 이것을 출력하는데 어려움을 겪을 것입니다.

test.c :

i,j;f(s,l,k)char*s;int*l;{for(i=j=0;i<k;){write(1,s+j,l[i]);puts("");j+=l[i++];}}
main(){
    int l[]={3,2,3};
    f("Hello, World!",l,3);
    int ll[]={2,1,3};
    f("abcdefghijk",ll,3);
    int lll[]={4,1};
    f("Code Golf",lll,2);
    int llll[]={3};
    f("Ayyy",llll,1);
    int lllll[]={2,2,2,7,4};
    f("lexicographically",lllll,5);
}

배관없는 출력 :

Hel
lo
, W
ab
c
def
Code

Ayy
le
xi
co
graphic
ally

PHP, 98 바이트

<?php
$b=$argv[1];foreach(explode(',',$argv[2])as$a){echo(substr($b,0,$a).' ');$b=substr($b,$a);}

용법:

php chainification.php lexicographically 2,2,2,7,4

산출:

le xi co graphic ally

PHP에는 더 나은 솔루션이있을 것입니다.

PHP, 82 바이트

<?php for($s=$argv[++$i],$j=-1;$n=$argv[++$i];){for(;$n--;)echo$s[++$j];echo"
";}

입력을 문자열로 가져온 다음 숫자 목록을 가져오고 출력은 줄 바꾸기로 구분됩니다. 예 :

php chainify.php lexicographically 2 2 2 7 4

-r과 함께 $ argv를 사용할 수있는 사람들 중 하나라면 여는 태그에 사용되는 6 바이트를 저장할 수 있습니다.

PHP, 63 바이트

<?foreach($_GET[a]as$p){echo" ".substr($_GET[s],$s,$p);$s+=$p;}

배열로 출력 85 바이트

<?foreach($_GET["a"]as$p){$o[]=substr($_GET["s"],$s,$p);$s+=$p;}echo json_encode($o);

Pyth, 7 바이트

PcwsM._

문자열을 이스케이프 처리하지 않고 배열 뒤에 오는 개행으로 구분하여 입력을받습니다. 온라인으로 사용해보십시오!

설명:

     ._  Get all prefixes of Q
   sM    Map sum across each of these prefixes (to get the total indices)
 cw      Split the string at these locations
P        Remove the last "remainder" of the string

옥타브 / MATLAB, 31 바이트

@(s,a)mat2cell(s(1:sum(a)),1,a)

이것은 입력을 가진 익명 함수입니다 s: string; a: 숫자 형 배열.

Ideone에서 사용해보십시오 .

설명

이것은 내 MATL 답변의 포트입니다.

s(1:sum(a))        % Take first n characters of string s, where n is the sum of array a
mat2cell(...,1,a)  % Split into pieces of lengths given by a and store in a cell array

자바 142 바이트

public static String[]substringChain(String s,int[]i){
  String[]r=new String[i.length];
  for(int j=-1;++j<i.length;){
    r[j]=s.substring(0,i[j]);
    s=s.substring(i[j]);
  }
  return b;
}

골프 :

String[]s(String s,int[]i){String[]r=new String[i.length];for(int j=-1;++j<i.length;){r[j]=s.substring(0,i[j]);s=s.substring(i[j]);}return b;}

어, 36 자

{FIELDWIDTHS=$0;OFS=RS;getline}$1=$1

샘플 실행 :

bash-4.3$ awk '{FIELDWIDTHS=$0;OFS=RS;getline}$1=$1' <<< $'3 2 3\nHello, World!'
Hel
lo
, W

실제로는 점수를 계산하는 방법을 모릅니다.

bash-4.3$ awk -vFIELDWIDTHS='3 2 3' -vOFS='\n' '$1=$1' <<< 'Hello, World!'
Hel
lo
, W

Dyalog APL 16.0, 15 자 (비경쟁); 15.0, 17 바이트

16.0 솔루션

{⍵⊆⍨(⍴⍵)↑⍺/+\⍺}

Dyalog APL 16.0은 APL2의 파티션 프리미티브를 ⊂glyph와 함께 추가합니다 ⊆.

15.0 해결책 :

{(-⍺)↑¨(+\⍺)↑¨⊂⍵}

TryAPL 온라인!

GNU sed, 55 + 2 (rn 플래그) = 57 바이트

1H;1d;G;:;s=.(\n.*)\n(.)=\1\2\n=;t;s=.==;P;s=[^\n]*==;h

온라인으로 사용해보십시오! (sed를 추가 한 @Dennis에게 감사드립니다)

설명 : 입력 문자열은 첫 번째 행에 있어야하고 그 뒤에 숫자 는 단항 으로되어 있어야합니다. 사이클이 시작될 때마다 매번 스크립트를 실행하여 새 줄을 암시 적으로 읽습니다.

1H;1d                       # once: append string to hold space and start new cycle
                            #Initially, the hold space contains an useful '\n'.
G                           # append hold space to pattern space. The pattern space
                            #format will be: 'UNARY\n\nSTRING'.
:;s=.(\n.*)\n(.)=\1\2\n=;t  # iteratively remove a char from the string, as many
                            #times as unary chars, and store it on 2nd pattern line
s=.==;P                     # remove '\n', then print the new top line
s=[^\n]*==;h                # delete up to '\n' and update hold space

테스트 실행 : EOF가 포함 된 여기 문서를 끝 마커로 사용

sed -rnf program.sed << EOF
> abcdefghijk
> 00
> 0
> 000
> EOF

산출:

ab
c
def

Vimscript, 79 78 바이트

아주 예쁘지 않아서 개선 될 수 있다고 확신합니다 ...

vim 버퍼를 가져온 다음 호출 echom string(A([2,3]))하여 출력을 봅니다.

fu A(l)
let r=[]
for i in a:l
exe "norm d".i."l"
let r+=[@"]
endfo
retu r
endf

나는 실제로 문자열 을 부정 행위하고 출력하는 것을 생각 ["abc", "def"]했지만 ...

설명 : 각 배열 항목을 삭제하고 (기본 레지스터에 넣음) 문자 수를 배열에 추가합니다 r. 실제로 지루한 답변입니다.

공통 리스프, 78 76 바이트

익명 기능이 허용된다고 가정합니다.

(lambda(s l)(loop for x in l as y = x then(+ y x)collect(subseq s(- y x)y)))

용법

(funcall #'(lambda(s l)(loop for x in l as y = x then(+ y x)collect(subseq s(- y x)y)))"AbCdefGhijK"'(3 2 3))

산출

("AbC" "de" "fGh")

두 변수 사이의 괄호에 맞게 y 정의를 as대신 사용 and하고 변경 하여 -2 바이트(subseq ...)

리볼, 38 바이트

func[s b][map-each n b[take/part s n]]