(fortemente inspirado no elemento String no índice especificado )

Dada uma sequência se um número inteiro nrepresentando um índice s, imprima scom o caractere na n-ésima posição removida.

A indexação 0 e a indexação 1 são permitidas.

• Para a indexação 0, nserá não negativo e menor que o comprimento de s.
• Para a indexação 1, nserá positivo e menor ou igual ao comprimento de s.

sconsistirá apenas em caracteres ASCII imprimíveis ( \x20-\x7Eou  completos ~).

Qualquer entrada / saída razoável é permitida. Aplicam-se brechas padrão .

Casos de teste (indexados 0):

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

Casos de teste (indexados 1):

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

Isso é código-golfe , então a resposta mais curta em bytes vence.

C #, 20 19 bytes

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

Alice , 13 12 bytes

Agradecemos a Leo por economizar 1 byte.

/oI\!e]&
@ q

Experimente online!

A primeira linha da entrada é a sequência, a segunda linha é o índice baseado em 0.

Explicação

/    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.

Japonês , 2 bytes

jV

Experimente online!

K (Kona), 1 byte

_

Conseguiu amar builtins. Indexação baseada em 0. Uso:

k)"abcdef" _ 3
"abcef"

Haskell , 28 24 bytes

-4 bytes graças a Laikoni, esta versão é 1 indexada.

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

Resposta antiga:

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

Uma função recursiva simples que aceita o valor, é indexada em 0.

Minha primeira vez em código de golfe, então talvez não seja a solução ideal. Ah bem.

Mathematica, 18 bytes

Indexado 1

#2~StringDrop~{#}&

entrada

[1, "abcde"]

obrigado Martin Ender

V , 3 bytes

À|x

Experimente online!

Isso usa 1 indexação.

CJam , 4 bytes

q~Lt

Experimente online!

Explicação

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.

Função GCC c, 25

Indexação baseada em 1.

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

Muito comportamento indefinido aqui, então cuidado com os velociraptores dispersos :

• A strcpy()página do manual diz que, se a cópia ocorrer entre objetos que se sobrepõem, o comportamento é indefinido . Aqui há claramente sobreposição do src e dest seqüências , mas parece funcionar, então o glibc é mais cuidadoso ou tive sorte.
• A resposta depende do fato de que isso s+=nacontece antes da s-1. O padrão c não oferece tais garantias e, de fato, chama isso de comportamento indefinido. Novamente, parece funcionar conforme necessário com o compilador gcc no x86_64 Linux.

Experimente online .

MATL , 3 bytes

&)&

Usa indexação baseada em 1.

Experimente online! Ou verifique todos os casos de teste .

Explicação

&    % 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

Na versão modificada com todos os casos de teste, o código fica dentro de um loop infinito `...Taté que nenhuma entrada seja encontrada. No final de cada iteração, a função display ( XD) é explicitamente chamada e a pilha é limpa ( x) para prepará-la para a próxima iteração.

Vim, 7 bytes

jDk@"|x

Como funciona:

Ele espera duas linhas; um com a corda e outro com o número.

1. Vá para a linha dois, copie o número no registro
2. Vá para a primeira linha e depois vá para a coluna no registro com @ "|
3. Exclua o caractere sob o cursor

Java 8, 39 bytes

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

Experimente aqui.

Java 7, 67 bytes

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

Experimente aqui.

Ruby , 16 bytes

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

Experimente online!

Haskell , 15 bytes

Isso requer o GHC 8.4.1 lançado recentemente (ou superior). Agora <> , como uma função nos Semigrupos, está no Prelúdio. É particularmente útil na função Semigroup

take<>drop.succ

Experimente online!
Como o tio está usando uma versão mais antiga do GHC, importei <>no cabeçalho.

R, 40 bytes

Apenas mostra as várias maneiras, nenhuma das quais particularmente compacta, você pode mexer nas cordas em R.

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

05AB1E , 5 bytes

ā²ÊÏJ

Experimente 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 bytes

vNÊiy?

Experimente online!

Explicação

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

Pitão, 3 bytes

.DE

Experimente aqui.

Leva o índice primeiro.

PHP, 42 bytes

0 indexado

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

Experimente online!

JS (ES6), 41 32 31 bytes

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

Com base nisso . Toma entrada através de currying, primeiro é string, segundo é índice.

-9 graças a @JohanKarlsson

-1 graças a @ETHproductions

Geléia , 3 bytes

Ṭœp

Um programa completo que pega o índice (com base em 1) e a sequência (nessa ordem) e imprime o resultado.

Como uma função diádica, ele retorna uma lista das duas partes.

De fato, o índice pode ser uma lista de n índices; nesse caso, ele retorna uma lista das n-1 partes.

Experimente online! ou consulte uma suíte de testes .

Quão?

Ṭœ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

Como um exemplo do uso de vários índices:

      "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

Recebe entrada indexada em 1 no seguinte 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

Obrigado a @DJMcMayhem por 3 bytes!

Java 8, 45 41 bytes

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

Guardado 4 bytes graças a @ OlivierGrégoire

Meu primeiro código de golfe responde em algo diferente de C #, mesmo que ainda não seja o mais curto para Java.

Python 3 , 24 bytes

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

Experimente online!

JavaScript (ES6), 39 34 33 bytes

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

• 5 6 bytes salvos graças a Arnauld .

brainfuck , 14 bytes

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

Experimente online!

Lê o índice de um byte baseado em zero imediatamente seguido pela string.

Befunge-98 , 35 27 25 bytes

-4 bytes graças a @ eush77

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

Experimente online!

Indexado em 1, observe que a entrada possui um byte nulo à direita.

PHP, 41 bytes, 35 bytes excluindo? Php

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

Indexado a 0

TIO

Japonês , 3 2 bytes

jV

Experimente online!

R, 48 47 bytes

(1 byte economizado com o uso de el()graças a Giuseppe)

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

Divida a string em seus caracteres individuais, remova a enésima e concatene novamente.

Pode muito bem haver uma solução melhor, strsplit () é bastante complicado, pois retorna uma lista.