Palindrome高尔夫球场

Question

目标：任何语言。最小的函数，它将返回一个字符串是一个回文。这是我的 Python ：

R=lambda s:all(a==b for a,b in zip(s,reversed(s)))

50个字符。

接受的答案将是当前最小的答案 - 当发现较小的答案时，这将会改变。请指定您的代码所在的语言。

Answer 1

J中有7个字符：不确定这是不是最好的方式，我对J有些新手：）

p=:-:|.

解释：|。反转输入。 - ：比较。操作数是隐含的。

p 'radar'
1

p 'moose'
0

Answer 2

这是我的;它是用我发明的特定领域语言编写的，叫做'回文'。

p

编辑：不那么轻率的版本（i386 asm，AT＆amp; T语法）

xor %eax, %eax
mov %esi, %edi
#cld    not necessary, assume DF=0 as per x86 ABI
repne scasb
scan:
    dec %edi
    cmpsb
    .byte 0x75, 6    #jnz (short) done
    dec %edi
    cmp %esi, %edi
    .byte 0x72, -9    #jb (short) scan
inc %eax
done:

16个字节，字符串指针在ESI中，结果在EAX中。

Answer 3

可悲的是，我无法理解千言万语......

（LabVIEW。是的，他们会在这里发布任何流浪汉帖子;）

Answer 4

Haskell， 15 字符：

p=ap(==)reverse

更易读的版本， 16 字符：

p x=x==reverse x

Answer 5

另一个相当短的python版本（21个字符）：

R=lambda s:s==s[::-1]

Answer 6

冒着获得投票的风险，大多数所有这些只是调用某种隐藏所有真实编程逻辑的命令 reverse 。

我想知道在这些语言中，最短的手动方式是什么。

Answer 7

使用C＃和LINQ运算符：

public bool IsPalindrome(string s)
{
    return s.Reverse().SequenceEqual(s);
}

如果你认为Reverse是作弊，你可以通过减少来完成整个事情：

public bool IsPalindrome(string s)
{
    return s.Aggregate(new StringBuilder(),
                       (sb, c) => sb.Insert(0, c),
                       (sb) => sb.ToString() == s);
}

Answer 8

Perl（27个字符）：

sub p{
 Perl（27个字符）：

def p(a)a==a.reverse end


 Ruby（24个字符）：

<*>[0]eq reverse
 Perl（27个字符）：

<*>

 Ruby（24个字符）：

<*>[0]}

Ruby（24个字符）：

<*>

Answer 9

用java编写的73个干净，可读，字符

boolean p(String s){return s.equals(""+new StringBuffer(s).reverse());}

和平:)

Answer 10

无意义的Haskell版本（15个字符，但除非你包含Control.Arrow和Control.Monad并且忽略单态限制，否则不会真正起作用）：

p=ap(==)reverse

Answer 11

Lua的目标更多是可读性而不是简洁性，但却是一个诚实的37个字符：

function p(s)return s==s:reverse()end

变体，只是为了好玩（同样大小）：

p=function(s)return s==s:reverse''end

JavaScript版本更冗长（55个字符），因为它没有字符串反转功能：

function p(s){return s==s.split('').reverse().join('')}

Answer 12

(equal p (reverse p))

口齿不清。 18个字符。

好的，这是一个特例。如果直接输入到lisp解释器并且已经定义了p，这将有效。

否则，这是必要的：

(defun g () (equal p (reverse p)))

28个字符。

Answer 13

我会更进一步：完整的c代码，编译然后去。

90个字符

main(int n,char**v){char*b,*e;b=e=v[1];while(*++e);for(e--;*b==*e&&b++<e--;);return b>e;}

Answer 14

F＃（很像C＃示例）

let p s=let i=0;let l=s.Length;while(++i<l)if(s[i]!=[l-i-1]) 0; 1;;

Answer 15

PHP：

function p($s){return $s==strrev($s);} // 38 chars

或者，只是

$s==strrev($s); // 15 chars

Answer 16

是不是在你的语言中使用反向功能有点作弊？我的意思是，看看Ruby解决方案给出了

def p(a)a==a.reverse end

您可以轻松地将其重写为

def p(a)a==a.r end

并且只是说您在代码中创建了一个扩展方法，以便“r”叫反向。我希望看到人们发布不包含其他功能调用的解决方案。当然，应该允许字符串长度函数。

没有反向的Ruby - 41个字符

def m(a)a==a.split('').inject{|r,l|l+r}end

VB.Net - 173 Chars

Function P(ByVal S As String) As Boolean
    For i As Integer = 0 To S.Length - 1
        If S(i) <> S(S.Length - i - 1) Then
            Return False
        End If
    Next
    Return True
End Function

Answer 17

Golfscript，5 char

.-1%=

$ echo -n abacaba | ruby golfscript.rb palindrome.gs
1

$ echo -n deadbeef | ruby golfscript.rb palindrome.gs
0

Answer 18

Common Lisp，短作弊版（23个字符）：

#L(equal !1(reverse !1))

#L是由SHARPL-READER在iterate包中实现的读取器宏字符。它基本上等同于（lambda（！1）...）。

Common Lisp，只使用原语的长版本（137包括空格，可压缩到108）：

(defun p (s)
  (let ((l (1- (length s))))
    (iter (for i from l downto (/ l 2))
          (always (equal (elt s i) (elt s (- l i)))))))

同样，它使用了iterate，它基本上是内置LOOP工具的一个更干净的版本，因此我倾向于将其视为核心语言。

Answer 19

不是最短的，非常事后的，但我无法帮助在MATLAB中试一试：

R=@(s)all(s==fliplr(s));

24个字符。

Answer 20

C＃没有反向功能 84个字符

int p(char[]s){int i=0,l=s.Length,t=1;while(++i<l)if(s[i]!=s[l-i-1])t&=0;return t;} 

C＃没有反向功能 86个字符

int p(char[]s){int i=0;int l=s.Length;while(++i<l)if(s[i]!=s[l-i-1])return 0;return 1;}

VBScript 41 chars

function p:p=s=strreverse(s):end function

Answer 21

18个字符perl正则表达式

/^(.?|(.)(?1)\2)$/

Answer 22

C中有52个字符，但需要注意的是，字符串的一半将被覆盖：

<代码> P（字符* S）{返回* S ||（S [strlen的（S）-1] - = * S）＆安培;！＆安培; P（++为s）;}

没有库调用它是64个字符：

<代码> P（字符* S）{字符* E = S;而（* E）++é;返回* S ||（* - 电子 - = * S）＆安培;！＆安培，P （++为s）;}

Answer 23

受上一篇文章的启发，69个字符

p(char*a){char*b=a,q=0;while(*++b);while(*a)q|=*a++!=*--b;return!q;}

编辑：关闭一个字符：

p(char*a){char*b=a,q=0;while(*++b);while(*a)q|=*a++%*--b;return!q;}

EDIT2：65个字符：

p(char*a){char*b=a;while(*b)b++;while(*a&&*a++==*--b);return!*a;}

Answer 24

Haskell，28个字符，需要Control.Arrow导入。

p=uncurry(==).(id&&&reverse)

Answer 25

使用标准库函数在C语言中直接实现，受到其他C语言答案中strlen的启发。

字符数：57

p(char*s){char*r=strdup(s);strrev(r);return strcmp(r,s);}

忏悔：我不是在这里释放r而成为坏人。我目前的努力是好的：

p(char*s){char*r=strdup(s);s[0]=strcmp(strrev(r),s);free(r);return s[0];}

带来73个字符;我正在考虑采取任何缩短方法。

Answer 26

Clojure使用37个字符：

user=> (defn p[s](=(seq s)(reverse(seq s))))
#'user/p
user=> (p "radar")
true
user=> (p "moose")
false

Answer 27

Perl中的24个字符。

sub p{
 Perl中的24个字符。

<*>[0]eq+reverse@_}

Answer 28

Groovy 17B：

  

<代码> P = {它==它[-1..0]}

缺点是它不适用于emptry string。

第二个想法，抛出空字符串的异常是合理的，因为你无法判断是否有任何回文。

Answer 29

不使用任何库函数（因为你应该真正添加 #include 成本），这里是96中的C ++版本：

int p(char*a,char*b=0,char*c=0){return c?b<a||p(a+1,--b,c)&&*a==*b:b&&*b?p(a,b+1):p(a,b?b:a,b);}

Answer 30

我在C中的尝试（70个字符）：

P(char*s){char*e=s+strlen(s)-1;while(s<e&&*s==*e)s++,e--;return s>=e;}

[编辑]现在实际工作了 [编辑2]使用默认的int return

从74减少到70

回应一些评论：我不确定预处理程序滥用是否重要 - 你可以在命令行中定义整个内容并使函数成为一个字符。