Inspiriert von Gleicht der Start dem Ende?

Geben Sie bei einer gegebenen Zeichenfolge sund einer Ganzzahl neine Wahrheit / einen Fehler aus, um festzustellen, ob das nth- Zeichen in sgleich dem nth- Zeichen vom End-Zeichen in ist s.

Eingang

Eine nicht leere Zeichenfolge und eine Ganzzahl. Sie können die 0-basierte Indizierung oder die 1-basierte Indizierung verwenden. Es ist garantiert, dass die Ganzzahl basierend auf der Zeichenfolge gültig ist. Wenn die Zeichenfolge beispielsweise "supercalifragalistic123" ist, kann die Ganzzahl für eine auf 1 basierende Indizierung zwischen 1 und 23 und für eine auf 0 basierende Indizierung zwischen 0 und 22 liegen. Bitte beachten Sie, dass ngrößer als die Hälfte der Länge sein kann s.

Die Eingabe ist auf druckbares ASCII beschränkt.

Ausgabe

Ein wahrer / falscher Wert, der darauf basiert, ob der nth-Wert in sgleich dem nth-Wert vom letzten Wert in ist s.

Bitte beachten Sie, dass das letzte Zeichen für eine 0-basierte Indizierung auf Position 0 und für eine 1-basierte Indizierung auf Position 1 steht. Stellen Sie sich vor, Sie vergleichen die Zeichenfolge mit der Rückseite.

Testfälle

0-indiziert

"1", 0         Truthy 1 == 1
"abc", 1       Truthy b == b
"aaaaaaa", 3   Truthy a == a
"[][]", 1      Falsey ] != [
"[][]", 0      Falsey [ != ]
"ppqqpq", 2    Truthy q == q
"ababab", 5    Falsey a != b
"12345", 0     Falsey 1 != 5
"letter", 1    Truthy e == e
"zxywv", 3     Falsey w != x

1-indiziert

"1", 1         Truthy 1 == 1
"abc", 2       Truthy b == b
"aaaaaaa", 4   Truthy a == a
"[][]", 2      Falsey ] != [
"[][]", 1      Falsey [ != ]
"ppqqpq", 3    Truthy q == q
"ababab", 6    Falsey a != b
"12345", 1     Falsey 1 != 5
"letter", 2    Truthy e == e
"zxywv", 4     Falsey w != x

Gelee , 5 4 Bytes

=UƓị

Probieren Sie es online!

In Jelly sollte es keine kürzeren Antworten geben. Ein Programm würde einen Vergleich, eine Umkehrung / Negation, einen Indexaufruf und ein Byte für den Steuerfluss ( Ɠin diesem Fall) benötigen , was insgesamt vier Byte ergibt.

Wie es funktioniert

 =UƓị 
       - (implicit) input string
 =     - equals (vectorizing by characters because a string is a charlist)
  U    - the reversed string
    ị  - get the element at the index of:
   Ɠ   - the input index

-1 Byte dank @ ais523, mit Ɠ

JavaScript (ES6), 26 Byte

s=>n=>s[n]==s.substr(~n,1)

Alternative:

s=>n=>s[n]==s.slice(~n)[0]

Dieser funktioniert fast, scheitert aber, wenn n == 0(weil s.slice(-1,0) == ""):

s=>n=>s[n]==s.slice(~n,-n)

Eine weitere 26-Byte-Lösung, auf die @RickHitchcock hingewiesen hat:

s=>n=>s[n]==s[s.length+~n]

MATL , 5 Bytes

tP=w)

Probieren Sie es online!

Erläuterung:

t   % Duplicate the input

Stack:
    ['ppqqpq' 'ppqqpq']

P   % Reverse the top element of the stack

Stack:
    ['ppqqpq' 'qpqqpp']

=   % Equals. Push an array of the indices that are equal

Stack:
    [[0 1 1 1 1 0]]

w   % Swap the top two elements

Stack:
    [[0 1 1 1 1 0], 3]

)   % Grab the a'th element of b 

Oktave , 22 Bytes

@(s,n)s(n)==s(end-n+1)

Probieren Sie es online!

Oder das gleiche bytecount:

@(s,n)s(n)==flip(s)(n)

Probieren Sie es online!

Erläuterung:

Es ist ganz einfach. Die erste Methode verwendet eine Zeichenfolge sund eine Ganzzahl nals Eingaben und vergleicht s(n)das n- te Element mit dem "last-n + 1" -Element auf Gleichheit.

Der zweite prüft das n-te Element s(n)gegen das n-te Element von sumgekehrt.

05AB1E , 7 5 Bytes

-2 Bytes dank Adnan

ÂøsèË

Probieren Sie es online! oder Probieren Sie alle Tests aus

     # Add a reversed copy on top of the original string
 ø    # Zip
  sè  # Extract the nth element
    Ë # Check if they are equal

Probieren Sie es online!

Haskell, 22 Bytes

s#n=s!!n==reverse s!!n

0-basd. Anwendungsbeispiel: "letter" # 1-> True.

Probieren Sie es online!

Alice , 24 Bytes

/t.~e?/-mom
\I!RtI&1n;@/

Probieren Sie es online!

Die Eingabe besteht aus der Zeichenfolge in einer Zeile und der Nummer in der zweiten Zeile. Die Ausgabe erfolgt, Jabberwockywenn die Zeichen identisch sind und ansonsten nichts.

Erläuterung

Dieses Programm befindet sich größtenteils im ordinalen Modus, mit einem Befehl im kardinalen Modus. Linearisiert sieht das Programm wie folgt aus:

I.ReI&1m;mt!~t?&-no

I  % Input first line
   % STACK: ["ppqqpq"]
.  % Duplicate top of stack
   % STACK: ["ppqqpq", "ppqqpq"]
R  % Reverse top of stack
   % STACK: ["ppqqpq", "qpqqpp"]
e  % Push empty string
   % STACK: ["ppqqpq", "qpqqpp", ""]
I  % Input next line
   % STACK: ["ppqqpq", "qpqqpp", "", "3"]
&  % (cardinal mode) Pop stack and repeat next command that many times
   % STACK: ["ppqqpq", "qpqqpp", ""], ITERATOR: [3]
1  % Append "1" to top of stack
   % STACK: ["ppqqpq", "qpqqpp", "111"]
m  % Truncate so the top two strings on the stack have the same length
   % STACK: ["ppqqpq", "qpq", "111"]
;  % Discard top of stack
   % STACK: ["ppqqpq", "qpq"]
m  % Truncate again
   % STACK: ["ppq", "qpq"]
t  % Extract last character
   % STACK: ["ppq", "qp", "q"]
!  % Move top of stack to tape
   % STACK: ["ppq", "qp"]
~  % Swap
   % STACK: ["qp", "ppq"]
t  % Extract last character
   % STACK: ["qp", "pp", "q"]
?  % Copy data from tape onto top of stack
   % STACK: ["qp', "pp", "q", "q"]
&  % Iterator: effectively a no-op in ordinal mode when the top of the stack is a 1-character string
   % STACK: ["qp", "pp", "q"], ITERATOR: ["q"]
-  % Remove occurrences: here, result is "" iff the characters are equal
   % STACK: ["qp", "pp", ""]
n  % Logical Not (for a consistent truthy value)
   % STACK: ["qp", "pp", "Jabberwocky"]
o  % Output top of stack

Python , 24 22 Bytes

-2 Bytes dank Adnan.

lambda s,n:s[n]==s[~n]

Probieren Sie es online!

Cubix , 22 Bytes

[email protected]):tBvpptc?1.\O0

1 indizierte, nimmt als Eingabe index, stringdurch einen Zwischenraum getrennt.

Probieren Sie es online aus

Cubified

    . .
    @ .
I A p ) : t B v
p p t c ? 1 . \
    O 0
    . .

Erläuterung

Dies ist meist linear. Die Hauptlogik ist

IAp):tBpptc

IA           Get the first input as an int and the rest as a string.
  p):        Move the index to the top of the stack, increment it, and copy it.
     t       Look up the appropriate character in the string.
      Bpp    Reverse the stack and put the index and character back on top.
         t   Look up the appropriate character in the reversed string.
          c  XOR the two characters.

Wir verzweigen dann mit ?to Output, 1wenn das Ergebnis 0 ist und 0ansonsten.

Java 8, 43 42 Bytes

s->n->s.charAt(n)==s.charAt(s.length()+~n)

Probieren Sie es hier aus.

C #, 28 27 Bytes

s=>n=>s[n]==s[s.Length+~n];

Ein Byte dank @KevinCruijssen gespeichert.

Kompiliert zu a Func<string, Func<int, bool>>.

CJam , 8 Bytes

l~_W%.==

Probieren Sie es online!

Der Index mit dem Index 0 steht an erster Stelle.

R 51 Bytes

function(s,n){s=el(strsplit(s,''));s[n]==rev(s)[n]}

Anonyme Funktion, verwendet 1-basierte Indizierung

Ruby, 22 20 18 Bytes

->s,n{s[n]==s[~n]}

Clojure, 27 Bytes

#(nth(map =(reverse %)%)%2)

Wow, das war kürzer als ich erwartet hatte.

APL (Dyalog) , 10 5 Bytes

⊃=⊃∘⌽

Dies ist eine implizite Funktion, der ein Name wie zugewiesen f←⊃=⊃∘⌽und dann als aufgerufen werden muss int f string.

Vielen Dank an @ Adám für die unglaublichen 5 Bytes.

Wie es funktioniert:

⊃=⊃∘⌽  ⍝ Main function; tacit. 
       ⍝ Inputs are ⍺ = 1 (left) and ⍵ = 'abca' (right).
⊃      ⍝ ⍺⊃⍵, meaning 'pick the ⍺-th element of ⍵'
 =     ⍝ Compare to
    ⌽  ⍝ ⌽⍵, meaning 'invert ⍵'
  ⊃    ⍝ Again, ⍺⊃⍵, but:
   ∘   ⍝ Compose. This turns ⌽ into the right argument for ⊃,
       ⍝ which becomes 'pick the ⍺-th element from ⌽(the inverse of)⍵'

Probieren Sie es online!

Die 22-Byte-Antwort wurde herausgeschnitten. Wenn Sie es sehen möchten, überprüfen Sie den Revisionsverlauf.

V , 26, 16 , 13 Bytes

ä$Àñã2xñVpøˆ±

Probieren Sie es online!

Hexdump:

00000000: e424 c0f1 e332 78f1 5670 f888 b1         .$...2x.Vp...

1 indiziert.

Erläuterung:

ä$                  " Duplicate this line horizontally
  Àñ   ñ            " Arg1 times...
    ã               "   Move to the center of this line
     2x             "   And delete two characters
        V           " Select this whole line
         p          " And replace it with the last pair of characters we deleted
          ø         " Count the number of matches of the following regex...
           <0x88>   "   Any character
                 ±  "   Followed by itself

Als Referenz war meine ursprüngliche Antwort:

Àñx$x|ñxv$hhpÓ¨.©±/1
ñllS0

Probieren Sie es online! (0 indiziert)

Hexdump:

00000000: c0f1 7824 787c f178 7624 6868 70d3 a82e  ..x$x|.xv$hhp...
00000010: a9b1 2f31 0af1 6c6c 5330                 ../1..llS0

Mathematica, 34 Bytes

s=StringTake;s[#,{#2}]==s[#,{-#2}]&

Perl 6 , 27 Bytes

{[eq] $^a.comb[$^b,*-1-$b]}

Probier es aus

{ # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣

  [eq]        # reduce using string equality operator

    $^a       # declare first positional parameter

    .comb\    # split that into individual characters

    [         # index into that sequence

      $^b,    # declare and use second parameter

      *-1-$b  # closure that subtracts one and the 
              # second parameter of the outer block
              # (｢*｣ is the parameter of this closure)

    ]
}

PHP> = 7.1, 36 Bytes

[,$t,$p]=$argv;echo$t[$p]==$t[~+$p];

Online Version

Pyth , 8 7 Bytes

q@zQ@_z

Bei umgekehrter Eingabe: zuerst der Index, dann die Zeichenfolge. Es ist 0-indiziert.

Erklärungen:

q@zQ@_z
 @zQ        Get the nth (Qth) character
     _z     Reverse the string
    @       Get the nth character of the reversed string. Implicit input of the index
q           Test equality

Probieren Sie es online!

Lua, 46 Bytes

function f(s,n)return s:byte(n)==s:byte(-n)end

Probieren Sie es online!

J, 6 Bytes

-4 Bytes dank FrownyFrog

{(=|.)

Siehe Erklärung der Originalantwort - Idee ist ähnlich genug, aber dies wird mit einem dyadischen Haken erreicht, dessen rechtes Verb selbst ein monadischer Haken ist.

Probieren Sie es online!

ursprüngliche Antwort (10 Bytes)

{=/@(,:|.)

,:|. rechtes arg über rückwärts rechtes arg

=/ Sind sie elementweise gleich?

{ Nehmen Sie aus dieser Booleschen Liste den Index, der durch das linke Argument angegeben wird

Probieren Sie es online!

C, 36 35 bytes

#define f(s,n)s[n]==s[strlen(s)+~n]

Verwendet natürlich die 0-basierte Indizierung.

Probieren Sie es online!

Japt , 10 9 8 Bytes

gV ¥Ug~V

Probieren Sie es online!

QBIC , 18 Bytes

?_s;,:,1|=_sA,-a,1

Erläuterung

?        =     PRINT -1 if equal, 0 otherwise, between
 _s     |      A substring of
   ;,:,1          A$ string (read from cmd line), from the n'th pos, length 1
 _sA,-a,1      And a substring of A$, n'th pos from the right, also 1 length
               The second Substring is auto-terminated because EOF.

CJam, 11 Bytes

q~_2$=@@~==

Schlecht. Zu viel Stapelmanipulation.

> <> (mit diesem Interpreter), 25 Bytes

i:0(?v
]&=n;>~{:}[:}]&r[}

In TIO funktioniert das nicht: Der TIO-Interpreter kehrt den neuen Stapel bei der Ausführung der [Anweisung nicht um, aber der Fischspielplatz - vergleiche zum Beispiel den "abcde"5[ooooo;Lauf hier und hier .

Die Zeichenfolgeneingabe wird von STDIN übernommen, und wir gehen davon aus, dass sich n bereits auf dem Stapel befindet. Verwendet 1-Indizierung.

Der Fisch bekommt das n- te Zeichen mit [:}]&, das die ersten n Dinge auf dem Stapel in einen neuen, umgekehrten Stapel einsaugt, das ein bisschen manipuliert, dann die Dinge zurücklegt und das n- te Zeichen im Register speichert . Es kehrt dann den gesamten Stapel um und macht dasselbe erneut und gibt 1 zurück, wenn die beiden Zeichen gleich sind, und 0, wenn dies nicht der Fall ist.

Dies scheint bei TIO für 26 Bytes zu funktionieren :

i:0(?v
]&=n;>~{:}[{:}]&r[{

C 73 Bytes

Kompiliert wie besehen mit GCC 6.3.1 (keine Flags). Einige unnötige Verschleierung enthalten.

main(c,v)char**v;{c=atoi(v[2]);putchar((*++v)[c]-(*v)[strlen(*v+1)-c]);}

Verwendung

$./a.out abcdcba 6

Wahrheit = nichts, Falschheit = Müll.

Lua , 35 Bytes

Verwendet 1-Indizierung.

s,n=...print(s:byte(n)==s:byte(-n))

Probieren Sie es online!