Cho một chuỗi svà một số không âm nnhỏ hơn độ dài của s, xuất ký tự ở nvị trí -th của s.

Chỉ mục 0 và lập chỉ mục 1 được cho phép. Đối với chỉ mục 1, nsẽ dương và nhỏ hơn hoặc bằng độ dài của s.

s sẽ chỉ bao gồm các ký tự có thể in được.

Bất kỳ đầu vào / đầu ra hợp lý đều được cho phép. Tiêu chuẩn áp dụng.

Testcase (lập chỉ mục 0):

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

Testcase (lập chỉ mục 1):

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

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng.

MATL , 1 byte

)

Hãy thử trực tuyến!

Vâng, khó để làm cho nó đơn giản hơn nhiều. )lập chỉ mục đầu vào đầu tiên, sử dụng giá trị đầu vào thứ hai. Đây là 1 chỉ mục.

Alice , 5 byte

I&IO@

Hãy thử trực tuyến!

Như thường lệ, nó sẽ ngắn hơn nhiều nếu chúng ta tránh chế độ Thông thường và sử dụng định dạng đầu vào sâu. Ở đây, điểm mã của ký tự đầu tiên được sử dụng làm đầu vào số nguyên . Phần còn lại của đầu vào là chuỗi. Chỉ số này dựa trên 1.

Giải trình

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 byte

str.__getitem__

hoặc là

lambda s,i:s[i]

Cả hai đều có 2 đối số: chuỗi và chỉ mục. Chỉ số 0.

Haskell, 4 byte

(!!)

Lập chỉ mục dựa trên 0. Ví dụ sử dụng: (!!) "Hello" 1-> 'e'.

Octave, 10 byte

@(s,n)s(n)

Lấy một chuỗi svà một số nlàm đầu vào và trả về nký tự thứ của s.

Võng mạc , 28 20 19 byte

Đã lưu 8 byte nhờ @MartinEnder bằng cách không sử dụng các nhóm cân bằng

Đã lưu 1 byte nhờ @ mbomb007 bằng cách sử dụng ^.+thay vì^\d+

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

Hãy thử trực tuyến!

Chương trình được lập chỉ mục 0.

05AB1E , 1 byte

Chỉ số 0.

è

Hãy thử trực tuyến!

Alice , 10 byte

/@!O?]&
 I

Hãy thử trực tuyến!

Yêu cầu chuỗi trên dòng đầu tiên và chỉ mục dựa trên 0 trên dòng thứ hai.

Giải trình

Mặc dù có rất nhiều tích hợp sẵn, lập chỉ mục chuỗi không tồn tại trong Alice. Lý do là nó yêu cầu cả số nguyên và tham số chuỗi và tất cả các lệnh trong Alice đều là số nguyên nghiêm ngặt cho số nguyên hoặc chuỗi thành chuỗi.

Nói chung, cách chính để thực hiện bất kỳ thao tác nào trên chuỗi yêu cầu hoặc dẫn đến số nguyên là lưu trữ chuỗi trên băng ở chế độ Thông thường, sau đó bạn có thể thao tác với số nguyên ở chế độ 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.

Thạch , 1 byte

ị

Hãy thử trực tuyến!

Prolog (SWI) , 40 37 byte

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

Hãy thử trực tuyến!

Brachylog , 2 byte

∋₎

Hãy thử trực tuyến!

Giải trình

∋thống nhất đầu ra của nó với một phần tử của Đầu vào. Với ₎dạng con, nó sẽ thống nhất đầu ra của nó với Iphần tử thứ S, với [S,I]là đầu vào.

Khối , 8 byte

t@poIA//

Giải pháp này là 1 chỉ mục. Đầu vào phải bao gồm một số trước, sau đó là dấu phân cách (không phải là chữ số hoặc a .) và sau đó là chuỗi.

Hãy thử trực tuyến!

CJam , 3 byte

{=}

Hãy thử trực tuyến!

= là tích hợp để lập chỉ mục danh sách / chuỗi.

Japt , 2 byte

gV

Giải pháp này là 0 chỉ mục.

Hãy thử trực tuyến!

Silos , 43 byte

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

Hãy thử trực tuyến!

Đủ đơn giản.

BF , 9 byte

,[->,<]>.

Chỉ mục được lấy thông qua mã ký tự của char (như đệ trình Alice). Theo đó, chúng ta có chuỗi.

Hãy thử trực tuyến!

Liên kết TIO sử dụng trình bao bọc Bash và đầu vào có thể được thay đổi trong tệp tiêu đề (lý do của trình bao bọc là để chúng ta có thể thấy các byte).

JavaScript, 11 10 byte

s=>n=>s[n]

Sử dụng lập chỉ mục dựa trên 0.

-1 byte nhờ @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 byte

+1 cho -vcờ để nhận đầu vào

:?!\i~1-
io;\

Cảm ơn @steenbergh đã thông báo cho tôi về -vcờ và tiết kiệm cho tôi 3 byte!

Nhập chỉ mục với đối số dòng lệnh -v [index](0-index) và nhập chuỗi thông qua stdin.

Hãy thử trực tuyến!

Giải trình

Ngăn xếp bắt đầu với chỉ số trên đầu trang.
:nhân đôi nó
?bỏ qua ký tự tiếp theo nếu chỉ số bằng 0. (Bật nó ra khỏi ngăn xếp)
Nếu nó bằng 0, \phản ánh hướng đi xuống. Sau đó, nó được phản ánh sang bên phải với tiếp theo \. Nó bao bọc xung quanh và thực hiện thuật ngữ imột nhân vật,o bỏ qua nó và ;tạm dừng thực thi.
Nếu không, !bỏ qua hướng dẫn tiếp theo, để nó không đi xuống.
i~nhập một ký tự và sau đó loại bỏ nó ngay lập tức.
1đẩy 1.
-trừ 1khỏi chỉ mục, do đó, một ký tự trong đầu vào được tiêu thụ và chỉ số bị giảm. Các vòng lặp chương trình trở lại :.

Cà rốt , 16 byte

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

Hãy thử trực tuyến!

Định dạng đầu vào là như vậy:

string
index

Và chương trình là 1 chỉ mục.

Giải trình

Carrot có một số biến toàn cục, một biến cho mỗi loại: chuỗi, float và mảng (các biến khác sẽ được triển khai sớm). Chương trình bắt đầu ở chế độ chuỗi, trong đó tất cả các toán tử sẽ ảnh hưởng đến biến chuỗi toàn cầu. Và tôi gọi các biến này là "ngăn xếp".

(Ví dụ nhập 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"]

Bây giờ, điều này trả về một mảng một phần tử chứa một chuỗi có độ dài một, nhưng nó được hiển thị dưới dạng một chuỗi trong trang web.

Nếu chúng ta thực sự muốn đưa ra kết quả dưới dạng một chuỗi, chúng ta có thể dễ dàng thực hiện S","ở cuối, nhưng điều đó không thành vấn đề vì đầu ra vẫn giống như trên trình thông dịch.

Mẻ, 32 byte

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

Đọc stừ STDIN và lấy nlàm tham số dòng lệnh.

GolfScript , 7 4 byte

~1/=

Hãy thử trực tuyến!

Tôi rất thích GolfScript, vì vậy tôi đánh giá cao sự giúp đỡ của Martin Ender .

Turtlèd , 9 byte

!?:[*l+].

Hãy thử trực tuyến!

giải trình:

Trước hết, Turtlèd dựa trên lưới, với một thứ rùa. Có những ô lưới mà rùa có thể di chuyển sang trái, lên, xuống và phải và có thể viết những thứ trên các ô lưới.

[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 Bạn có thể làm gì khi có tích hợp sẵn cho việc này? Điều này hoạt động trên danh sách, vectơ, chuỗi và trình tự. Nó là O (1) hoặc O (n), tùy thuộc vào kiểu dữ liệu được sử dụng.

sed , 31 byte

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

Hãy thử trực tuyến!

Đầu vào: chỉ mục và chuỗi, cách nhau bởi một khoảng trắng. Chỉ số trong unary, nhưng dựa trên không.

Dyvil , 4 byte

_[_]

Tạo một hàm ẩn danh có một Stringvà một intvà trả về mộtchar .

Sử dụng:

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

Pip , 3 byte

a@b

Đây là 0 dựa trên. Hãy thử trực tuyến!

QBasic 4.5, 24 byte

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

Khá đơn giản.

Vim, 8 byte

DJ@"|xVp

Vì V tương thích ngược, bạn có thể dùng thử trực tuyến!

Toán học, 18 byte

#~StringTake~{#2}&

Giải pháp cơ bản, nhưng tiếc là tên hàm khá dài.

C #, 11 byte

s=>n=>s[n];