Biorąc pod uwagę ciąg znaków si liczbę nieujemną nmniejszą niż długość s, wypisz znak na n-tą pozycję s.

Dozwolone jest indeksowanie 0 i indeksowanie 1. Dla 1-indeksowania nbędzie dodatnia i mniejsza lub równa długości s.

s będzie się składać wyłącznie z drukowalnych znaków.

Wszelkie uzasadnione wejścia / wyjścia są dozwolone. Obowiązują standardowe luki .

Testcases (indeksowanie 0):

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

Testcases (1-indeksowanie):

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

To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.

MATL , 1 bajt

)

Wypróbuj online!

Trudno to uprościć. )indeksuje pierwsze wejście, używając drugiej wartości wejściowej. Jest to indeks 1.

Alice , 5 bajtów

I&IO@

Wypróbuj online!

Jak zwykle jest o wiele krótszy, jeśli unikniemy trybu porządkowego i użyjemy fatalnego formatu wejściowego. W tym przypadku punkt kodowy pierwszego znaku jest używany jako wejście liczby całkowitej . Pozostała część danych wejściowych to ciąg znaków. Indeks jest oparty na 1.

Wyjaśnienie

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 bajtów

str.__getitem__

lub

lambda s,i:s[i]

Oba pobierają 2 argumenty: ciąg i indeks. 0-indeksowane.

Haskell, 4 bajty

(!!)

Indeksowanie na podstawie 0. Przykład użycia: (!!) "Hello" 1-> 'e'.

Oktawa, 10 bajtów

@(s,n)s(n)

Bierze ciąg si liczbę njako dane wejściowe i zwraca nznak th z s.

Retina , 28 20 19 bajtów

Zaoszczędź 8 bajtów dzięki @MartinEnder, nie używając grup bilansujących

Zapisano 1 bajt dzięki @ mbomb007, używając ^.+zamiast^\d+

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

Wypróbuj online!

Program ma indeks 0.

05AB1E , 1 bajt

0-indeksowane.

è

Wypróbuj online!

Alice , 10 bajtów

/@!O?]&
 I

Wypróbuj online!

Oczekuje ciągu w pierwszym wierszu i indeksu opartego na 0 w drugim wierszu.

Wyjaśnienie

Pomimo bogactwa wbudowanych indeksów łańcuchów w Alice nie istnieje. Powodem jest to, że wymaga zarówno liczby całkowitej, jak i parametru ciągu, a wszystkie polecenia w Alice są ściśle liczbami całkowitymi do liczb całkowitych lub ciągów do ciągów.

Zasadniczo głównym sposobem wykonywania dowolnych operacji na ciągach znaków, które wymagają lub skutkują liczbami całkowitymi, jest przechowywanie łańcucha na taśmie w trybie porządkowym, którym można następnie manipulować liczbami całkowitymi w trybie kardynalnym.

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

Galaretka , 1 bajt

ị

Wypróbuj online!

Prolog (SWI) , 40 37 bajtów

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

Wypróbuj online!

Brachylog , 2 bajty

∋₎

Wypróbuj online!

Wyjaśnienie

∋ujednolica dane wyjściowe z elementem Input. Z ₎jako indeks dolny ujednolici swoje wyjście z Ielementem th S, z [S,I]jako wejście.

Cubix , 8 bajtów

t@poIA//

To rozwiązanie ma indeks 1. Dane wejściowe powinny składać się najpierw z liczby, następnie z separatora (który nie jest cyfrą ani a .), a następnie z łańcucha.

Wypróbuj online!

CJam , 3 bajty

{=}

Wypróbuj online!

= jest wbudowanym narzędziem do indeksowania list / ciągów.

Japt , 2 bajty

gV

To rozwiązanie ma indeks 0.

Wypróbuj online!

SILOS , 43 bajty

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

Wypróbuj online!

Wystarczająco proste.

BF , 9 bajtów

,[->,<]>.

Indeks jest pobierany za pomocą kodu znakowego znaku (takiego jak przesłanie Alice). Następnie mamy ciąg.

Wypróbuj online!

Łącze TIO używa otoki Bash, a dane wejściowe można zmienić w pliku nagłówkowym (powodem otoki jest to, że możemy zobaczyć bajty).

JavaScript, 11 10 bajtów

s=>n=>s[n]

Wykorzystuje indeksowanie 0.

-1 bajt dzięki @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 bajtów

+1 dla -vflagi, aby przejąć dane

:?!\i~1-
io;\

Dzięki @steenbergh za powiadomienie mnie o -vflagi i oszczędność mi 3 bajtów!

Wprowadź indeks za pomocą argumentu wiersza poleceń -v [index](indeksowany 0) i wprowadź ciąg przez stdin.

Wypróbuj online!

Wyjaśnienie

Stos zaczyna się od indeksu na górze.
:powiela to.
?ignoruje następny znak, jeśli indeks wynosi 0. (Usuwanie go ze stosu)
Jeśli jest zero, \odzwierciedla kierunek zejścia. Następnie jest odzwierciedlany po prawej stronie przy następnym \. Zawija się i wykonuje input znaku, owypisuje go i ;zatrzymuje wykonywanie.
Jeśli nie, !pomija następną instrukcję, więc nie spada.
i~wprowadza znak, a następnie natychmiast go odrzuca.
1wypycha 1.
-odejmuje 1od indeksu, więc jeden znak na wejściu jest zużywany, a indeks jest zmniejszany. Program zapętla się z powrotem do :.

Marchewka , 16 bajtów

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

Wypróbuj online!

Format wejściowy jest taki:

string
index

A program ma indeks 1.

Wyjaśnienie

Marchew ma kilka zmiennych globalnych, po jednej dla każdego typu: string, float i array (inne zostaną wkrótce zaimplementowane). Program uruchamia się w trybie łańcuchowym, w którym wszyscy operatorzy wpływają na globalną zmienną łańcuchową. I te zmienne nazywam „stosem”.

(Przykład wkład: 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"]

Teraz zwraca tablicę jednoelementową zawierającą ciąg o długości jeden, ale jest wyświetlany jako ciąg w witrynie.

Jeśli naprawdę chcielibyśmy dać wynik jako ciąg, moglibyśmy z łatwością zrobić to S","na końcu, ale to nie ma znaczenia, ponieważ wynik nadal wygląda tak samo na interpretatorze.

Partia, 32 bajty

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

Czyta sze STDIN i przyjmuje njako parametr wiersza polecenia.

GolfScript , 7 4 bajty

~1/=

Wypróbuj online!

Wciągam GolfScript, więc cenię pomoc Martina Endera .

Turtlèd , 9 bajtów

!?:[*l+].

Wypróbuj online!

wyjaśnienie:

Po pierwsze, Turtlèd jest oparty na siatce, z żółwiem. Istnieją komórki siatki, w których żółw może poruszać się w lewo, w górę, w dół i w prawo, i mogą pisać rzeczy na komórkach siatki.

[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 Co możesz zrobić, jeśli jest do tego wbudowany ? Działa to na listach, wektorach, ciągach i sekwencjach. Jest to O (1) lub O (n), w zależności od użytego typu danych.

sed , 31 bajtów

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

Wypróbuj online!

Dane wejściowe: indeks i ciąg oddzielone jedną spacją. Indeks w jednostkowej, ale zerowej.

Dyvil , 4 bajty

_[_]

Tworzy anonimową funkcję, która przyjmuje a Stringi an inti zwraca a char.

Stosowanie:

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

Pip , 3 bajty

a@b

Jest to oparte na 0. Wypróbuj online!

QBasic 4.5, 24 bajty

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

Całkiem proste.

Vim, 8 bajtów

DJ@"|xVp

Ponieważ V jest kompatybilny wstecz, możesz wypróbować online!

Mathematica, 18 bajtów

#~StringTake~{#2}&

Podstawowe rozwiązanie, ale niestety nazwa funkcji jest dość długa.

C #, 11 bajtów

s=>n=>s[n];