任务

在此挑战中，您的任务是编写一个程序或函数，该程序或函数接受String，并根据输入String的第一个字符和最后一个字符是否相等，输出真值或伪值。

输入值

您可以以任何合理的方式接受输入。但是，不允许输入存在于预定义变量中。允许从文件，控制台，命令行，输入字段等进行读取，或将输入作为函数参数。

输出量

除了将结果分配给变量外，您可以以任何合理的格式输出。return允许写入文件，控制台，命令行，模式框，函数语句等。

附加规则

• 输入也可以是空String，您应该为其返回falsey值。

• 单字符输入字符串应得到真实的结果。

• 您的程序应区分大小写。helloH应该输出一个falsey值。

• 您只能有一个Truthy值和一个Falsey值。例如，不允许将false一个输入字符串和0另一个输入字符串输出为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])

Mathematica，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)?$

在线尝试！包括测试套件。编辑：由于@Kobi，节省了1个字节。

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

在线尝试

Brachylog，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]

在线尝试！

疯子，43字节

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

在线尝试！

说明

主循环是[>[->+<<->],]。每次迭代之后，当前位置右边的单元格是字符串的第一个字节，而左边单元格是最近处理的字符与第一个字符之间的差。 <[[-]-<]如果非零，则将最终结果转换为-1，其余的将-1和0转换为48和49（分别为“ 0”和“ 1”）。

Haskell，21个字节

c取String并返回Bool。

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

在线尝试！

• 如果不是空字符串，则可能是16个字节c s=s!!0==last s。
• take 1s给出一个列表，仅仅是第一要素s，除非s是空的，在这种情况下它是空的了。
• last s 会在一个空字符串上出错，但是Haskell的懒惰将其保存：具有单个元素的字符串总是与空字符串不同，而不评估其元素。

MATL，5个字节

&=PO)

在MATL在线上尝试一下！

说明

       % 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

在这种情况下，必须处理一个空的输入字符串，那么类似下面的内容（8个字节）将起作用

&=POwhO)

此解决方案只是将a 0放在N x N矩阵的前面，这样对于空输入，当矩阵为时0 x 0，仍然有一个0值，然后由0)

在MATL Online上尝试

Japt，6个字节

tJ ¥Ug

在线尝试！

APL（Dyalog），4个字节

⊃⌽=⊃

在线尝试！

说明

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

这是对空字符串起作用的原因。应用于⊃空字符串将返回一个空格。但是反转一个空字符串仍然会返回一个空字符串，因此将一个空字符串与一个非空字符串（在这种情况下）进行比较会得出一个空的数值向量。并应用于⊃空数值向量return 0。因此，传递空字符串将返回0。

Java，52个 43字节

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

要使其工作，请将其输入到使lambda“运行”的函数中，例如以下代码：

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

Ruby，26个 24字节

感谢@philomory，节省了两个字节！

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

Codegolf上的第一篇文章-））

PHP> = 7.1，23字节

打印1表示相等，如果字符不同则不打印

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

迅捷，57字节

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

C＃，38 30字节

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

感谢@raznagul，节省了8个字节。

R，40个字节

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

感谢Nitrodon提供了-2个字节。

感谢-8字节的MickyT。

测试：

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

输出：

> 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字节

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

这是我第一次使用> <>和打高尔夫球代码，因此将为您提供有益的建议。

该代码分为三个基本部分。

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表格，33字节

从单元格获取输入，[A1]并输出1真输入和0假输入。

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

请注意，用户输入公式文字并按Enter离开该单元格后，Google表格会自动更正此括号，Exact(并且Right(不会关闭这些括号。

输出量

R， 50 43 41 40 64

第二个解决方案具有41个字节的可调用函数-感谢@ niczky12＆@Giuseppe-修改了x =“”

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

首先是50个字节，但不是挑战

function(x){charToRaw(x)[1]==rev(charToRaw(x))[1]}

八度，16字节

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

它以字符串s作为输入，并将第一个s(1)元素与最后一个元素进行比较s(end)。

可以@(s)s(1)-s(end)交换true/false到false/true。

GNU grep，12个字节

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

在扩展或PCRE模式下运行。

我不知道这是否被认为是作弊行为。

JavaScript，20个字节

f=在开始处添加并调用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>

说明

该函数接受一个参数_。在函数体中，_[0]==_.slice(-1)检查_（在0索引处）的第一个元素是否等于其最后一个元素，并返回适当的值true或false布尔值。

SILOS，81个字节

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

在线尝试！

Common Lisp，83 74 61 58字节

原始：83个字节

我刚刚开始学习Common Lisp，所以我觉得我正在将推杆带到练习场。我可能没有看到某种可能的递归宏向导或数组操作。

这是一个匿名函数，它接受字符串作为输入：

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

美化：

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

希望看到一个更好的解决方案！

修订版1：74个字节

一定喜欢那些标准的库函数！

丑陋：

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

漂亮：

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

修订1.5：61个字节

空格！

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

修订版2：58个字节

丑陋：

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

漂亮：

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

目前为止就这样了！我想我已经更聪明了。

AWK，29 34字节

这可能有点作弊，因为它需要使用以下选项来调用AWK：

`-F ''`

在GNU Awk中，您可以使用长格式同义词：

`--field-separator=''`

因此，我在总数中增加了5个字节来解决这个问题。

丑陋：

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

漂亮：

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}