code-golf - 回文高尔夫

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

冒着被否决票的风险，所有这些都只是调用某种隐藏所有真实编程逻辑的命令反向。

我想知道在每种语言中执行此操作的最短手动方法是什么。

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

红宝石（24 个字符）：

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

Answer 9

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

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

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

PHP：

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

要不就

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

Answer 15

在您的语言中使用反向功能不是有点作弊吗？我的意思是，查看 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 个字符

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 16

F#（很像 C# 示例）

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

Answer 17

Golfscript，5 个字符

.-1%=

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

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

Answer 18

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 个字符

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

Answer 19

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 20

灵感来自上一篇文章，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 21

不是最短的，而且是事后的，但我忍不住在 MATLAB 中尝试一下：

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

24 个字符。

Answer 22

18 个字符的 perl 正则表达式

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

Answer 23

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 24

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

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

Answer 25

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

字符数：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

不使用任何库函数（因为你也应该增加#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 27

时髦的 17B：

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

缺点是它不适用于空字符串。

再想一想，为空字符串抛出异常是合理的，因为您无法判断是否没有回文。

Answer 28

Clojure 使用 37 个字符：

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

Answer 29

Perl 中的 24 个字符。

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

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

作为对一些评论的回应：我不确定预处理器滥用是否算数——您可以在命令行上定义整个内容并将函数设为一个字符。

Answer 31

Haskell，36 个字符，包括它自己的反向函数。（实际上，如果您使用分号使其成为单行，并忽略末尾的换行符，则为 35...）

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

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

Answer 32

Perl（21 个字符）：

sub{"@_"eq reverse@_}

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

Answer 33

F#，没有 LINQ 和 Reverse 方法。序列折叠：

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 34

CFScript，39 个字符：

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

我从来都不擅长打高尔夫球。

Answer 35

爪哇：

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

上面的不行，哎呀！

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

嗯。

Answer 36

外壳脚本（sed + tac + tr）：

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

Answer 37

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

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

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

Answer 38

C，无库，70 个字符：

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

正如对另一个 C 解决方案的评论之一提到的那样，原型在 C 中是完全可选的，int假定在任何地方都会出现类型，但没有被提及。没有人用 pre-ANSI C 编程过吗？

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

Answer 39

JavaScript：55 个字符

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

以上将不起作用，因为您需要join调用""

JavaScript：55 个字符

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

Answer 40

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 41

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

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

Answer 42

C，68 个字符，无库：

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

Answer 43

may 很好地给出了一个使用标准库的 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 44

Python 中的 58 个字符，无需反转字符串：

r="y"
对于我在范围内（len（s））：
 如果（s[i]！=s[-i-1]）：
  r="n"

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

Answer 45

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 46

F#：29 个字符

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

（假设 System.Linq 已导入）

Answer 47

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 48

不可能的！language，假设使用普通参数传递字符串：

;~=

3 个字符

Answer 49

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 50

上面 Josh 的 Java 代码片段每次都会返回 true。