Does the start equal the end?

Question

The Task

In this challenge, your task is to write a program or function which takes in a String and outputs a truthy or falsey value based on whether the first character and the last character of the input String are equal.

Input

You may take input in any way reasonable way. However, assuming that the input is present in a predefined variable is not allowed. Reading from a file, console, command line, input field etc., or taking input as a function argument is allowed.

Output

You may output in any reasonable format, except for assigning the result to a variable. Writing to a file, console, command line, modal box, function return statements etc. is allowed.

Additional Rules

• The input can be empty String as well, for which you should return a falsey value.

• Single-Char Input Strings should have a truthy result.

• Your program should be case-sensitive. helloH should output a falsey value.

• You can only have a single Truthy value and a single Falsey value. For example, outputting false for an Input String and 0 for another input String as Falsey values is not allowed.

• Standard loopholes are not allowed.

Test Cases

Input    ->    Output

"10h01"        Truthy
"Nothing"      Falsey
"Acccca"       Falsey
"eraser"       Falsey
"erase"        Truthy
"wow!"         Falsey
"wow"          Truthy
"H"            Truthy
""             Falsey

This is code-golf, so the shortest code in bytes wins!

Answer 1

Octave, 16 bytes

@(s)s(1)==s(end)

It takes a string s as input, and compares the first s(1) element with the last s(end).

This could be @(s)s(1)-s(end) if it was OK to swap true/false to false/true.

Answer 2

S.I.L.O.S, 81 bytes

loadLine
a=256
c=get a
lblb
t=s
s=get a
a+1
if s b
t-c
if t d
i+1
lbld
printInt i

Try it online!

Answer 3

Common Lisp, 83 74 61 58 bytes

Original: 83 bytes

I've just started learning Common Lisp, so I feel like I'm bringing a putter to a driving range. There must be some kind of recursive macro wizardry or array manipulation possible here that I'm not seeing.

This is an anonymous function that accepts a string as its input:

(lambda (s) (let ((n (- (length s) 1))) (when (> n 0) (eq (char s 0) (char s n)))))

Prettified:

(lambda (s)
  (let ((n (- (length s) 1)))
    (when (> n 0)
      (eq (char s 0)
          (char s n)))))

Would love to see a slicker solution!

Revision 1: 74 bytes

Gotta love those standard library functions!

Ugly:

(lambda (s) (when (> (length s) 0) (eq (elt s 0) (elt (reverse s) 0))))

Pretty:

(lambda (s)
  (when (> (length s) 0)
    (eq (elt s 0)
        (elt (reverse s) 0))))

Revision 1.5: 61 bytes

Whitespace!

(lambda(s)(when(>(length s)0)(eq(elt s 0)(elt(reverse s)0))))

Revision 2: 58 bytes

Ugly:

(lambda(s)(and(>(length s)0)(not(mismatch s(reverse s)))))

Pretty:

(lambda (s)
  (and (> (length s) 0)
       (not (mismatch s (reverse s)))))

That's all for now! I think I'm smarter already.

Answer 4

AWK, 29 34 bytes

This one might be cheating slightly, because it requires invoking AWK with the option:

`-F ''`

In GNU Awk you can use the long-form synonyms:

`--field-separator=''`

So I added 5 bytes to the total to account for this.

Ugly:

NR==1{a=$1}END{print(a==$NF)}

Pretty:

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}

Answer 5

Python, 51 bytes

s=input()
if s:print(s[0]==s[-1])
else:print(False)

Try it online!

Answer 6

Bash, 37 bytes

[ -n "$1" ]&&[ ${1:0:1} == ${1: -1} ]

Takes command line input and returns with exit status 0 (truthy) or 1 (falsy).

Test with:

bash test.sh "helloH" ; echo $?

Answer 7

Fireball, 4 bytes

d1╡├

Explanation:

d      Duplicate implicit input
 1╡    Get the first character
   ├   Check whether the input ends with the first character

Alternative program:

d↔♥├

Answer 8

Pyth, 9 bytes

.xqhzez!1

Try it online!

Could make it 5 bytes if I didn't have to deal with "", probably even less if I was good at Pyth.

Answer 9

JavaScript (ES6), 25 bytes

s=>/^(.)(.*\1)?$/.test(s)

21 bytes if we can return true for the empty string.

s=>s[0]==[...s].pop()

---

Try it

f=
s=>/^(.)(.*\1)?$/.test(s)
o.innerText=f(i.value="10h01")
i.oninput=_=>o.innerText=f(i.value)

<input id=i><pre id=o>

Answer 10

Python 3, 31 24 Bytes

lambda a:a[0]==a[-1]!=''

Old code:

def f(a):return a[0]==a[-1]!=''

This is pretty self explanatory; It takes a string a and checks if the first and last chars are equal, but I then had to add the !='' in order to satisfy the requirement "The input can be empty String as well, for which you should return a falsey value" because Python returns True for an empty string.

EDIT:

-7 Bytes thanks to @numbermaniac

Answer 11

Ruby, 16 17 bytes

Outputs true or false. Now with fixed syntax error.

p !! ~/./&~/#$&$/

Try it online!

Answer 12

Casio Basic, 46 bytes

StrLeft s,1,a
StrRight s,1,b
Print judge(a=b)

Strings aren't very nice to work with in this language. We need to take the first character from the left and right of the string, assign them to a and b, then print whether a is equal to b.

45 bytes for the code, 1 byte to enter s as parameter.

Answer 13

C, 50 40 36 bytes

Saved 10 bytes thanks to Dennis.

#define f(s)(*s&&*s==s[strlen(s)-1])

Equates to 0 if the first and last characters are different, or if the string is empty.

You could call f with something like:

int main(void)
{
    char s[100] = {0};
    gets(s);
    printf("%d\n",f(s));
}

Or, try it online!

Answer 14

PowerShell, 24 bytes

!("$args"[0,-1]|gu).Rank

Try it online!

Answer 15

Labyrinth, ²⁷ 20 bytes

,)!@
 : !
,} _
")=-:

Try it online!

-7 bytes thanks to Jo King.

Basic flow goes like this: start at the upper left corner, filter away the empty input at the first T-junction, take the rest of the string at the 2x2 loop, and test for equality at the last T-junction.

How it works

x marks the alternative paths at junctions, which should make the explanation easier to follow.

,)!@   Take char input (possibly EOF == -1), increment
 x     If EOF, top is 0, so go straight, print 0 and halt

 x     Otherwise, the string is not empty
 :     Duplicate the first char and move to aux. stack
,}     Go around the 2x2 loop `,")}`:
")x    Take next char input, increment, move to aux. stack
       until it hits EOF, where the stack is [first 0 | last ... first]
  @
  !    `=`: Swap the top of two stacks, giving [first last | (ignored)]
  _    Then calculate first - last
x=-x   If nonzero, take the north branch `_!@`: Push 0, print, halt

x)!@
 :     If zero, go all the way back to the first branch
x} x   (Eventually print 1 and halt)
x)=-:

Answer 16

Lexurgy, 27 bytes

a:
([]$1) []* !$1=>*
[]+=>a

Outputs an empty string for falsey, and a otherwise.

Explanation:

a:                # change...
([]$1)            # the first character
       []*        # then 0 or more any character, regex /.*/
           !$1    # then a character that's not the first
              =>* # change to an empty string
# equivalent regex: /(.).*\1/
[]+=>a            # replace the leftovers with "a"

Answer 17

Julia, 22 bytes

!s=s>""&&s[1]==s[end]   

Attempt This Online!

Answer 18

MUMPS, 27 bytes

 w x]""&($e(x)=$e(x,$l(x)))

Try it online!

• There is a leading space character so w is interpreted as a command and not a label.
• w is short for the write command which prints the following expression to the console.
• x]"" checks that x is not empty. ] is the "follows" operator and everything non-empty follows the empty string.
• $l is short for $length which returns the length of a string.
• $e is short for $extract which gets characters from a string. $e(x) gets the first character of x and $e(x,$l(x)) gets the last character of x.

It could be further reduced to 23 bytes in Intersystems Caché/IRIS by replacing $l(x) with *.

 w x]""&($e(x)=$e(x,*))

Answer 19

C#, 25 21 bytes

Uses the index operator ^ from C# 8 to get the last character in the string.

x=>x!=""&&x[0]==x[^1]

Try it online!

-4 bytes thanks to the default

Answer 20

Python 2, 36 35 bytes

-1 byte thanks to Erik the Outgolfer

lambda s:s[0]==s[-1]if s else False

Try it online!

Answer 21

Python, 31 bytes

lambda x:bool(x)and x[0]==x[-1]

Answer 22

QBIC, 12 11 bytes

?_s;|=_s_fA

Explanation:

?              PRINT
     =         -1 if equal, 0 if not, between
 _s;|          QBIC's Substring function takes a variable amount of parameters.
                 With only a string as argument it takes the leftmost char of it.
                 The ; takes a string from the cmd line and names it A$
                 | closes the call to Substring
      _s_fA    _f flips string A, _s without arguments takes the left 1 char again.

---

Original 12 byter, which takes a substring of 1 from the left and 1 from the right:

?_s;|=_sA,-1

Explanation of the second substring:

      _sA,-1   Another call to Substring
                 A$ is implicitly defined by the ; in the other substring
                 -1 sets the starting index at the last position
                 No argument for length = 1 char by default.
               No closing |, auto-added at EOF

Answer 23

Standard ML - 52 54 bytes

open String
fn s=>s<>""andalso sub(s,0)=sub(s,size s-1)

Answer 24

CJam, 6

q_W>#!

Try it online

Explanation:

q_     read and duplicate the input
W>     get the substring starting from the last position (W=-1)
        the result is empty if the input is empty
#      find the position of that substring within the initial string
        a bit surprising, position of empty string within itself is -1 (not found)
!      negate (0->1, non-zero->0)

Note: I consider the behavior of # with an empty substring to be a bug in CJam⩽0.6.5 and I will probably fix it in the next version. It's useful for this challenge though.

Answer 25

Excel, 38 bytes

=1*IFERROR(CODE(A1)=CODE(RIGHT(A1)),0)

Surprisingly longer than I expected, in order to get the same truthy/falsy for all cases. Text conditionals ignore case by default in excel, so "A"="a" is TRUE. Empty cells yield an error for CODE(). Multiplied by 1 to force everything to a number, rather than having TRUE, FALSE, or 0 cases.

Answer 26

Batch, 52 bytes

@set s=!=
@set/ps=
@if "%s:~,1%"=="%s:~-1%" echo 1

Outputs 1 if equal, nothing if not. set/p doesn't change the variable if nothing is entered, so I can initialise it to a failure case, and != seemed appropriate.

Answer 27

Ruby, 22 20 bytes

->x{x[0]===x[-1]||p}

Answer 28

Java 8, 29 bytes

s->s.matches("^(.)(.*\\1)?$")

Port of @Neil's Retina answer.

Try it here.

Answer 29

C, 34 bytes

f(char*s){s=*s&&*s==s[puts(s)-2];}

Try it online

C, 35 bytes

f(char*s){s=*s&&!strrchr(s,*s)[1];}

Try it online

Answer 30

Brain-Flak, 51 bytes

Includes +1 for -a

{(<([({})<{({}<>)<>}<>>]{})((){[()](<{}>)}{})>)}{}

Try it online!

Outputs 1 on top of the stack for truthy, and either nothing or 0 on top of the stack for falsy. These are consistent with Brain-Flak's "if" statement: {...}.

{(<                                          >)}{} # If there is input...
     ({})<            >                            #   Evaluate to the first char after...
          {({}<>)<>}<>                             #     reversing the entire stack
   ([                  ]{})((){[()](<{}>)}{})      # Check if the top 2 are equal
                                                   # I.e. first == last