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{$_[0]eq reverse$_[0]}

Ruby（24个字符）：

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

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

(equal p (reverse p))

口齿不清。 18个字符。

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

否则，这是必要的：

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

28个字符。

Answer 12

我会更进一步：完整的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 13

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 14

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

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

您可以轻松地将其重写为

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

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

没有反向的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 15

F＃（很像C＃示例）

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

Answer 16

PHP：

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

或者，只是

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

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

受上一篇文章的启发，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 19

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 20

18个字符perl正则表达式

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

Answer 21

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

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

24个字符。

Answer 22

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

p(char*s){return!*s||!(s[strlen(s)-1]-=*s)&&p(++s);}

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

p(char*s){char*e=s;while(*e)++e;return!*s||!(*--e-=*s)&&p(++s);}

Answer 23

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 24

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

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

Answer 25

Perl中的24个字符。

sub p{$_[0]eq+reverse@_}

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

使用标准库函数在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 28

不使用任何库函数（因为你真的应该加上#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 29

Groovy 17B：

  

p={it==it[-1..0]}

缺点是它不适用于emptry string。

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

Answer 30

Perl（21个字符）：

sub{"@_"eq reverse@_}

嘿，这个问题没有指定名为的子程序！

Answer 31

Haskell，36个字符，包括其自身的反向功能。 （实际上，如果你使用分号使其成为单行，并且最后忽略换行符，那么它就是35 ......）

r[]y=y
r(a:x)y=r x$a:y
p s=s==r s[]

与其他实现一样，“p”是回文谓词。

Answer 32

F＃，没有LINQ和反向方法。 Seq.fold：

let p (s : string) = 
  fst(s |> Seq.fold (fun (r, i) c -> (r && c = s.[s.Length - 1 - i], i + 1)) (true, 0))

相同，但使用Seq.iteri和ref变量而不是Seq.fold：

let p (s : string) = 
  let r = ref true
  Seq.iteri (fun i c -> r :=  (!r && c = s.[s.Length - 1 - i])) s
  !r

Answer 33

我在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

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

Answer 34

Shell脚本（sed + tac + tr）：

test "`echo $1|sed -e 's/\(.\)/\1\n/g'|tac|tr -d '\n'`" == "$1"

Answer 35

JavaScript，64个字节。

function a(x){for(r='',i=x.length;i>0;i--)r+=x[i-1];return x==r}

测试用例：

a('lolol'); // true
a('haha');  // false

Answer 36

<强>不可能！语言，假设使用普通的args传递字符串：

;~=

3个字符

Answer 37

C＃使用递归lambda 函数而不使用Reverse函数（115个字符）：

Func<string,bool>p=null;p=w=>{if(w.Length<2)return true;return w[0]==w[w.Length-1]&&p(w.Substring(1,w.Length-2));};

Answer 38

F＃：29个字符

let p(s:string)=s=s.Reverse()

（假设导入了System.Linq）

Answer 39

CFScript，39个字符：

function y(x){return(x is reverse(x));}

我从来都不擅长高尔夫。

Answer 40

javascript递归版（没有反向垃圾）

function p(s){l=s.length;return l<2||(s[0]==s[l-1]&&p(s.substr(1,l-2)))}

（72个字符）

或在内部实现反向：

p=function(s,y){return y?(s==p(s)):s[1]?(p(s.substr(1))+s[0]):s[0]}

p("hannah",1);

（67个字符）

或者，根本不使用内置函数......

p=function(s,y,i){
return i?s[i]?s[i]+p(s,0,i+1):'':y?(s==p(s)):s[1]?(p(p(s,0,1))+s[0]):s[0]
}

p("hannah",1);

（92个字符）

最短我能想到:(迭代）

function p(s,l){for(c in s){if(s[c]!=s[l-1-c])s=0}return s}

p("hannah",6);// (is this cheating?)

（59个字符）

期待看到你在javascript中做得更好！

（最好不使用任何内置功能，尤其是反向）

（对'return s == s.reverse（）'类型答案不是很感动）

Answer 41

爪哇：

boolean y(StringBuffer x){return x.equals(x.reverse());}

以上不起作用，哎呀！

boolean y(StringBuffer x){return x.toString().equals(x.reverse().toString()); }

的E w

Answer 42

JavaScript：55个字符

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

以上操作无效，因为您需要使用join

致电""

JavaScript：55个字符

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

Answer 43

绝对不是最小的，但我还是想添加一个条目：

sub p{return @_==reverse split//;}

我的perl生锈了，这是未经测试的。

Answer 44

Python中的58个字符，没有反转字符串：

r="y"
for i in range(len(s)):
 if(s[i]!=s[-i-1]):
  r="n"

也许for循环可以优化？ Python对我来说是新的......

Answer 45

可能很好地给出了一个使用标准库的c ++示例：

bool p(const std::string &s){std::string s2(s);std::reverse(s2);return s==s2;}

感谢Jon For指出，如果我们制作一些不必要的副本，这可能会更短。共计67个字符。

bool p(std::string s){std::string x=s;std::reverse(x);return s==x;}

Answer 46

C，没有库，70个字符：

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

作为对提到的另一个C解决方案的评论之一，原型在C中是完全可选的，int假定类型可以到处但未提及。没有人曾在ANSI C之前编程吗？

编辑：缩短并处理空字符串。

Answer 47

C，68个字符，没有libs：

p(char *s){char *e=s;while(*++e);for(;*s==*--e&&s++<e;);return s>e;}

Answer 48

标准ML（34个字符和无聊）：

fun p s=s=implode(rev(explode(s)))

Answer 49

Java，不使用反向：

boolean p(String s){int i=0,l=s.length();while(i<l){if(s.charAt(i++)!=s.charAt(--l))l=-1;}return l>=0;

Answer 50

Josh的Java片段每次都会返回true。