Dada una cadena sy un número no negativo nmenor que la longitud de s, muestra el carácter en la nposición -th de s.

La indexación 0 y la indexación 1 están permitidas. Para la indexación 1, nserá positiva y menor o igual que la longitud de s.

s consistirá solo en caracteres imprimibles.

Se permite cualquier entrada / salida razonable. Se aplican lagunas estándar .

Casos de prueba (indexación 0):

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

Casos de prueba (1 indexación):

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

Este es el código de golf , por lo que la respuesta más corta en bytes gana.

MATL , 1 byte

)

Pruébalo en línea!

Bueno, es difícil hacerlo mucho más simple. )indexa la primera entrada, utilizando el segundo valor de entrada. Esto es 1 indexado.

Alice , 5 bytes

I&IO@

Pruébalo en línea!

Como de costumbre, es mucho más corto si evitamos el modo Ordinal y usamos un formato de entrada abismal. Aquí, el punto de código del primer carácter se usa como entrada entera . El resto de la entrada es la cadena. El índice está basado en 1.

Explicación

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.

Python, 15 bytes

str.__getitem__

o

lambda s,i:s[i]

Ambos toman 2 argumentos: la cadena y el índice. 0 indexado.

Haskell, 4 bytes

(!!)

Indexación basada en 0. Ejemplo de uso:(!!) "Hello" 1 -> 'e'.

Octava, 10 bytes

@(s,n)s(n)

Toma una cadena sy un número ncomo entrada, y devuelve el ncarácter th de s.

Retina , 28 20 19 bytes

Ahorró 8 bytes gracias a @MartinEnder al no usar grupos de equilibrio

Guardado 1 byte gracias a @ mbomb007 usando en ^.+lugar de^\d+

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

Pruébalo en línea!

El programa está indexado a 0.

05AB1E , 1 byte

0 indexado.

è

Pruébalo en línea!

Alice , 10 bytes

/@!O?]&
 I

Pruébalo en línea!

Espera la cadena en la primera línea y el índice basado en 0 en la segunda línea.

Explicación

A pesar de su gran cantidad de elementos integrados, la indexación de cadenas no existe en Alice. La razón es que requiere un parámetro entero y un parámetro de cadena, y todos los comandos en Alice son estrictamente enteros a enteros o cadenas a cadenas.

En general, la forma principal de realizar cualquier operación en cadenas que requieran o den como resultado enteros es almacenar la cadena en la cinta en modo Ordinal, que luego puede manipular con enteros en 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.

Jalea , 1 byte

ị

Pruébalo en línea!

Prólogo (SWI) , 40 37 bytes

q(L,N,A):-nth0(N,L,X),char_code(A,X).

Pruébalo en línea!

Brachylog , 2 bytes

∋₎

Pruébalo en línea!

Explicación

∋unifica su salida con un elemento de la entrada. Con ₎como subíndice, unificará su salida con el Ielemento th de S, [S,I]como entrada.

Cubix , 8 bytes

t@poIA//

Esta solución está 1 indexada. La entrada debe consistir primero en un número, luego en un separador (que no sea un dígito o un a .) y luego la cadena.

Pruébalo en línea!

CJam , 3 bytes

{=}

Pruébalo en línea!

= es el incorporado para la indexación de listas / cadenas.

Japt , 2 bytes

gV

Esta solución está indexada en 0.

Pruébalo en línea!

SILOS , 43 bytes

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

Pruébalo en línea!

Suficientemente simple.

BF , 9 bytes

,[->,<]>.

El índice se toma a través del código de carácter de un personaje (como el envío de Alice). Después de eso, tenemos la cadena.

Pruébalo en línea!

El enlace TIO utiliza un contenedor Bash y la entrada se puede cambiar en el archivo de encabezado (el motivo del contenedor es para que podamos ver los bytes).

JavaScript 11 10 bytes

s=>n=>s[n]

Utiliza indexación basada en 0.

-1 byte gracias 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));

> <> , 13 + 1 = 14 bytes

+1 para que la -vbandera tome entrada

:?!\i~1-
io;\

Gracias a @steenbergh por notificarme sobre el-v bandera y 3 bytes!

Ingrese el índice con el argumento de línea de comando -v [index] (indexado a 0) e ingrese la cadena a través de stdin.

Pruébalo en línea!

Explicación

La pila comienza con el índice en la parte superior.
:lo duplica
?ignora el siguiente carácter si el índice es 0. (Sacando de la pila)
Si es cero, \refleja la dirección hacia abajo. Luego, se refleja a la derecha con el siguiente \. Se envuelve y ejecuta input un personaje,o emite y ;detiene la ejecución.
Si no, !omite la siguiente instrucción, para que no se caiga.
i~ingresa un carácter y luego lo descarta inmediatamente.
1empuja 1.
-resta 1del índice, por lo que se consume un carácter en la entrada y se disminuye el índice. El programa vuelve a la :.

Zanahoria , 16 bytes

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

Pruébalo en línea!

El formato de entrada es como tal:

string
index

Y el programa está indexado en 1.

Explicación

Carrot tiene varias variables globales, una para cada tipo: string, float y array (otras se implementarán pronto). El programa comienza en modo cadena, donde todos los operadores afectarán la variable global de cadena. Y llamo a estas variables la "pila".

(Ejemplo 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"]

Ahora esto devuelve una matriz de un elemento que contiene una cadena de longitud uno, pero se muestra como una cadena en el sitio web.

Si realmente quisiéramos dar el resultado como una cadena, podríamos hacerlo fácilmente S","al final, pero no importa porque la salida todavía se ve igual en el intérprete.

Lote, 32 bytes

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

Lee sdesde STDIN y toma ncomo parámetro de línea de comandos.

GolfScript , 7 4 bytes

~1/=

Pruébalo en línea!

Apelo en GolfScript, así que valoro la ayuda de Martin Ender .

Turtlèd , 9 bytes

!?:[*l+].

Pruébalo en línea!

explicación:

En primer lugar, Turtlèd se basa en la cuadrícula, con una cosa de tortuga. Hay celdas de cuadrícula que la tortuga puede mover hacia la izquierda, arriba, abajo y derecha, y puede escribir cosas en las celdas de la cuadrícula.

[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]

Clojure, 3

nth

: P ¿Qué puedes hacer cuando hay una función incorporada para esto? Esto funciona en listas, vectores, cadenas y secuencias. Es O (1) u O (n), según el tipo de datos utilizado.

sed , 31 bytes

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

Pruébalo en línea!

Entrada: índice y la cadena, separados por un espacio. Índice en unario, pero basado en cero.

Dyvil , 4 Bytes

_[_]

Crea una función anónima que toma ay Stringan inty devuelve unchar .

Uso:

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

Pip , 3 bytes

a@b

Esto está basado en 0. Pruébalo en línea!

QBasic 4.5, 24 bytes

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

Muy claro.

Vim, 8 bytes

DJ@"|xVp

Como V es compatible con versiones anteriores, ¡puede probarlo en línea!

Mathematica, 18 bytes

#~StringTake~{#2}&

Solución básica, pero desafortunadamente el nombre de la función es bastante largo.

C #, 11 bytes

s=>n=>s[n];