Elemento da string no índice especificado

13

Dada uma sequência se um número não negativo nmenor que o comprimento de s, produza o caractere na n-ésima posição de s.

Indexação 0 e indexação 1 são permitidas. Para a indexação 1, nserá positivo e menor ou igual ao comprimento de s.

s consistirá apenas em caracteres imprimíveis.

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

Casos de teste (indexação 0):

n s        output
0 "abcde"  a
1 "abcde"  b
2 "a != b" !
3 "+-*/"   /
4 "314159" 5

Casos de teste (indexação 1):

n s        output
1 "abcde"  a
2 "abcde"  b
3 "a != b" !
4 "+-*/"   /
5 "314159" 5

Isso é , então a resposta mais curta em bytes vence.

Freira Furada
fonte
13
Eu diminuí a votação porque não é realmente um desafio de programação ou golfe; tudo o que está sendo perguntado aqui é essencialmente qual idioma tem o menor tempo para o trabalho.
Salsicha
15
@Shaggy O mesmo para muitos outros desafios simples, como adicionar dois números, testar se um número é primo ou imprimir "Olá, mundo!". Embora eles sejam entediantes em muitos idiomas que podem fazê-lo imediatamente, eles podem ser desafios interessantes para idiomas mais primitivos que precisam implementar sua própria implementação. Além disso, qualquer coisa mais complicada geralmente é pedir muito a esses idiomas, por isso é bom ter uma saída para eles. Se desafios triviais o incomodam, tente enfrentá-los em um idioma não trivial.
Martin Ender

Respostas:

9

MATL , 1 byte

)

Experimente online!

Bem, é difícil torná-lo muito mais simples. )indexa a primeira entrada, usando o segundo valor de entrada. Isso é indexado em 1.

Stewie Griffin
fonte
7

Alice , 5 bytes

I&IO@

Experimente online!

Como de costume, é muito mais curto se evitarmos o modo Ordinal e usarmos um formato de entrada abismal. Aqui, o ponto de código do primeiro caractere é usado como a entrada inteira . O restante da entrada é a sequência. O índice é baseado em 1.

Explicação

I   Read a character and push its code point.
&I  Read that many more characters and push them.
O   Output the last one we read.
@   Terminate the program.
Martin Ender
fonte
abysmal- Eu pensei que você fez isso xD
Stephen
@StephenS Você quer dizer que propus este formato de E / S na meta? Sim, sim, mas principalmente para idiomas que teriam que implementar seu próprio analisador / renderizador de número decimal decimal cada vez que competem em um desafio com E / S numérica, então provavelmente ignorariam completamente esses. Mas tem o infeliz efeito colateral de que, em alguns idiomas que sabem ler e escrever decimais com bastante facilidade, ainda é mais curto usar pontos de código.
Martin Ender
6

Python, 15 bytes

str.__getitem__

ou

lambda s,i:s[i]

Ambos recebem 2 argumentos: a string e o índice. Indexado a 0.

Artyer
fonte
Estou surpreso que os dois métodos tenham o mesmo comprimento.
Freira vazando
6

Haskell, 4 bytes

(!!)

Indexação baseada em 0. Exemplo de uso: (!!) "Hello" 1-> 'e'.

nimi
fonte
5

Oitava, 10 bytes

@(s,n)s(n)

Pega uma string se um número ncomo entrada e retorna o nth caractere de s.

Stewie Griffin
fonte
5

Retina , 28 20 19 bytes

Economizou 8 bytes graças a @MartinEnder por não usar grupos de balanceamento

Economizou 1 byte graças a @ mbomb007 usando em ^.+vez de^\d+

^.+
$*
+`1¶.
¶
!1`.

Experimente online!

O programa é indexado em 0.

Kritixi Lithos
fonte
Mude \dpara .para salvar um byte.
Mbomb007
@ mbomb007 Obrigado pela dica :)
Kritixi Lithos
3

Alice , 10 bytes

/@!O?]&
 I

Experimente online!

Espera a sequência na primeira linha e o índice baseado em 0 na segunda linha.

Explicação

Apesar de sua riqueza de embutidos, a indexação de strings não existe em Alice. O motivo é que ele requer um número inteiro e um parâmetro de string, e todos os comandos em Alice são estritamente números inteiros para inteiros ou cadeias para cadeias.

Em geral, a principal maneira de executar qualquer operação em cadeias que exijam ou resultem em números inteiros é armazenar a cadeia na fita no modo Ordinal, que você pode manipular com números inteiros no modo Cardinal.

/    Reflect to SE. Switch to Ordinal. While in Ordinal mode, the IP bounces
     diagonally up and down through the program.
I    Read one line from STDIN and push it.
!    Store the string on the tape. This writes the character codes into consecutive
     tape cells starting at the tape head. (It also writes a -1 at the end as a
     terminator, but the tape is initialised to -1s anyway).

     The next few commands are junk that luckily doesn't affect the program:

?      Load the string from the tape and push it to the stack again.
&      Fold the next command over this string. That is, for each character
       in the string, push that character, then execute the command.
?      So we're folding "load" over the string itself. So if the string is "abc"
       we'll end up with "a" "abc" "b" "abc" "c" "abc" on the stack.
!      Store the top copy of "abc" on the tape (does nothing, because it's
       already there).

     Now the relevant part of the program continues.

I    Read another line from STDIN, i.e. the string representation of the index.
/    Reflect to W. Switch to Cardinal. The IP wraps to the last column.
&    Implicitly convert the string to the integer value it represents and
     repeat the next command that many times.
]    Move the tape head right that many cells. Note that Ordinal and Cardinal
     mode have separate tape heads, but they are initialised to the same cell.
?    Load the value from that cell, which is the code point of the character
     at the given index.
O    Print the corresponding character.
!    This discards or converts some of the strings on the stack and writes some
     value back to the tape, but it's irrelevant.
@    Terminate the program.
Martin Ender
fonte
1
"Apesar de sua riqueza de embutidos, a indexação de strings não existe em Alice." > _>
Freira vazada
1
@LeakyNun Se você acha que isso é ruim, também não há um built-in para obter o comprimento de uma string. ;)
Martin Ender
3

Brachylog , 2 bytes

∋₎

Experimente online!

Explicação

unifica sua saída com um elemento da entrada. Com como subscrito, ele unificará sua saída com o Ielemento th de S, com [S,I]como entrada.

Fatalizar
fonte
3

Cubix , 8 bytes

t@poIA//

Esta solução é 1 indexada. A entrada deve consistir primeiro em um número, depois em um separador (que não é um dígito ou um. ) e depois na sequência.

Experimente online!

Lucas
fonte
2

SILOS , 43 bytes

loadLine
readIO
a=256+i
a=get a
printChar a

Experimente online!

Simples o suficiente.

Rohan Jhunjhunwala
fonte
SILOS está de volta \ o /
Leaky Nun
1
Sim, estou tentando responder ao maior número possível de desafios, incluindo a tela de carregamento do Windows. Eu gosto do ponto em que se trata em termos de saída gráfica e bibliotecas, mas ainda gostaria de desenvolver um esquema de compactação para tentar obtê-lo competitivo. Essencialmente, o int [] que ele compila pode ser gerado através da leitura de um fluxo de bytes. @LeakyNun
Rohan Jhunjhunwala
2

BF , 9 bytes

,[->,<]>.

O índice é obtido pelo código de caractere de um caractere (como o envio de Alice). Depois disso, temos a string.

Experimente online!

O link TIO usa um wrapper Bash e a entrada pode ser alterada no arquivo de cabeçalho (o motivo do wrapper é para que possamos ver os bytes).

Kritixi Lithos
fonte
Legit TIO hacking: p
Leaky Nun,
@LeakyNun Eu usei o wrapper para BF .
Kritixi Lithos
1
Eu disse que é legítimo.
Leaky Nun
Existe uma maneira de inserir dados em outros idiomas TIO como esse? Gosta de SMBF?
Mbomb007
@ mbomb007 Você deve conseguir fazer isso em outros idiomas usando seus invólucros. Aqui está o wrapper para SMBF
Kritixi Lithos
2

JavaScript, 11 10 bytes

s=>n=>s[n]

Usa indexação baseada em 0.

-1 byte graças a @Leaky Nun

f=
s=>n=>s[n]
console.log(f("abcde")(0));
console.log(f("abcde")(1));
console.log(f("a != b")(2));
console.log(f("+-*/")(3));
console.log(f("314159")(4));

Stephen
fonte
1
você pode usar currying s=>i=>s[i]para salvar um byte
Leaky Nun
1
Toda vez que vejo respostas como essa, me incomoda porque sei que a versão C # é sempre um byte a mais para o ponto e vírgula no final. E isso é realmente o caso aqui
TheLethalCoder
2

> <> , 13 + 1 = 14 bytes

+1 para o -vsinalizador receber entrada

:?!\i~1-
io;\

Obrigado a @steenbergh por me notificar sobre o-v bandeira e salvar 3 bytes!

Insira o índice com o argumento da linha de comandos -v [index] (indexado 0) e insira a sequência através de stdin.

Experimente online!

Explicação

A pilha começa com o índice no topo.
:duplica.
?ignora o próximo caractere se o índice for 0. (Retirando-o da pilha)
Se for zero, \reflete a direção para descer. Então, é refletido à direita com a próxima \. Ele envolve e executa input um caractere, output e ;interrompe a execução.
Caso contrário, !pula a próxima instrução, para que ela não desça.
i~insere um caractere e o descarta imediatamente.
1empurra 1.
-subtrai 1do índice, portanto, um caractere na entrada é consumido e o índice é decrementado. O programa volta para o arquivo :.

Artyer
fonte
1
Há o -v <x>parâmetro da linha de comando, que inicializa a pilha para manter o <x>início do programa. Experimente online
steenbergh
2

Cenoura , 16 bytes

$^//.{#}/S1//.$/

Experimente online!

O formato de entrada é o seguinte:

string
index

E o programa é 1 indexado.

Explicação

O Carrot possui várias variáveis ​​globais, uma para cada tipo: string, float e array (outras a serem implementadas em breve). O programa inicia no modo de sequência, onde todos os operadores afetam a variável de sequência global. E eu chamo essas variáveis ​​de "pilha".

(Exemplo de entrada: abcdef\n3)

$                          Get the first line of the input and set the stack-string to this value
^                          Exit caret-mode
                           stack-string = "abcdef"
/                          Operator (behaves differently depending on the argument)
 /.{#}/                     And the argument to this operator is a regex, so this program gets the matches of this regex into the stack-array
  .                          Any character
   {#}                       Pops a line from the input. So now this evaluates to # of any character where # is the second line of the input (in this case, 3)
                           stack-array = ["abc"]
                           And now we just need to get the last character in this string, but first
S1                         Join the array on the number 1 and set this to the stack-string. Because the array only contains one element, the number 1 does not appear in the stack-string.
                           stack-string = "abc"
/                          Operator; because the argument is a regex, this retrieves the matches of the regex:
 /.$/                       Get the last character in the string
                           stack-array = ["c"]

Agora isso retorna uma matriz de um elemento contendo uma sequência de comprimento um, mas é mostrada como uma sequência no site.

Se realmente quiséssemos fornecer o resultado como uma string, poderíamos fazê-lo facilmente S","no final, mas isso não importa, porque a saída ainda parece a mesma no intérprete.

Kritixi Lithos
fonte
1

Lote, 32 bytes

@set/ps=
@call echo(%%s:~%1,1%%

sde STDIN e usa ncomo um parâmetro de linha de comando.

Neil
fonte
1

GolfScript , 7 4 bytes

~1/=

Experimente online!

Eu sugiro o GolfScript, então valorizo a ajuda de Martin Ender .

Erik, o Outgolfer
fonte
Não há necessidade de [.
Martin Ender
Mas, em geral, se você quiser personagens de cordas, basta dividir a string primeira vez de converter o ponto de código de volta:~1/=
Martin Ender
@MartinEnder e é assim que você bate Alice-se ...
Erik as Outgolfer
1

Turtlèd , 9 bytes

!?:[*l+].

Experimente online!

explicação:

Primeiro, Turtlèd é baseado em grade, com uma coisa de tartaruga. Existem células da grade em que a tartaruga pode se mover para a esquerda, para cima, para baixo e para a direita, e pode escrever coisas nas células da grade.

[the first grid cell the turtle starts on is marked with a *]
!         input the string into the string variable

 ?        input the number into the number variable

  :       this command takes the number variable and moves right that many.
          hence this moves right by the amount inputted

   [*  ]  this is an `until` loop. the * there means that `until` the turtle ends the loop
          on a grid cell with * written on it (that is, the first cell), it will execute
          the code inside again and again

     l+   the code inside the while loop. the `l` moves the turtle left, and the +
          increments the string pointer. the string pointer is used with the string var;
          when you want to write something from the string, you use `.`, which writes
          the pointed char. the pointed char is the n-th character of the string, n being
          the value of the string pointer. this code will execute until the l moves
          the turtle back on to the origin cell. since we moved right by the number
          inputted, this will increase the string pointer (which starts at 1)
          by the amount inputted.

       .  write the pointed char, which was dealt with in the previous comment.
          if 0 is inputted, turtle stayed on the origin square, and executed none
          of the loop, and turtle writes the first char of string input.
          if 1 is inputted, turtle moved one right, moved one left and incremented
          string pointer once, which means the second char is written. and so on.


          [the char of input has been written over the origin square]
          [implicitly the grid is outputted, which has spaces and blank lines taken out]
          [this is the requested char outputted, plus an unavoidable trailing newline
          due to how I made the interpreter. sue me]
Limão destrutível
fonte
1

Clojure, 3

nth

: P O que você pode fazer quando houver um built-in para isso? Isso funciona em listas, vetores, strings e sequências. É O (1) ou O (n), dependendo do tipo de dados usado.

NikoNyrh
fonte
1

sed , 31 bytes

:
/^1/{s:1 .: :;b}
s: (.).*:\1:

Experimente online!

Entrada: índice e a sequência, separados por um espaço. Índice em unário, mas com base em zero.

eush77
fonte
1

Dyvil , 4 bytes

_[_]

Cria uma função anônima que leva um Stringe um inte retorna umchar .

Uso:

let f: (String, int) -> char = _[_]
print f("abc", 1) // b
Clashsoft
fonte
1

QBasic 4.5, 24 bytes

INPUT a$,b:?MID$(a$,b,1)

Bem direto.

steenbergh
fonte
1

Mathematica, 18 bytes

#~StringTake~{#2}&

Solução básica, mas infelizmente o nome da função é bastante longo.

numbermaniac
fonte
1

C #, 11 bytes

s=>n=>s[n];
TheLethalCoder
fonte