# Does the nth char equal the nth from last char?

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

• Sandbox (deleted) Commented May 31, 2017 at 20:50
• Would it be acceptable to take n as a code-point? (for esoteric languages such as brain-flak) Commented May 31, 2017 at 21:29
• @DJMcMayhem sure. Commented May 31, 2017 at 21:30

# 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]

• Nice use of ~, would never have though of that for this. Commented May 31, 2017 at 21:19

# 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 Ɠ

• Failed 4 byte solution from original version of post: ịµU= Commented May 31, 2017 at 21:59
• You can improve it to four bytes by making it monadic rather than dyadic (and taking n from standard input rather than an argument): Try it online! This technique is often useful when you're wasting a byte on control flow and an additional byte on ³, as the Ɠ costs one byte but makes the ³ implicit and often gives you more control flow flexibility.
– user62131
Commented May 31, 2017 at 22:21
• @ais512 Good idea, I have actually never used the input before in an answer because implicit arguments tend to be more efficient. Commented May 31, 2017 at 22:29

# 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

• Very clever approach! Commented May 31, 2017 at 21:21
• @LuisMendo Thankyou! That is quiet the complement coming from you :) Commented May 31, 2017 at 21:25
• Now we see if Jelly can beat this xD Commented May 31, 2017 at 21:26

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

# Python, 24 22 bytes

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


Try it online!

• I think you can replace -n-1 by ~n. Commented May 31, 2017 at 21:11
• Why only Python2? Seems to work on Python3 just fine, you should change it to just 'Python'. Commented Jun 1, 2017 at 9:52
• @sagiksp it's the default template output in TIO Commented Jun 1, 2017 at 10:54
• Oh, makes sense. Commented Jun 1, 2017 at 13:43
• @sagiksp Yeah, it's the template from TIO but updated. :) Commented Jun 1, 2017 at 17:03

# 05AB1E, 7 5 bytes

ÂøsèË

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


Try it online!

• ÂøsèË saves two bytes Commented May 31, 2017 at 21:37
• @Adnan Thanks! I knew there was a 1 byte way to add a reversed copy, I just couldn't remember how it was labeled. Commented May 31, 2017 at 21:43
• @ComradeSparklePony I forgot to update it to include Adnan's suggestion. Commented May 31, 2017 at 22:08

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


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

Try it online!

# 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

• @MartinEnder Jabberwocky? Commented Jun 1, 2017 at 2:33
• @StephenS Jabberwocky. Commented Jun 1, 2017 at 12:30
• @StephenS Btw, I don't get notifications if you just mention me on random posts. Pings only work if the post is mine or I've commented myself (and I think if I edited the post). You're usually better off pinging me in chat. Commented Jun 1, 2017 at 12:31
• @MartinEnder I kind of knew that, but it wasn't important enough to ping you. Thanks for the confirmation and the link :) Commented Jun 1, 2017 at 12:40

# Java 8, 43 42 bytes

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


Try it here.

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

# 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  • Try it online! This is a bit shorter. Man the Àñx$x|ñ feels like too many characters. I tried a regex only, but it ended up being like 24 long! Commented Jun 1, 2017 at 13:25
• @nmjcman101 Turns out it can be much shorter than that using newer features. Commented Oct 31, 2017 at 16:48
• Oh wow I'm out of practice, I can barely even read V anymore Commented Oct 31, 2017 at 16:53
• @nmjcman101 I've posted an explanation (and golfed a little more) Commented Oct 31, 2017 at 17:04

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

• You can save a byte by changing s.Length-n-1 to s.Length+~n. Commented Jun 1, 2017 at 9:06
• @KevinCruijssen Thanks, nice trick never would have thought of that. Commented Jun 1, 2017 at 9:08
• I will be completely honest, I got it from the comment of the JS answer myself. :) Byte-operations aren't really my expertise. Commented Jun 1, 2017 at 9:14

# CJam, 8 bytes

l~_W%.==


Try it online!

0-indexed index goes first.

## R 51 bytes

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


Anonymous function, uses 1-based indexing

• 43 bytes: function(s,n)(s=utf8ToInt(s))[n]==rev(s)[n] Commented Oct 31, 2017 at 16:02

## Ruby, 22 20 18 bytes

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

• I guess ->s,n{s[n]==s[~n]} should work? (Got no idea of ruby) Commented Jun 1, 2017 at 13:04
• It does, nice! Thanks! Commented Jun 1, 2017 at 15:53

## Clojure, 27 bytes

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


Wow, this was shorter than I expected.

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

• " it takes the input in a non conventional way" -- taking 2 element input as the left and right args in APL is completely standard and always acceptable unless the OP specifically forbids it for some bizarre reason. Commented Oct 31, 2017 at 14:28
• @Jonah yeah, people in chat enlightened me about that. I left it as is because OP doesn't specify clearly if it's okay or not. I'll edit that when I get back to my PC so the shorter answer appears first. Commented Oct 31, 2017 at 14:30
• Regarding "implicitly assumes": Actually, this function will work even when called monadically, and will then appear to use 1 as default left argument. Try it online! The functions don't assume anything; they are being applied dyadically because they are given both a left and a right argument.
Commented Oct 31, 2017 at 16:04
• @Adám I thought that happened because, when called monadically, ⊃ takes the first element of the argument? Anyway, I'll edit to clarify. Commented Oct 31, 2017 at 16:06

# 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!

# 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!

{=/@(,:|.)


,:|. 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!

# Mathematica, 34 Bytes

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

• StringTake[#, #2] takes the first #2 characters of #. StringPart would work well in this case. #~(s=StringPart)~-#2==s@##& Commented May 31, 2017 at 23:30
• my wrong. fixed! Commented May 31, 2017 at 23:33
• #~s~{#2}==#~s~{#2}& would always yield True... Commented May 31, 2017 at 23:34
• final fixed!.... Commented May 31, 2017 at 23:36
• Actually, you can take a List of Strings as input, so #[[#2]]==#[[-#2]]& would suffice Commented May 31, 2017 at 23:39

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

]
}


# PHP>=7.1, 36 Bytes

[,$t,$p]=$argv;echo$t[$p]==$t[~+$p];  Online Version • ~+$p saves one byte. Commented Jun 1, 2017 at 4:12

# 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!

# Lua, 46 bytes

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


Try it online!

• you can't assume the input is already in s, and you need to output it as well Commented Jun 1, 2017 at 10:56

# C, 36 35 bytes

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


Uses 0-based indexing, naturally.

Try it online!

• I think -1-n can be +~n. Commented Oct 31, 2017 at 16:10

# 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


# 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


# 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


## ZSH, 32

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


Try it online!

# Japt, 10 9 8 bytes

gV ¥Ug~V


Try it online!