Does the nth char equal the nth from last char?

Question

Inspired by Does the start equal the end

Given a string s and an integer n, output a truthy/falsey as to whether the nth char in s equals the nth from the end char in s.

Input

A non-empty string and an integer. You can use 0-based indexing or 1-based indexing. The integer is guaranteed to be valid based on the string. For example, if the string is "supercalifragalistic123", the integer can be from 1 to 23 for 1-based indexing, and 0 to 22 for 0-based indexing. Please note that n can be larger than half the length of s.

Input is limited to printable ASCII.

Output

A truthy/falsey value based on whether the nth value in s equals the nth from last value in s.

Please note that the last char is in position 0 for 0-based indexing and position 1 for 1-based indexing. Think of it as comparing the string to its reverse.

Test Cases

0-indexed

"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-indexed

"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

Answer 1

JavaScript (ES6), 26 bytes

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

Alternatively:

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

This one almost works, but fails when n == 0 (because s.slice(-1,0) == ""):

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

Another 26-byte solution that @RickHitchcock pointed out:

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

Answer 2

Jelly, 5 4 bytes

=UƓị

Try it online!

There should be no shorter answers in Jelly. An program would need comparison, reversal/negation, an index call, and a byte for control flow (Ɠ in this case), which adds up to four bytes.

How it works

 =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 thanks to @ais523, using Ɠ

Answer 3

MATL, 5 bytes

tP=w)

Try it online!

Explanation:

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 

Answer 4

Octave, 22 bytes

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

Try it online!

Or the same bytecount:

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

Try it online!

Explanation:

It's quite straight forward. The first one takes a string s and an integer n as inputs and checks the n'th element s(n) against the "last-n+1" element for equality.

The second one checks the n'th element s(n) against the n'th element of s reversed.

Answer 5

Python, 24 22 bytes

-2 bytes thanks to Adnan.

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

Try it online!

Answer 6

05AB1E, 7 5 bytes

-2 bytes thanks to Adnan

ÂøsèË

Try it online! or Try all tests

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

Try it online!

Answer 7

Haskell, 22 bytes

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

0-basd. Usage example: "letter" # 1 -> True.

Try it online!

Answer 8

Alice, 24 bytes

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

Try it online!

Input consists of the string on one line, and the number on the second line. Output is Jabberwocky if the characters are the same, and nothing otherwise.

Explanation

This program is mostly in ordinal mode, with one command in cardinal mode. Linearized, the program is as follows:

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

Answer 9

Java 8, 43 42 bytes

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

Try it here.

Answer 10

Cubix, 22 bytes

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

1-indexed, takes input as index,string, separated by a space.

Try it online

Cubified

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

Explanation

This is mostly linear. The main logic is

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.

We then branch with ? to Output 1 if the result is 0 and 0 otherwise.

Answer 11

V, 26, 16, 13 bytes

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

Try it online!

Hexdump:

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

1 indexed.

Explanation:

ä$                  " 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

For reference, my original answer was:

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

Try it online! (0 indexed)

Hexdump:

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

Answer 12

C#, 28 27 bytes

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

Saved a byte thanks to @KevinCruijssen.

Compiles to a Func<string, Func<int, bool>>.

Answer 13

CJam, 8 bytes

l~_W%.==

Try it online!

0-indexed index goes first.

Answer 14

R 51 bytes

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

Anonymous function, uses 1-based indexing

Answer 15

Ruby, 22 20 18 bytes

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

Answer 16

Clojure, 27 bytes

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

Wow, this was shorter than I expected.

Answer 17

APL (Dyalog), 10 5 bytes

⊃=⊃∘⌽

This is a tacit function, which needs to be assigned a name such as f←⊃=⊃∘⌽, and then called as int f string.

Thanks to @Adám for a whopping 5 bytes.

How it works:

⊃=⊃∘⌽  ⍝ 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)⍵'

Try it online!

The 22 byte answer was edited out. If you want to see it, check the revision history.

Answer 18

C# (Visual C# Interactive Compiler), 20 bytes

I don't have enough reputation to comment on TheLethalCoder's answer, but in C# 8 you can save some more bytes.

s=>n=>s[n]==s[^++n];

Try it online!

Answer 19

J, 6 5 bytes

{]=|.

Try it online!

-4 bytes thanks to FrownyFrog for {(=|.)

See original answer explanation -- idea is similar enough, but this is accomplished with a dyadic hook whose right verb is itself a monadic hook.

Try it online!

original answer (10 bytes)

{=/@(,:|.)

,:|. right arg on top of reverse right arg

=/ are they elementwise equal?

{ take from that boolean list the index indicated by the left arg

Try it online!

Answer 20

Mathematica, 34 Bytes

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

Answer 21

Perl 6, 27 bytes

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

Test it

{ # 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)

    ]
}

Answer 22

PHP>=7.1, 36 Bytes

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

Online Version

Answer 23

Pyth, 8 7 bytes

q@zQ@_z

With the input reversed: first the index, then the string. It is 0-indexed.

Explanations:

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

Try it online!

Answer 24

Lua, 46 bytes

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

Try it online!

Answer 25

C, 36 35 bytes

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

Uses 0-based indexing, naturally.

Try it online!

Answer 26

Factor, 24 bytes

[ 2dup nth -rot nth* = ]

Try it online!

Explanation

nth* is like nth except it indexes from the back; if 0 nth is the first element, 0 nth* is the last.

             ! 1 "[][]"
2dup         ! 1 "[][]" 1 "[][]"
nth          ! 1 "[][]" 93
-rot         ! 93 1 "[][]"
nth*         ! 93 91
=            ! f

Answer 27

Thunno, \$ 8 \log_{256}(96) \approx \$ 6.58 bytes

Drz.=sAI

Attempt This Online!

0-indexed. Change AI to AH if you want it to be 1-indexed.

Explanation

Drz.=sAI  # Implicit input
Dr        # Duplicate and reverse
  z.=     # Zipped equality
     sAI  # Swap and index in
          # Implicit output

Answer 28

Vyxal, 4 bytes

fḂ=i

Try it Online!

Explanation

fḂ=i  # Implicit input
f     # Flatten into a list of characters
 Ḃ    # Bifurcate: duplicate and reverse
  =   # Are they equal (vectorises)
   i  # Index in
      # Implicit output

Answer 29

ZSH, 32

f(){read s n;[ $s[n] = $s[-n] ]}

Try it online!

Answer 30

Japt, 10 9 8 bytes

gV ¥Ug~V

Try it online!