The goal: Any language. The smallest function which will return whether a string is a palindrome. Here is mine in Python:
R=lambda s:all(a==b for a,b in zip(s,reversed(s)))
50 characters.
The accepted answer will be the current smallest one - this will change as smaller ones are found. Please specify the language your code is in.
7 characters in J: Not sure if this is the best way, I'm somewhat new to J :)
p=:-:|.
explanation: |. reverses the input. -: compares. the operands are implicit.
p 'radar'
1
p 'moose'
0
Here's mine; it's written in a domain-specific language I invented, called 'palindrome'.
p
Edit: Less flippant version (i386 asm, AT&T syntax)
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 bytes, string pointer goes in ESI, result is in EAX.
Sadly, I'm unable to get under a thousand words...
(LabVIEW. Yeah, they'll let just about any hobo post here ;)
Haskell, 15 chars:
p=ap(==)reverse
More readable version, 16 chars:
p x=x==reverse x
Another python version that is rather shorter (21 chars):
R=lambda s:s==s[::-1]
At the risk of getting down votes, most all of these just call a command reverse of some sort that hides all the real programming logic.
I wonder what the shortest manual way to do this is in each of these languages.
With C# and LINQ operators:
public bool IsPalindrome(string s)
{
return s.Reverse().SequenceEqual(s);
}
If you consider Reverse as cheating, you can do the entire thing with a reduction:
public bool IsPalindrome(string s)
{
return s.Aggregate(new StringBuilder(),
(sb, c) => sb.Insert(0, c),
(sb) => sb.ToString() == s);
}
s.Reverse().ToString()==s; and the second as !s.Where((c,i)=>c!=s[s.Length-i-1]).Any() –
Paver Perl (27 chars):
sub p{$_[0]eq reverse$_[0]}
Ruby (24 chars):
def p(a)a==a.reverse end
->(e){e.reverse==e}, but I don't know if its considered as a "function" (I guess it does) –
Enthrall 73 clean, readable, chars written in java
boolean p(String s){return s.equals(""+new StringBuffer(s).reverse());}
peace :)
Pointless Haskell version (15 chars, though doesn't really work unless you include Control.Arrow and Control.Monad and ignore the monomorphism restriction):
p=ap(==)reverse
I'll take it a little bit further: full c code, compile and go.
90 characters
main(int n,char**v){char*b,*e;b=e=v[1];while(*++e);for(e--;*b==*e&&b++<e--;);return b>e;}
Lua aims more at readability than conciseness, yet does an honest 37 chars:
function p(s)return s==s:reverse()end
variant, just for fun (same size):
p=function(s)return s==s:reverse''end
The JavaScript version is more verbose (55 chars), because it doesn't has a string reverse function:
function p(s){return s==s.split('').reverse().join('')}
(equal p (reverse p))
lisp. 18 characters.
ok, this is a special case. This would work if typed directly into a lisp interpreter and p was already defined.
otherwise, this would be necessary:
(defun g () (equal p (reverse p)))
28 characters.
reverse works on any sequence, equal works on strings, bit vectors, and conses (lists), among others that are not interesting with respect to a palindrome. –
Ca (defun p(p)(equal p(reverse p))) :o) –
Ca Golfscript, 5 char
.-1%=
$ echo -n abacaba | ruby golfscript.rb palindrome.gs
1
$ echo -n deadbeef | ruby golfscript.rb palindrome.gs
0
F# (a lot like the C# example)
let p s=let i=0;let l=s.Length;while(++i<l)if(s[i]!=[l-i-1]) 0; 1;;
Isn't using the reverse function in your language kind of cheating a bit? I mean, looking at the Ruby solution give as
def p(a)a==a.reverse end
you could easily rewrite that as
def p(a)a==a.r end
and just say that you made an extension method in your code so that "r" called reverse. I'd like to see people post solutions that don't contain calls to other functions. Of course, the string length function should be permitted.
Ruby without reverse - 41 characters
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
PHP:
function p($s){return $s==strrev($s);} // 38 chars
or, just
$s==strrev($s); // 15 chars
52 characters in C, with the caveat that up to half the string will be overwritten:
p(char*s){return!*s||!(s[strlen(s)-1]-=*s)&&p(++s);}
Without library calls it's 64 characters:
p(char*s){char*e=s;while(*e)++e;return!*s||!(*--e-=*s)&&p(++s);}
Not the shortest, and very after-the-fact, but I couldn't help giving it a try in MATLAB:
R=@(s)all(s==fliplr(s));
24 chars.
Inspired by previous post, 69 characters
p(char*a){char*b=a,q=0;while(*++b);while(*a)q|=*a++!=*--b;return!q;}
EDIT: Down one char:
p(char*a){char*b=a,q=0;while(*++b);while(*a)q|=*a++%*--b;return!q;}
EDIT2: 65 chars:
p(char*a){char*b=a;while(*b)b++;while(*a&&*a++==*--b);return!*a;}
while(*++b); will crash accessing unmapped memory. I'm not sure if there are any implementations in which this can happen, but fixing it costs one character: while(*b)++b; Since it's currently 64 chars (not 65), that'd bring it up to 65 chars. –
Rhineland Common Lisp, short-and-cheating version (23 chars):
#L(equal !1(reverse !1))
#L is a reader macro character implemented by SHARPL-READER in the iterate package. It's basically equivalent to (lambda (!1) ...).
Common Lisp, long version using only primitives (137 including whitespace, compressible down to 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)))))))
Again, it uses iterate, which is basically a cleaner version of the builtin LOOP facility, so I tend to treat it as being in the core language.
C# Without Reverse Function 84 chars
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# Without Reverse Function 86 chars
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
Clojure using 37 characters:
user=> (defn p[s](=(seq s)(reverse(seq s))))
#'user/p
user=> (p "radar")
true
user=> (p "moose")
false
Groovy 17B:
p={it==it[-1..0]}
Downside is that it doesn't work with emptry string.
On second thought, throwing exception for empty string is reasonable since you can't tell if nothing is palindrome or not.
Without using any library functions (because you should really add in the #include cost as well), here's a C++ version in 96:
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);}
Straightforward implementation in C using standard library functions, inspired by the strlen in the other C answer.
Number of characters: 57
p(char*s){char*r=strdup(s);strrev(r);return strcmp(r,s);}
Confession: I'm being the bad guy by not freeing r here. My current attempt at being good:
p(char*s){char*r=strdup(s);s[0]=strcmp(strrev(r),s);free(r);return s[0];}
brings it to 73 characters; I'm thinking of any ways to do it shorter.
Haskell, 28 chars, needs Control.Arrow imported.
p=uncurry(==).(id&&&reverse)
F#, no LINQ and Reverse method. 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))
The same, but with Seq.iteri and ref variables instead of 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
Perl (21 characters):
sub{"@_"eq reverse@_}
Hey, the question didn't specify a named subroutine!
Haskell, 36 characters including its own reverse function. (Actually, if you use semicolons to make it a one-liner, and ignore the newline at the end, it'd be 35...)
r[]y=y
r(a:x)y=r x$a:y
p s=s==r s[]
As with other implementations, "p" is the palindrome predicate.
My attempt in C (70 chars):
P(char*s){char*e=s+strlen(s)-1;while(s<e&&*s==*e)s++,e--;return s>=e;}
[Edit] Now actually working
[Edit 2] Reduced from 74 to 70 by using default int return
In response to some of the comments: I'm not sure if that preprocessor abuse counts - you could just define the whole thing on the command line and make the function one character.
P(char*s){char*e=s;while(*++e);while(s<=--e&&*s++==*e);return s>e;}, but cannot call P() with empty string. And no need for <string.h> :) –
Demibastion JavaScript, 64 bytes.
function a(x){for(r='',i=x.length;i>0;i--)r+=x[i-1];return x==r}
Test case:
a('lolol'); // true
a('haha'); // false
Impossible! language, assuming that string is passed by using normal args:
;~=
3 chars
C# using a recursive lambda function and not using the Reverse function (115 chars):
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));};
F#: 29 chars
let p(s:string)=s=s.Reverse()
(assuming System.Linq is imported)
javascript recursive version (no reverse junk)
function p(s){l=s.length;return l<2||(s[0]==s[l-1]&&p(s.substr(1,l-2)))}
(72 chars)
or implement reverse inside:
p=function(s,y){return y?(s==p(s)):s[1]?(p(s.substr(1))+s[0]):s[0]}
p("hannah",1);
(67 chars)
or, using no built in functions at all...
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 chars)
shortest I could come up with: (iterative)
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 chars)
looking forward to seeing you do it better in javascript!
(preferably without using any built in functions, especially reverse)
(not really very impressed by the 'return s==s.reverse()' type answers)
58 characters in Python, without reversing the string:
r="y" for i in range(len(s)): if(s[i]!=s[-i-1]): r="n"
Maybe the for loop could be optimized? Python is new to me...
may was well give a c++ example which uses the standard library:
bool p(const std::string &s){std::string s2(s);std::reverse(s2);return s==s2;}
Thanks to Jon For pointing out that this could be shorter if we make some unnecessary copies. Totalling 67 chars.
bool p(std::string s){std::string x=s;std::reverse(x);return s==x;}
int p(std::string s){std::string t(s);std::reverse(t);return s==t;} (67), or int p(std::string s){return std::equal(s.begin(),s.end(),s.rbegin());} (70)? C++0x lets you reduce the former from std::string t to auto t, for a savings of seven characters. –
Rissole C, 68 characters, no libs:
p(char *s){char *e=s;while(*++e);for(;*s==*--e&&s++<e;);return s>e;}
Standard ML (34 characters and boring):
fun p s=s=implode(rev(explode(s)))
Java, without using reverse:
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;
JavaScript: 55 chars
p=function(x){return (x==x.split('').reverse().join())}
The above won't work because you need to call join with ""
JavaScript: 55 chars
function p(s){return s==s.split("").reverse().join("")}
C, no libraries, 70 characters:
p(char*a){char*b=a-1;while(*++b);while(a<b&&*a++==*--b);return!(a<b);}
As one of the comments on another C solution mentioned, prototypes are completely optional in C, int is assumed everywhere a type would go but isn't mentioned. Has nobody ever programmed in pre-ANSI C?
Edit: shorter and handles empty strings.
Definitely not the smallest, but I still wanted to add a entry:
sub p{return @_==reverse split//;}
My perl's rusty tho and this is untested.
Shell-script (sed + tac + tr):
test "`echo $1|sed -e 's/\(.\)/\1\n/g'|tac|tr -d '\n'`" == "$1"
Java:
boolean y(StringBuffer x){return x.equals(x.reverse());}
The above doesn't work, oops!
boolean y(StringBuffer x){return x.toString().equals(x.reverse().toString()); }
Ew.
CFScript, 39 characters:
function y(x){return(x is reverse(x));}
I was never very good at golf.
Josh's Java snippet above will return true every time.
© 2022 - 2024 — McMap. All rights reserved.