(fortemente ispirato all'elemento stringa nell'indice specificato )

Data una stringa se un numero intero che nrappresenta un indice in s, l'output viene rimosso scon il carattere nella nposizione -th.

0-indicizzazione e 1-indicizzazione sono consentiti.

• Per l'indicizzazione 0, nsarà non negativo e inferiore alla lunghezza dis .
• Per 1-indicizzazione, nsarà positivo e minore o uguale alla lunghezza di s.

ssarà composto solo da caratteri ASCII stampabili ( \x20-\x7Eo  tramite~ ).

È consentito qualsiasi input / output ragionevole. Scappatoie standard applicano .

Testcase (indicizzati 0):

n s        output
0 "abcde"  "bcde"
1 "abcde"  "acde"
2 "a != b" "a = b"
3 "+-*/"   "+-*"
4 "1234.5" "12345"
3 "314151" "31451"

Test (1-indicizzato):

n s        output
1 "abcde"  "bcde"
2 "abcde"  "acde"
3 "a != b" "a = b"
4 "+-*/"   "+-*"
5 "1234.5" "12345"
4 "314151" "31451"

Questo è code-golf , quindi vince la risposta più breve in byte.

C #, 20 19 byte

s=>n=>s.Remove(n,1)

Alice , 13 12 byte

Grazie a Leo per aver salvato 1 byte.

/oI\!e]&
@ q

Provalo online!

La prima riga dell'input è la stringa, la seconda riga è l'indice in base 0.

Spiegazione

/    Reflect to SE. Switch to Ordinal. While in Ordinal mode, the IP bounces
     diagonally up and down through the code.
I    Read the first line of input (the string).
!    Store the string on the tape, which writes the characters' code points to 
     consecutive cells (the tape is initialised to all -1s).
]    Move the tape head right. This moves it by an entire string, i.e. to the
     cell after the -1 that terminates the current string.
     The IP bounces off the bottom right corner and turns around.
]    Move the tape head right by another cell.
!    Store an implicit empty string on the tape, does nothing. It's actually
     important that we moved the tape head before this, because otherwise it
     would override the first input code point with a -1.
I    Read the second line of input (the index) as a string.
/    Reflect to W. Switch to Cardinal.
     The IP wraps around to the last column.
&]   Implicitly convert the first input to the integer value it contains
     (the index) and move the tape head that many cells to the right, i.e.
     onto the character we want to delete. Note that Ordinal and Cardinal mode
     have two independent tape heads on the same tape, so the Cardinal tape
     head is still on the first cell of the string input before we do this.
e!   Store a -1 in the cell we want to delete.
\    Reflect to SW. Switch to Ordinal.
q    Push the entire tape contents as a single string. This basically takes
     all cells which hold valid code points from left to right on the tape 
     and concatenates the corresponding characters into a single string. Since
     we wrote a -1 (which is not a valid code point) over the target character,
     this will simply push the entire input string without that character.
o    Output the result.
@    Terminate the program.

Japt , 2 byte

jV

Provalo online!

K (Kona), 1 byte

_

Devi amare i builtin. Indicizzazione basata su 0. Uso:

k)"abcdef" _ 3
"abcef"

Haskell , 28 anni 24 byte

-4 byte grazie a Laikoni, questa versione è 1-indicizzata.

s#n=take(n-1)s++drop n s

Vecchia risposta:

f(s:t)0=t;f(s:t)n=s:f t(n-1)

Una semplice funzione ricorsiva che accetta il valore, è indicizzata a 0.

Il mio primo gioco di golf a codice quindi forse non è la soluzione ottimale. Oh bene.

Mathematica, 18 byte

1-indicizzato

#2~StringDrop~{#}&

ingresso

[1, "abcde"]

grazie Martin Ender

V , 3 byte

À|x

Provalo online!

Questo utilizza 1-indicizzazione.

CJam , 4 byte

q~Lt

Provalo online!

Spiegazione

q~    e# Read and eval input (push the string and number to the stack).
  Lt  e# Set the nth element of the string to the empty string.

Funzione GCC c, 25

Indicizzazione basata su 1.

f(n,s){strcpy(s-1,s+=n);}

Un sacco di comportamenti indefiniti qui, quindi fai attenzione ai velociraptor vaganti :

• La strcpy()pagina man dice Se la copia avviene tra oggetti che si sovrappongono, il comportamento non è definito . Qui c'è chiaramente la sovrapposizione delle stringhe src e dest , ma sembra funzionare, quindi o glibc è più attento o sono stato fortunato.
• La risposta dipende dal fatto che ciò s+=naccade prima del s-1. Lo standard c non fornisce tali garanzie e, in effetti, lo definisce un comportamento indefinito. Ancora una volta, sembra funzionare come richiesto con il compilatore gcc su x86_64 Linux.

Provalo online .

MATL , 3 byte

&)&

Utilizza l'indicizzazione basata su 1.

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

&    % Specify secondary default number of inputs/outputs for next function
)    % Implicitly input string and number. Index: with & it pushes the char
     % defined by the index and the rest of the string
&    % Specify secondary default number of inputs/outputs for next function
     % Implicitly display (XD): with & it only displays the top of the stack

Nella versione modificata con tutti i casi di test, il codice è all'interno di un ciclo infinito `...Tfino a quando non viene trovato alcun input. Alla fine di ogni iterazione XDviene esplicitamente chiamata la funzione display ( ) e lo stack viene cancellato ( x) per prepararlo alla successiva iterazione.

Vim, 7 byte

jDk@"|x

Come funziona:

Si aspetta due righe; uno con la stringa e uno con il numero.

1. Vai alla riga due, copia il numero nel registro
2. Vai alla prima riga e poi vai alla colonna nel registro con @ "|
3. Elimina il carattere sotto il cursore

Java 8, 39 byte

s->n->s.substring(0,n)+s.substring(n+1)

Provalo qui.

Java 7, 67 byte

String c(int n,String s){return s.substring(0,n)+s.substring(n+1);}

Provalo qui.

Rubino , 16 byte

->n,s{s[n]='';s}

Provalo online!

Haskell , 15 byte

Ciò richiede il GHC 8.4.1 (o successivo) rilasciato di recente. Ora <> , in funzione dei semigruppi, è in Preludio. È particolarmente utile sulla funzione Semigruppo

take<>drop.succ

Provalo online!
Poiché tio sta utilizzando una versione precedente di GHC, ho importato <>nell'intestazione.

R, 40 byte

Va solo a mostrare la varietà di modi, nessuno dei quali particolarmente compatto, puoi armeggiare con le corde in R.

function(s,n)intToUtf8(utf8ToInt(s)[-n])

05AB1E , 5 byte

ā²ÊÏJ

Provalo online!

ā     # push range(1, len(input string) + 1)
 ²Ê   # Check each for != to input index
   Ï  # Keep characters from input where this array is 1
    J # Join

05AB1E , 6 byte

vNÊiy?

Provalo online!

Spiegazione

v       # for each element, index (y,N) in input1
 NÊi    # if N is not equal to input2
    y?  # print y

Pyth, 3 byte

.DE

Provalo qui.

Indica prima l'indice.

PHP, 42 byte

0 indicizzato

<?=substr_replace($argv[1],"",$argv[2],1);

Provalo online!

JS (ES6), 41 32 31 byte

y=>i=>y.slice(0,i++)+y.slice(i)

Sulla base di questo . Accetta input tramite curry, il primo è stringa, il secondo è indice.

-9 grazie a @JohanKarlsson

-1 grazie a @ETHproductions

Gelatina , 3 byte

Ṭœp

Un programma completo che prende l'indice (basato su 1) e la stringa (in quell'ordine) e stampa il risultato.

Come funzione diadica restituisce un elenco delle due parti.

In effetti l'indice può essere un elenco di n indici, nel qual caso restituisce un elenco delle parti n-1 .

Provalo online! o vedere una suite di test .

Come?

Ṭœp - Main link: number i, string s                   e.g. "fish 'n chips", 6
Ṭ   - untruth - get a list with 1s at the indexes of i      000001 <-- i.e. [0,0,0,0,0,1]
 œp - partition s at truthy indexes without borders       ["fish ","n chips"]
    - implicit print                                        fish n chips

Come esempio di utilizzo di più indici:

      "fish and chips", [6,8]
Ṭ      00000101 <- i.e. [0,0,0,0,0,1,0,1]
 œp  ["fish ","n"," chips"] 
       fish n chips

vim, 10 7

DgJ@"|x

Accetta 1 input indicizzato nel seguente formato:

2
abcde

D      delete the number on the first line into register "
gJ     remove the newline while preserving whitespace on line 2
@"     run the " register as a macro - input is used as a count for...
|      the "go to nth column" command
x      delete the character at the cursor

Grazie a @DJMcMayhem per 3 byte!

Java 8, 45 41 byte

s->n->new StringBuffer(s).deleteCharAt(n)

Salvato 4 byte grazie a @ OlivierGrégoire

Il mio primo codice golf risponde in qualcosa di diverso da C #, anche se non è ancora il più breve per Java.

Python 3 , 24 byte

lambda n,a:a[:n]+a[n+1:]

Provalo online!

JavaScript (ES6), 39 34 33 byte

n=>s=>s.replace(/./g,c=>n--?c:"")

• 5 6 byte salvati grazie ad Arnauld .

Brainfuck , 14 byte

,[>,.<-],,[.,]

Provalo online!

Legge l'indice di un byte in base zero immediatamente seguito dalla stringa.

Befunge-98 , 35 27 25 byte

-4 byte grazie a @ eush77

&#;1-:!#v_~,;
_@#:~;#~<;,

Provalo online!

1 indicizzato, notare che l'input ha un byte null finale.

PHP, 41 byte, 35 byte escluso? Php

<?php $argv[1][$argv[2]]='';echo$argv[1];

0-indicizzato

TIO

Japt , 3 2 byte

jV

Provalo online!

R, 48 47 byte

(1 byte salvato grazie all'uso di el()grazie a Giuseppe)

function(s,n)cat(el(strsplit(s,""))[-n],sep="")

Dividi la stringa nei suoi singoli caratteri, rimuovi l'ennesimo e poi concatena nuovamente.

Potrebbe esserci una soluzione migliore, strsplit () è piuttosto ingombrante in quanto restituisce un elenco.