문자열 S과 인덱스 목록이 제공 되면의 결과를 새 값으로 사용하면서의 각 인덱스에서 요소를 제거하여 X수정 S하십시오 .SS

예를 들어 given S = 'codegolf'및 X = [1, 4, 4, 0, 2],

0 1 2 3 4 5 6 7  |
c o d e g o l f  |  Remove 1
c d e g o l f    |  Remove 4
c d e g l f      |  Remove 4
c d e g f        |  Remove 0
d e g f          |  Remove 2
d e f

귀하의 작업은이 프로세스를 수행하고 S각 작업 후의 값을 수집 한 후 각 줄 바꿈 순서대로 표시하는 것입니다. 최종 답변은

S = 'codegolf'
X = [1, 4, 4, 0, 2]

Answer:

codegolf
cdegolf
cdeglf
cdegf
degf
def

• 이것은 코드 골프 이므로 코드를 최대한 짧게 만드십시오.
• 의 값 X이 항상 유효한 인덱스 라고 가정하고 S0 기반 또는 1 기반 색인을 사용할 수 있습니다.
• 문자열에만 포함됩니다 [A-Za-z0-9]
• 하나 S또는 x으로 비어 있습니다. S비어있는 경우 에는 비어 x있어야합니다.
• S문자열 대신 문자 목록으로 사용할 수도 있습니다 .
• 출력을 인쇄하거나 문자열 목록을 반환 할 수 있습니다. 선행 및 후행 공백이 허용됩니다. 쉽게 읽을 수있는 한 어떤 형태의 출력이라도 좋습니다.

테스트 사례

S = 'abc', x = [0]
'abc'
'bc'

S = 'abc', x = []
'abc'

S = 'abc', x = [2, 0, 0]
'abc'
'ab'
'b'
''

S = '', x = []
''

S = 'codegolfing', x = [10, 9, 8, 3, 2, 1, 0]
'codegolfing'
'codegolfin'
'codegolfi'
'codegolf'
'codgolf'
'cogolf'
'cgolf'
'golf'

하스켈, 38 33 바이트

s#i=take i s++drop(i+1)s
scanl(#)

직접 : 인덱스 i 전후의 요소를 반복적으로 가져 와서 다시 결합하고 결과를 수집하십시오.

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

편집 : @Lynn은 5 바이트를 저장했습니다. 감사!

자바 스크립트 (ES6), 57 50 48 45 42 바이트

문자열을 개별 문자의 배열로 가져 와서 각 단계마다 쉼표로 구분 된 문자열의 하위 배열과 쉼표로 구분 된 원본을 포함하는 배열을 출력합니다.

s=>a=>[s+"",a.map(x=>s.splice(x,1)&&s+"")]

• Arnauld 덕분에 이전 보다 느슨한 출력 사양을 남용하여 3 바이트를 절약 할 수 있기 때문에 3 바이트가 절약되었습니다.

그것을 테스트

o.innerText=JSON.stringify((f=

s=>a=>[s+"",a.map(x=>s.splice(x,1)&&s+"")]

)([...i.value="codegolf"])(j.value=[1,4,4,0,2]));oninput=_=>o.innerText=JSON.stringify(f([...i.value])(j.value.split`,`))

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>String: </label><input id=i><label for=j>Indices: </label><input id=j><pre id=o>

설명

카레 구문에서 매개 변수 s(문자열 배열) 및 a(정수 배열)을 통해 두 개의 입력을 가져옵니다 f(s)(a).

우리는 새로운 배열을 만들고 original로 시작합니다 s. 그러나 splice나중에 사용할 메소드는 배열을 수정하므로 배열을 문자열로 변환하여 수행 할 수 있습니다 (빈 문자열 만 추가).

부분 배열을 생성하기 map위해 정수 배열 a( x현재 정수) 을 오버하고 각 요소에 대해 index에서 시작하여 splice1 개의 요소를 s시작 x합니다. modified를 반환하고 s다시 문자열로 변환하여 복사본을 만듭니다.

Japt , 6 바이트

åjV uV

온라인으로 테스트하십시오!

설명

UåjV uV   Implicit: U = array of integers, V = string
Uå        Cumulatively reduce U by
  j         removing the item at that index in the previous value,
   V        with an initial value of V.
     uV   Push V to the beginning of the result.

또는

uQ åjV

UuQ       Push a quotation mark to the beginning of U.
    å     Cumulatively reduce by
     j      removing the item at that index in the previous value,
      V     with an initial value of V.

이것은 인덱스에서 항목을 제거해도 "아무것도하지 않으므로 원래 문자열을 반환 하기 때문에 작동 합니다.

껍질 , 7 바이트

G§+oh↑↓

먼저 문자열을 가져온 다음 (1 기반) 인덱스를 가져옵니다. 온라인으로 사용해보십시오!

설명

G§+oh↑↓
G        Scan from left by function:
           Arguments are string, say s = "abcde", and index, say i = 3.
      ↓    Drop i elements: "de"
     ↑     Take i elements
   oh      and drop the last one: "ab"
 §+        Concatenate: "abde"
         Implicitly print list of strings on separate lines.

파이썬 2 , 43 바이트

s,i=input()
for i in i+[0]:print s;s.pop(i)

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

쉽게 읽을 수있는 한 어떤 형태의 출력이라도 좋습니다.

따라서 이것은 문자 목록으로 인쇄됩니다.

파이썬 2 , 47 바이트

@LuisMendo가 지적했듯이 이것은 43 바이트 로 단축 될 수 있지만 이미 @ErktheOutgolfer의 솔루션입니다.

a,b=input();print a
for i in b:a.pop(i);print a

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

자바 8, 78 바이트

또는 int[]의 소비자에 대한 카레 람다 입니다. 출력이 표준 출력으로 인쇄됩니다.StringBuilderStringBuffer

l->s->{System.out.println(s);for(int i:l)System.out.println(s.delete(i,i+1));}

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

05AB1E , 11 바이트

v=ā0m0yǝÏ},

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

v           # For each index:
 =          #   Print without popping
  ā         #   Push range(1, len(a) + 1)
   0m       #   Raise each to the power of 0. 
            #   This gives a list of equal length containing all 1s
     0yǝ    #   Put a 0 at the location that we want to remove
        Ï   #   Keep only the characters that correspond to a 1 in the new list
         }, # Print the last step

Mathematica, 70 바이트

(s=#;For[t=1,t<=Length@#2,Print@s;s=StringDrop[s,{#2[[t]]+1}];t++];s)&

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

R , 46 32 바이트

function(S,X)Reduce(`[`,-X,S,,T)

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

입력을 문자 목록으로 취하고 X1부터 시작합니다. Reduce는 R에 해당 fold하고이 경우 함수 [는 하위 집합입니다. 반복 처리는 위에 -XR 마이너스 인덱싱 요소를 제거하고 있기 때문에 init로 설정 S하여, accum=TRUE우리는 중간 결과를 축적되도록.

R , 80 바이트

function(S,X,g=substring)Reduce(function(s,i)paste0(g(s,0,i-1),g(s,i+1)),X,S,,T)

2 인수 함수 X 1- 색인이 필요합니다. 소요S 문자열로.

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

하스켈 , 33 바이트

scanl(\s i->take i s++drop(i+1)s)

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

PowerShell , 94 84 바이트

param($s,$x)$a=[Collections.Generic.list[char]]$s;$x|%{-join$a;,$a|% r*t $_};-join$a

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

입력 $s을 문자열 및 $x명시 적 배열로 사용합니다. 그런 다음$a$s 목록을 기반으로 합니다.

PowerShell의 배열은 크기가 고정되어 있으므로 (여기서는 여기에서) 긴 길이를 사용해야합니다 [System.Collections.Generic.list].removeAt() 에 따라) 주석에 표시된 것과 정확히 일치 하는 함수에 액세스하려면 유형 .

-join출력을 예쁘게 만들기 위해 두 개의 명령문을 포함하도록 10 바이트를 희생했습니다 . OP는 문자 목록을 출력하는 것이 좋다고 말했기 때문에 $a오히려 출력 할 수 있습니다-join$a 있지만 실제로는 추악합니다.

briantist 덕분에 10 바이트를 절약했습니다.

파이썬 2 , 50 바이트

• 문자열과 인덱스 목록을받습니다.

s,i=input()
for j in i+[0]:print s;s=s[:j]+s[j+1:]

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

05AB1E , 9 7 바이트

=svõyǝ=

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

=s        # Print original string, swap with indices.
  v       # Loop through indices...
   õyǝ    # Replace current index with empty string.

@ETHProductions의 아이디어 덕분에 -2.

망막 , 58 바이트

¶\d+
¶¶1$&$*
+1`(?=.*¶¶.(.)*)(((?<-1>.)*).(.*)¶)¶.*
$2$3$4

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

¶\d+

색인을 일치 시키십시오 (첫 번째 행에 있지 않으므로 항상 개행이 앞에옵니다).

¶¶1$&$*

인덱스를 두 번 공백으로 만들고 단항으로 변환 한 다음 1을 더합니다 (Retina에서는 0이 어렵 기 때문에).

+1`

항상 문자열의 현재 값인 첫 번째 일치 항목을 반복해서 변경하십시오.

   (?=.*¶¶.(.)*)

에서 다음 색인을 검색하십시오 $#1.

                (           .    ¶)

$#1th 문자와 하나의 줄 바꿈을 포함하여 문자열을 캡처하십시오 .

                 ((?<-1>.)*) (.*)

$#1문자열의 문자의 접두사와 접미사를 별도로 캡처하십시오 .

                                   ¶.*

색인과 일치하십시오.

$2$3$4

문자열을 자체로 바꾸고 색인을 $#1th 문자 의 접두사와 접미사로 바꾸십시오.

Pyth, 8 바이트

.u.DNYEz

데모

Reduce, starting with the string and iterating over the list of indices, on the deletion function.

PowerShell, 54 58 bytes

param($s,$x),-1+$x|%{$z=$_;$i=0;-join($s=$s|?{$z-ne$i++})}

Try it online!

Explanation

Takes input as a char array ([char[]]).

Iterates through the array of indices ($x) plus an injected first element of -1, then for each one, assigns the current element to $z, initializes $i to 0, then iterates through the array of characters ($s), returning a new array of only the characters whose index ($i) does not equal (-ne) the current index to exclude ($z). This new array is assigned back to $s, while simultaneously being returned (this happens when the assignment is done in parentheses). That returned result is -joined to form a string which is sent out to the pipeline.

Injecting -1 at the beginning ensures that the original string will be printed, since it's the first element and an index will never match -1.

q/kdb+, 27 10 bytes

Solution:

{x _\0N,y}

Examples:

q){x _\0N,y}["codegolf";1 4 4 0 2]
"codegolf"
"cdegolf"
"cdeglf"
"cdegf"
"degf"
"def"
q){x _\0N,y}["abc";0]
"abc"
"bc"
q){x _\0N,y}["abc";()]
"abc"
q){x _\0N,y}["abc";2 0 0]
"abc"
"ab"
,"b"
""    
q){x _\0N,y}["";()]
""

Explanation:

Takes advantage of the converge functionality \ as well as drop _.

{x _\0N,y}
{        } / lambda function, x and y are implicit variables
     0N,y  / join null to the front of list (y), drop null does nothing
   _\      / drop over (until result converges) printing each stage
 x         / the string (need the space as x_ could be a variable name)

Notes:

If we didn't need to print the original result, this would be 2 bytes in q:

q)_\["codegolfing";10 9 8 3 2 1 0]
"codegolfin"
"codegolfi"
"codegolf"
"codgolf"
"cogolf"
"cgolf"
"golf"

Perl 5, 55 bytes (54 + "-l")

sub{print($s=shift);for(@_){substr$s,$_,1,"";print$s}}

Try it online!

MATL, 8 bytes

ii"t[]@(

Indexing is 1-based.

Try it online! Or verify the test cases.

Explanation

i      % Input string. Input has to be done explicitly so that the string
       % will be displayed even if the row vector of indices is empty
i      % Input row vector of indices
"      % For each
  t    %   Duplicate current string
  []   %   Push empty array
  @    %   Push current index
  (    %   Assignment indexing: write [] to string at specified index
       % End (implicit). Display stack (implicit)

C# (.NET Core), 87 87 74 70 bytes

S=>I=>{for(int i=0;;S=S.Remove(I[i++],1))System.Console.WriteLine(S);}

Try it online!

Just goes to show that recursion isn't always the best solution. This is actually shorter than my original invalid answer. Still prints to STDOUT rather than returning, which is necessary because it ends with an error.

-4 bytes thanks to TheLethalCoder

C (gcc), 99 bytes

j;f(s,a,i)char*s;int*a;{puts(s);for(j=0;j<i;j++){memmove(s+a[j],s+a[j]+1,strlen(s)-a[j]);puts(s);}}

Try it online!

Takes the string, array, and the length of the array.

Pyth, 10 bytes

Rule changes saved me 1 byte:

V+E0Q .(QN

Try it online!

Pyth, 11 bytes

V+E0sQ .(QN

Try it online!

Gaia, 9 bytes

+⟪Seḥ+⟫⊣ṣ

^{I should really add a "delete at index" function...}

Try it online!

Explanation

+          Add the string to the list
 ⟪Seḥ+⟫⊣   Cumulatively reduce by this block:
  S         Split around index n
   e        Dump the list
    ḥ       Remove the first char of the second part
     +      Concatenate back together
        ṣ  Join the result with newlines

V, 12 bytes

òdt,GÙ@-|xHx

Try it online!

This is 1-indexed, input is like:

11,10,9,4,3,2,1,
codegolfing

Explanation

ò              ' <M-r>ecursively until error
 dt,           ' (d)elete (t)o the next , (errors when no more commas)
    G          ' (G)oto the last line
     Ù         ' Duplicate it down
        |      ' Goto column ...
      @-       ' (deleted number from the short register)
         x     ' And delete the character there
          H    ' Go back home
           x   ' And delete the comma that I missed

Swift 3, 80 bytes

func f(l:[String],c:[Int]){var t=l;for i in c{print(t);t.remove(at:i)};print(t)}

Try it online!

Pyth, 8 bytes

+zm=z.Dz

Test suite!

explanation

+zm=z.DzdQ    # implicit: input and iteration variable
  m      Q    # for each of the elements of the first input (the array of numbers, Q)
     .Dzd     # remove that index from the second input (the string, z)
   =z         # Store that new value in z
+z            # prepend the starting value

Python 2, 54

X,S=input()
for a in X:
    print S
    S=S[:a]+S[a+1:]
print S

Try It Online

APL, 31 30 28 bytes

{⎕←⍺⋄⍵≡⍬:⍬⋄⍺[(⍳⍴⍺)~⊃⍵]∇1↓⍵}

Try it online!

C# (Mono), 85 bytes

s=>a=>{for(int i=-2;++i<a.Count;)System.Console.WriteLine(s=i<0?s:s.Remove(a[i],1));}

Try it online!