Завдання

У цьому завданні ваше завдання полягає в тому, щоб написати програму або функцію, яка приймає в String і виводить значення truthy або falsey на основі того, чи є рівними перший символ і останній символ вхідної String.

Вхідні дані

Ви можете взяти вклад будь-яким розумним способом. Однак припустити, що вхід присутній у заздалегідь заданій змінній, не допускається. Допускається читання з файлу, консолі, командного рядка, поля введення тощо або ж введення даних як аргументу функції.

Вихідні дані

Ви можете виводити в будь-якому розумному форматі, крім присвоєння результату змінній. returnДозволяється запис у файл, консоль, командний рядок, модальне вікно, операційні функції тощо.

Додаткові правила

• Вхід може також бути порожнім рядком, для якого слід повернути значення фальси.

• Однострумові вхідні рядки повинні мати тривалий результат.

• Ваша програма повинна враховувати регістри. helloHмає вивести значення фальси.

• Ви можете мати лише одне значення Truthy та одне значення Falsey. Наприклад, виведення falseдля рядка введення та 0для іншого введення String як значення Falsey заборонено.

• Стандартні лазівки заборонені.

Випробування

Input    ->    Output

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

Це код-гольф , тому найкоротший код у байтах виграє!

Желе , 3 байти

=ṚḢ

Спробуйте в Інтернеті!

Python 3 , 23 байти

s=input()
s[0]!=s[-1]<e

Вихід здійснюється за допомогою вихідного коду, тому 0 (успіх) є тривожним, а 1 (невдача) - хибним. Якщо це прийнятно, байт можна зберегти.

Спробуйте в Інтернеті!

Як це працює

Перш за все, якщо s порожній рядок, s[0]підніме IndexError , в результаті чого програма вийде з ладу.

Для порожніх s , якщо перший та останній символи рівні, s[0]!=s[-1]оцінюватиметься як False , тому програма виходить чисто та негайно.

Нарешті, якщо персонажі різні, s[0]!=s[-1]оцінюватиметься як True , викликаючи порівняння s[-1]<e. Оскільки e не визначено, це викликає NameError .

Якщо сумісність із Python 2 назад не бажана,

s[0]!=s[-1]<3

працює також, оскільки порівняння рядка з цілим числом викликає TypeError .

JavaScript, 19 байт

a=>a.endsWith(a[0])

Математика, 15 байт

#&@@#===Last@#&

Займає масив символів. Випускає помилки, коли вхід порожній, але його можна ігнорувати.

05AB1E , 4 байти

S¬Q¤

Спробуйте в Інтернеті! або Спробуйте всі тести

S    # Split the input into individual characters
 ¬   # Get the first character
  Q  # Check all characters for equality to the first
   ¤ # Get the last value i.e. head == tail

Сітківка , 13 12 байт

^(.)(.*\1)?$

Спробуйте в Інтернеті! Включає тестовий набір. Редагувати: Збережено 1 байт завдяки @Kobi.

C ++, 39 байт

[](auto s){return s[0]&&s[0]==s.back();}

Повні програми:

#include <string>
#include <iostream>

using namespace std;

int main()
{
    string t = "";
    auto f = [](auto s){return s[0]&&s[0]==s.back();};
    cout << f(t);
}

Спробуйте в Інтернеті

Брахілог , 4 байти

h~t?

Спробуйте в Інтернеті!

Пояснення

h       The head of the Input...
 ~t?    ...is the tail of the Input

Java, 81 77 байт

• -4 байти, дякую @KevinCruijssen

Спробуйте в Інтернеті

boolean f(String s){int l=s.length();return l>0&&s.charAt(l-1)==s.charAt(0);}

• Повертає , trueякщо вони рівні, в іншому випадку false, falseдля порожнього рядка

Версія масиву, 60 байт

boolean f(char[]s){int l=s.length;return l>0&&s[0]==s[l-1];}

Python 2 , 26 25 24 байти

Дякуємо @Dennis за збереження байта!

lambda x:""<x[:1]==x[-1]

Спробуйте в Інтернеті!

brainfuck, 43 bytes

+>,[<,[>[->+<<->],]]<[[-]-<]-[----->+<]>--.

Try it online!

Explanation

The main loop is [>[->+<<->],]. After each iteration, the cell to the right of the current position is the first byte of the string, and the cell to the left is the difference between the most recently handled character and the first. <[[-]-<] converts the final result to -1 if nonzero, and the rest converts -1 and 0 to 48 and 49 ("0" and "1") respectively.

Haskell, 21 bytes

c takes a String and returns a Bool.

c s=take 1s==[last s]

Try it online!

• If not for empty strings, this could have been 16 bytes with c s=s!!0==last s.
• take 1s gives a list that is just the first element of s unless s is empty, in which case it's empty too.
• last s would error out on an empty string, but Haskell's laziness saves it: A string with a single element is always different from the empty string, without evaluating its element.

MATL, 5 bytes

&=PO)

Try it at MATL Online!

Explanation

       % Implicitly grab input as a string (of length N)
&=     % Perform an element-wise equality check yielding an N x N matrix
P      % Flip this matrix up-down
O)     % Get the last value in the matrix (column-major ordering)
       % Implicitly display the result

In the case, that an empty input string must be handled, then something like the following (8 bytes) would work

&=POwhO)

This solution simply prepends a 0 to the front of the N x N matrix such that for an empty input, when the matrix is 0 x 0, there's still a 0 value that is then grabbed by 0)

Try it at MATL Online

Japt, 6 bytes

tJ ¥Ug

Try it online!

APL (Dyalog), 4 bytes

⊃⌽=⊃

Try it online!

Explanation

  =                     Compare
   ⊃                    The first element of the right argument with
 ⌽                      The right argument reversed
                        This will return an array of the length of the reversed argument. Each element in the resulting array will be either 0 or 1 depending on whether the element at that position of the reversed argument equals the first element of the original right argument
                        So with argument 'abcda', we compare 'a' with each character in 'adcba' which results in the array 1 0 0 0 1
⊃                       From this result, pick the first element.

Here is the reason this works on empty strings. Applying ⊃ to an empty string returns a space . But reversing an empty string still returns an empty string, so comparing an empty string with a non-empty string (in this case ) gives an empty numerical vector. And applying ⊃ to an empty numerical vector returns 0. Hence passing an empty string returns 0.

Java, 52 43 bytes

s->!s.isEmpty()&&s.endsWith(""+s.charAt(0))

To make it work, feed this into a function such as the following that makes a lambda "go":

private static boolean f(Function<String, Boolean> func, String value) {
  return func.apply(value);
}

Ruby, 26 24 bytes

Saved two bytes thanks to @philomory!

->e{!!e[0]>0&&e[0]==e[-1]}

First post on codegolf -))

PHP>=7.1, 23 Bytes

prints 1 for equal and nothing if the character is different

<?=$argn[0]==$argn[-1];

Swift, 57 bytes

var s=readLine()!,a=Array(s.characters);a[0]==a.last ?1:0

C#, 38 30 bytes

s=>s!=""&&s[0]==s[s.Length-1];

Saved 8 bytes thanks to @raznagul.

R, 40 bytes

function(x)x>""&&rev(y<-charToRaw(x))==y

Thanks to Nitrodon for -2 bytes.

Thanks to MickyT for -8 bytes.

Test:

f=function(x)x>""&&rev(y<-charToRaw(x))==y
test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
sapply(test, f)
all(sapply(test, f) == c(T, F, F, F, T, T, F))

Output:

> f=function(x)x>""&&rev(y<-charToRaw(x))==y
> test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
> sapply(test, f)
  10h01 Nothing  Acccca    wow!     wow       H         
   TRUE   FALSE   FALSE   FALSE    TRUE    TRUE   FALSE 
> all(sapply(test, f) == c(T, F, F, F, T, T, F))
[1] TRUE

><>, 39 33 bytes

 2i&01. >~&-?v1v
  i:1+?!^01. >0>n;

This is my first time both using ><> and playing code golf, so helpful suggestions would be appreciated.

The code is in three basic sections.

2i&01. Pushes an arbitrary number (2 in this case, this causes an empty string to print 0) onto the stack and puts the input's first character in the register.

>i:1+?!^01. Main loop. Pushes the next character onto the stack. If the string has been read completely, then go to the last section

>~&-?v1v
     >0>n;  Compare the first and last characters. Print 1 if they're the same, 0 if not

Google Sheets, 33 Bytes

Takes input from cell [A1] and outputs 1 for truthy input and 0 for falsey input.

=(A1<>"")*Exact(Left(A1),Right(A1

It is noted that the parentheticals in Exact( and Right( are left unclosed as Google Sheets automatically corrects this as soon as the user has input the formula text and pressed enter to leave that cell.

Output

R, 50 43 41 40 64

Second solution with 41 bytes for a callable function - thanks to @niczky12 & @Giuseppe - amended for x=""

r=function(x,y=utf8ToInt(x))ifelse(x=="","FALSE",(y==rev(y))[1])

First with 50 bytes but not for the challenge

function(x){charToRaw(x)[1]==rev(charToRaw(x))[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.

GNU grep, 12 bytes

^(.)(.*\1)?$

Run in extended or PCRE mode.

I don't know if this is considered cheating or not.

JavaScript, 20 bytes

Add f= at the beginning and invoke like f(arg).

_=>_[0]==_.slice(-1)

f=_=>_[0]==_.slice(-1)

i.oninput = e => o.innerHTML = f(i.value);

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

Explanation

This function takes in an argument _. In the function body, _[0]==_.slice(-1) checks whether the first element of _ (at 0th index) equals the last element of it, and returns the appropriate true or false boolean.

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!

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.

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