Étant donné une chaîne set un nombre non négatif ninférieur à la longueur de s, affichez le caractère à la n-ième position de s.

L'indexation 0 et l'indexation 1 sont autorisées. Pour l'indexation 1, nsera positif et inférieur ou égal à la longueur de s.

s sera composé uniquement de caractères imprimables.

Toute entrée / sortie raisonnable est autorisée. Des échappatoires standard s'appliquent.

Cas de test (indexation 0):

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

Cas de test (1-indexation):

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

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

MATL , 1 octet

)

Essayez-le en ligne!

Eh bien, difficile de le rendre beaucoup plus simple. )indexe la première entrée, en utilisant la deuxième valeur d'entrée. Ceci est indexé 1.

Alice , 5 octets

I&IO@

Essayez-le en ligne!

Comme d'habitude, il est beaucoup plus court si nous évitons le mode Ordinal et utilisons un format d'entrée abyssal. Ici, le point de code du premier caractère est utilisé comme entrée entière . Le reste de l'entrée est la chaîne. L'index est basé sur 1.

Explication

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 octets

str.__getitem__

ou

lambda s,i:s[i]

Les deux prennent 2 arguments: la chaîne et l'index. 0 indexé.

Haskell, 4 octets

(!!)

Indexation basée sur 0. Exemple d'utilisation: (!!) "Hello" 1-> 'e'.

Octave, 10 octets

@(s,n)s(n)

Prend une chaîne set un nombre nen entrée et renvoie le ne caractère de s.

Rétine , 28 20 19 octets

8 octets enregistrés grâce à @MartinEnder en n'utilisant pas de groupes d'équilibrage

1 octet enregistré grâce à @ mbomb007 en utilisant ^.+au lieu de^\d+

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

Essayez-le en ligne!

Le programme est indexé 0.

05AB1E , 1 octet

0 indexé.

è

Essayez-le en ligne!

Alice , 10 octets

/@!O?]&
 I

Essayez-le en ligne!

Attend la chaîne sur la première ligne et l'index basé sur 0 sur la deuxième ligne.

Explication

Malgré sa richesse intégrée, l'indexation des chaînes n'existe pas dans Alice. La raison en est qu'elle nécessite à la fois un entier et un paramètre de chaîne, et toutes les commandes dans Alice sont strictement des entiers en entiers ou des chaînes en chaînes.

En général, la principale façon d'effectuer des opérations sur des chaînes qui nécessitent ou entraînent des nombres entiers est de stocker la chaîne sur la bande en mode Ordinal, que vous pouvez ensuite manipuler avec des nombres entiers en mode 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.

Gelée , 1 octet

ị

Essayez-le en ligne!

Prolog (SWI) , 40 37 octets

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

Essayez-le en ligne!

Brachylog , 2 octets

∋₎

Essayez-le en ligne!

Explication

∋unifie sa sortie avec un élément de l'entrée. Avec ₎comme indice, il unifiera sa sortie avec le Ie élément de S, avec [S,I]comme entrée.

Cubix , 8 octets

t@poIA//

Cette solution est indexée 1. L'entrée doit être composée d'un nombre d'abord, puis d'un séparateur (qui n'est pas un chiffre ou un .), puis de la chaîne.

Essayez-le en ligne!

CJam , 3 octets

{=}

Essayez-le en ligne!

= est la fonction intégrée pour l'indexation de liste / chaîne.

Japt , 2 octets

gV

Cette solution est indexée 0.

Essayez-le en ligne!

SILOS , 43 octets

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

Essayez-le en ligne!

Assez simple.

BF, 9 bytes

,[->,<]>.

The index is taken via the character code of a char (like the Alice submission). Following that, we have the string.

Try it online!

The TIO link uses a Bash wrapper and the input can be changed in the header file (the reason for the wrapper is so that we can see the bytes).

JavaScript, 11 10 bytes

s=>n=>s[n]

Uses 0-based indexing.

-1 byte thanks to @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 for -v flag to take input

:?!\i~1-
io;\

Thanks to @steenbergh for notifying me about the -v flag and saving me 3 bytes!

Input the index with the command line argument -v [index] (0-indexed) and input the string through stdin.

Try it online!

Explanation

The stack starts with the index on top.
: duplicates it.
? ignores the next character if the index is 0. (Popping it off the stack)
If it is zero, \ reflects the direction to go down. Then, it is reflected to the right with the next \. It wraps around and executes input a character, output it and ; halts execution.
If not, ! skips the next instruction, so it doesn't go down.
i~ inputs a character and then immediately discards it.
1 pushes 1.
- subtractes 1 from the index, so one character in the input is consumed and the index is decremented. The program loops around back to the :.

Carrot, 16 bytes

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

Try it online!

The input format is as such:

string
index

And the program is 1-indexed.

Explanation

Carrot has several global variables, one for each type: string, float and array (others to be implemented soon). The program starts in string-mode, where all the operators will affect the global string variable. And I call these variables the "stack".

(Example input: 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"]

Now this returns a one element array containing a string of length one, but it is shown as a string in the website.

If we really wanted to give the result as a string, we could easily do S"," at the end, but it doesn't matter because the output still looks the same on the interpreter.

Batch, 32 bytes

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

Reads s from STDIN and takes n as a command-line parameter.

GolfScript, 7 4 bytes

~1/=

Try it online!

I suck in GolfScript, so I value Martin Ender's help.

Turtlèd, 9 bytes

!?:[*l+].

Try it online!

explanation:

First off, Turtlèd is grid based, with a turtle thing. There are grid cells the turtle can move left, up, down, and right on, and can write things on the grid cells.

[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 What can you do when there is a built-in for this? This works on lists, vectors, strings and sequences. It is either O(1) or O(n), depending on the used datatype.

sed, 31 bytes

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

Try it online!

Input: index and the string, separated by one space. Index in unary, but zero-based.

Dyvil, 4 Bytes

_[_]

Creates an anonymous function that takes a String and an int and returns a char.

Usage:

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

Pip, 3 bytes

a@b

This is 0-based. Try it online!

QBasic 4.5, 24 bytes

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

Pretty straightforward.

Vim, 8 bytes

DJ@"|xVp

Since V is backwards compatible, you can Try it online!

Mathematica, 18 bytes

#~StringTake~{#2}&

Basic solution, but unfortunately the function name is quite long.

C#, 11 bytes

s=>n=>s[n];