Data una stringa Se un elenco di indici X, modificare Srimuovendo l'elemento in ciascun indice di Smentre si utilizza quel risultato come nuovo valore di S.

Ad esempio, dato S = 'codegolf'e 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

Il tuo compito è eseguire questo processo, raccogliere i valori di Sdopo ogni operazione e visualizzarli su una nuova riga in ordine. La risposta finale sarebbe

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

Answer:

codegolf
cdegolf
cdeglf
cdegf
degf
def

• Questo è code-golf, quindi abbassa il codice il più possibile.
• Puoi presumere che i valori in Xsiano sempre indici validi per Se puoi utilizzare l'indicizzazione basata su 0 o 1.
• La stringa conterrà solo [A-Za-z0-9]
• Sia So xpossono da svuotare. Se Sè vuoto, ne consegue che xdeve essere vuoto.
• Puoi anche prendere Scome un elenco di caratteri anziché una stringa.
• È possibile stampare l'output o restituire un elenco di stringhe. Gli spazi bianchi iniziali e finali sono accettabili. Qualsiasi forma di output va bene purché sia ​​facilmente leggibile.

Casi test

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 byte

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

Semplice: prendere ripetutamente gli elementi prima e dopo l'indice i, ricongiungerli e raccogliere i risultati.

Provalo online!

Modifica: @Lynn ha salvato 5 byte. Grazie!

JavaScript (ES6), 57 50 48 45 42 byte

Prende la stringa come un array di singoli caratteri, genera un array contenente una stringa separata da virgole dell'originale seguita da un sottoarray di stringhe separate da virgola per ogni passaggio.

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

• 3 byte salvati grazie ad Arnauld che mi suggerisce di abusare delle specifiche di output più ampie di quanto non fossi già, il che mi ha portato ad abusarne ancora di più per un altro salvataggio di 3 byte.

Provalo

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>

Spiegazione

Prendiamo i due input tramite parametri s(l'array string) e a(l'array integer) nella sintassi del curry, il che significa che chiamiamo la funzione con f(s)(a).

Costruiamo un nuovo array e lo avviamo con l'originale s. Tuttavia, poiché il splicemetodo che useremo in seguito modifica un array, dobbiamo crearne una copia, cosa che possiamo fare convertendolo in una stringa (semplicemente aggiungendo una stringa vuota).

Per generare il subarray, passiamo mapsopra l'array intero a(dove xè l'attuale intero) e, per ogni elemento, abbiamo splice1 elemento da s, iniziando dall'indice x. Restituiamo il modificato s, facendone di nuovo una copia convertendolo in una stringa.

Japt , 6 byte

åjV uV

Provalo online!

Spiegazione

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.

In alternativa:

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.

Questo funziona perché la rimozione dell'elemento all'indice "non fa nulla e quindi restituisce la stringa originale.

Buccia , 7 byte

G§+oh↑↓

Prende prima la stringa, quindi gli indici (basati su 1). Provalo online!

Spiegazione

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 byte

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

Provalo online!

Qualsiasi forma di output va bene purché sia ​​facilmente leggibile.

Quindi questo viene stampato come un elenco di caratteri.

Python 2 , 47 byte

Questo potrebbe essere ridotto a 43 byte , come ha sottolineato @LuisMendo, ma questa è già la soluzione di @ ErktheOutgolfer.

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

Provalo online!

Java 8, 78 byte

Questa è una lambda al curry, da int[]un consumatore di StringBuildero StringBuffer. L'output viene stampato allo standard.

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

Provalo online

05AB1E , 11 byte

v=ā0m0yǝÏ},

Provalo online!

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 byte

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

Provalo online!

R , 46 32 byte

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

Provalo online!

Accetta input come un elenco di caratteri ed Xè basato su 1. Reduceè l'equivalente R di fold, la funzione in questo caso è [quale sottoinsieme. Esegue l'iterazione -Xperché l'indicizzazione negativa in R rimuove l'elemento ed initè impostata su S, con accum=TRUEciò accumuliamo i risultati intermedi.

R , 80 byte

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

Funzione a 2 argomenti, accetta X1 indicizzata. Prende Scome una stringa.

Provalo online!

Haskell , 33 byte

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

Provalo online!

PowerShell , 94 84 byte

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

Provalo online!

Accetta input $scome stringa e $xcome array esplicito. Quindi creiamo$a base a $sun elenco.

Le matrici in PowerShell hanno dimensioni fisse (per i nostri scopi qui), quindi è necessario utilizzare il [System.Collections.Generic.list]tipo lungo per ottenere l'accesso al.removeAt() funzione, che fa esattamente quello che dice sulla tin.

Ho sacrificato 10 byte per includere due -joinistruzioni per rendere grazioso l'output. OP ha dichiarato che produrre un elenco di caratteri va bene, quindi potrei produrre solo $apiuttosto che-join$a , ma secondo me è davvero brutto.

Risparmiato 10 byte grazie a briantist.

Python 2 , 50 byte

• Comprende una stringa e un elenco di indici

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

Provalo online!

05AB1E , 9 7 byte

=svõyǝ=

Provalo online!

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

-2 grazie all'idea di @ETHProductions.

Retina , 58 byte

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

Provalo online! Spiegazione:

¶\d+

Abbina gli indici (che non sono mai sulla prima riga, quindi sono sempre preceduti da una nuova riga).

¶¶1$&$*

Doppio spazio degli indici, converti in unario e aggiungi 1 (perché gli zeri sono difficili in Retina).

+1`

Cambia ripetutamente la prima corrispondenza, che è sempre il valore corrente della stringa.

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

Recupera il prossimo indice in $#1.

                (           .    ¶)

Cattura la stringa, incluso il $#1carattere th e una nuova riga.

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

Acquisisci separatamente il prefisso e il suffisso di $#1 carattere th della stringa.

                                   ¶.*

Abbina l'indice.

$2$3$4

Sostituisci la stringa con se stessa e l'indice con il prefisso e il suffisso del $#1carattere th.

Pyth, 8 byte

.u.DNYEz

Dimostrazione

Ridurre, iniziando con la stringa e ripetendo l'elenco degli indici, sulla funzione di eliminazione.

PowerShell , 54 58 byte

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

Provalo online!

Spiegazione

Accetta input come char array ( [char[]]).

Scorre la matrice di indici ( $x) più un primo elemento iniettato di -1, quindi per ciascuno, assegna l'elemento corrente a $z, si inizializza $ia 0, quindi scorre attraverso la matrice di caratteri ( $s), restituendo una nuova matrice di soli caratteri il cui indice ( $i) non è uguale ( -ne) all'indice corrente di exclude ( $z). Questo nuovo array viene assegnato a $s, mentre viene contemporaneamente restituito (ciò accade quando l'assegnazione viene eseguita tra parentesi). Il risultato restituito viene modificato -joinper formare una stringa che viene inviata alla pipeline.

L'iniezione -1all'inizio garantisce che la stringa originale verrà stampata, poiché è il primo elemento e un indice non corrisponderà mai -1.

q / kdb +, 27 10 byte

Soluzione:

{x _\0N,y}

Esempi:

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

Spiegazione:

Sfrutta la funzionalità di convergenza\ e 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)

Appunti:

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!