给定一个字符串S和一个索引列表X，S通过删除每个索引处的元素来进行修改，并将S结果作为的新值S。

例如，给定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始终是的有效索引S，并且可以使用基于0或基于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'

Haskell，38 33字节

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

直截了当：反复获取索引i之前和之后的元素，将它们重新加入并收集结果。

在线尝试！

编辑：@Lynn保存5个字节。谢谢！

JavaScript（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)。

我们建立一个新的数组，并从原始数组开始 s。但是，splice稍后我们将使用的方法修改数组时，我们需要为其复制一个副本，方法是将其转换为字符串（只需附加一个空字符串）即可。

为了生成子map数组，我们对整数数组a（其中x是当前整数）进行遍历，对于每个元素，我们splice从sindex开始，从1个元素开始x。我们返回经过修改的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.

Python 2，43个字节

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

在线尝试！

只要易于阅读，任何形式的输出都可以。

因此，这将打印为字符列表。

Python 2 2，47个字节

正如@LuisMendo指出的那样，它可以缩短为43个字节，但这已经是@ErktheOutgolfer的解决方案。

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

在线尝试！

Java 8，78字节

这是一个令行禁止的λ，从int[]给消费者StringBuilder或StringBuffer。输出被打印到标准输出。

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)

在线尝试！

将输入作为字符列表，并且X从1开始。Reduce是R的等价物fold，在这种情况下，函数[是子集。重复进行，-X因为R中的负索引删除了元素，并将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-argument function, takes X 1-indexed. Takes S as a string.

Try it online!

Haskell, 33 bytes

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

Try it online!

PowerShell, 94 84 bytes

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

Try it online!

Takes input $s as a string and $x as an explicit array. We then create $a based on $s as a list.

Arrays in PowerShell are fixed size (for our purposes here), so we need to use the lengthy [System.Collections.Generic.list] type in order to get access to the .removeAt() function, which does exactly what it says on the tin.

I sacrificed 10 bytes to include two -join statements to make the output pretty. OP has stated that outputting a list of chars is fine, so I could output just $a rather than -join$a, but that's really ugly in my opinion.

Saved 10 bytes thanks to briantist.

Python 2, 50 bytes

• Takes in string and list of indices

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

Try it online!

05AB1E, 9 7 bytes

=svõyǝ=

Try it online!

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

-2 thanks to idea from @ETHProductions.

Retina, 58 bytes

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

Try it online! Explanation:

¶\d+

Match the indices (which are never on the first line, so are always preceded by a newline).

¶¶1$&$*

Double-space the indices, convert to unary, and add 1 (because zeros are hard in Retina).

+1`

Repeatedly change the first match, which is always the current value of the string.

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

Retrieve the next index in $#1.

                (           .    ¶)

Capture the string, including the $#1th character and one newline.

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

Separately capture the prefix and suffix of the $#1th character of the string.

                                   ¶.*

Match the index.

$2$3$4

Replace the string with itself and the index with the prefix and suffix of the $#1th character.

Pyth, 8 bytes

.u.DNYEz

Demonstration

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!