Palindrom Golf

Oto mój; jest napisany w języku specyficznym dla domeny, który wymyśliłem, zwanym "palindromem".

p

Edit: Less flippant version (i386 ASM, AT & T składnia)

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 bajtów, wskaźnik ciągów idzie w ESI, wynik jest w EAX.

Niestety, nie jestem w stanie uzyskać poniżej tysiąca słów...

(LabVIEW. Tak, pozwolą tu każdemu włóczędze pisać;)

Haskell, 15 znaki:

p=ap(==)reverse

Wersja bardziej czytelna, 16 znaki:

p x=x==reverse x

Kolejna wersja Pythona, która jest raczej krótsza (21 znaków):

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

Ryzykując obniżenie głosów, większość z nich po prostu wywołuje polecenie odwrotne jakiegoś rodzaju, które ukrywa całą prawdziwą logikę programowania.

Zastanawiam się, jaki jest najkrótszy ręczny sposób, aby to zrobić w każdym z tych języków.

Z operatorami C# i LINQ:

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

Jeśli uważasz rewers za oszustwo, możesz zrobić całą rzecz z redukcją:

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

Perl (27 znaków):

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

Ruby (24 znaki):

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

73 czyste, czytelne, znaki napisane w Javie

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

Peace:)

Bezsensowna Wersja Haskella (15 znaków, choć tak naprawdę nie działa, chyba że włączysz kontrolkę.Strzałka i sterowanie.Monad i ignorować ograniczenie monomorfizmu):

p=ap(==)reverse

Lua ma na celu bardziej czytelność niż zwięzłość, ale robi uczciwe 37 znaków:]}

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

Wariant, just for fun (ten sam rozmiar):

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

Wersja JavaScript jest bardziej wyrazista( 55 znaków), ponieważ nie ma funkcji odwrotnej ciągu znaków:

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

(equal p (reverse p))

Lisp. 18 znaków.

W przeciwnym razie byłoby to konieczne:

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

28 znaków.

Wezmę to trochę dalej: Pełny kod c, skompilować i iść.

90 znaków

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

F #(podobnie jak Przykład C#)

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

PHP:

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

Lub po prostu

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

Czy używanie funkcji odwrotnej w Twoim języku nie jest trochę oszustwem? Mam na myśli, patrząc na rozwiązanie Ruby dać jako

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

Możesz to łatwo przepisać jako

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

I po prostu powiedz, że zrobiłeś metodę rozszerzenia w swoim kodzie tak, że" r " nazywa się odwróconym. Chciałbym, aby ludzie publikowali rozwiązania, które nie zawierają wywołań do innych funkcji. Oczywiście, funkcja długości łańcucha powinna być dozwolona.

Ruby bez rewersu - 41 znaków

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

VB.Net - 173 znaki

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

Golfscript, 5 char

.-1%=

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

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

Common Lisp, wersja krótko-i-oszukująca (23 znaki):

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

#L jest makrem programu reader zaimplementowanym przez SHARPL-READER w pakiecie iterate. Jest w zasadzie odpowiednikiem (lambda (!1) ...).

Common Lisp, długa wersja używająca tylko primitives (137 włącznie z białymi spacjami, Kompresowalne do 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)))))))

Ponownie, używa iterate, który jest w zasadzie czystszą wersją wbudowanego obiektu loop, więc traktuję go jako język podstawowy.

Nie najkrótszy, i bardzo po fakcie, ale nie mogłem się powstrzymać przed wypróbowaniem go w Matlabie:

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

24 znaki.

C# bez funkcji odwrotnej 84 znaki

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# bez funkcji odwrotnej 86 znaków

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 znaków

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

18 znaków Perl regex

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

52 znaki w C, z zastrzeżeniem, że do połowy łańcucha zostanie nadpisany:

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

Bez wywołania biblioteki ma 64 znaki:

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

Zainspirowany poprzednim postem, 69 znaków

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 znaków:

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

Haskell, 28 znaków, potrzebuje kontroli./ Align = "left" /

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

Prosta implementacja w C przy użyciu standardowych funkcji bibliotecznych, zainspirowana strlenem w innym C odpowiedzi.

Liczba znaków: 57

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

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

Sprowadza się do 73 znaków; myślę o wszelkich sposobach, aby zrobić to krócej.

Clojure używając 37 znaków:

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

24 znaki w Perlu.

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

Groovy 17b:

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

minusem jest to, że nie działa z emptry string.

Po namyśle, rzucanie wyjątku dla pustego ciągu jest rozsądne, ponieważ nie można stwierdzić, czy nic nie jest palindromem, czy nie.

Bez korzystania z żadnych funkcji bibliotecznych (bo naprawdę powinieneś dodać do kosztów #include), oto wersja C++ w 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);}

Moja próba w C (70 znaków):

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

[edytuj] aktualnie działa
[Edytuj 2] zmniejszono z 74 do 70 za pomocą domyślnego int return

W odpowiedzi na niektóre komentarze: nie jestem pewien, czy to nadużycie preprocesora się liczy - można by zdefiniować całość w wierszu poleceń i uczynić funkcję jednym znakiem.