Palindrome Golf

Ответ 1

7 символов в J: Не уверен, что это лучший способ, я несколько новичок в J:)

p=:-:|.

объяснение: |. меняет вход. -: сравнивает. операнды неявны.

p 'radar'
1

p 'moose'
0

Ответ 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.

Ответ 3

К сожалению, я не могу попасть под тысячу слов...

(LabVIEW. Да, они позволят почти любой пост hobo здесь;)

Ответ 4

Haskell, 15:

p=ap(==)reverse

Более читаемая версия, 16:

p x=x==reverse x

Ответ 5

Еще одна версия python, которая короче (21 символ):

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

Ответ 6

Рискуя получить голоса, большинство из них просто называет команду реверсом какого-то типа, который скрывает всю реальную логику программирования.

Интересно, что самый короткий ручной способ сделать это на каждом из этих языков.

Ответ 7

С операторами С# и 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);
}

Ответ 8

Perl (27 символов):

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

Ruby (24 символа):

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

Ответ 9

73 чистые, читаемые, символы, написанные в java

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

мир:)

Ответ 10

Бесцельная версия Haskell (15 символов, хотя на самом деле не работает, если вы не включили Control.Arrow и Control.Monad и игнорируете ограничение мономорфизма):

p=ap(==)reverse

Ответ 11

(equal p (reverse p))

lisp. 18 символов.

ok, это особый случай. Это будет работать, если набрать непосредственно в интерпретаторе lisp и p уже определен.

в противном случае это было бы необходимо:

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

28 символов.

Ответ 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('')}

Ответ 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;}

Ответ 14

PHP:

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

или просто

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

Ответ 15

Не использует ли обратная функция в вашем языке тип обмана? Я имею в виду, глядя на решение Ruby как

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

вы можете легко переписать это как

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

и просто скажите, что вы сделали метод расширения в своем коде так, чтобы "r" назывался обратным. Я бы хотел, чтобы люди отправляли решения, не содержащие вызовов других функций. Конечно, должна быть разрешена функция длины строки.

Руби без обратного - 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

Ответ 16

F # (очень похоже на пример С#)

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

Ответ 17

Golfscript, 5 char

.-1%=

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

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

Ответ 18

С# Без обратной функции 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;} 

С# Без обратной функции 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

Ответ 19

Общая Lisp, короткая и читая версия (23 символа):

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

#L - это макрос читателя, реализованный SHARPL-READER в пакете итерации. Это в основном эквивалентно (lambda (! 1)...).

Общая 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)))))))

Опять же, он использует итерацию, которая в основном является более чистой версией встроенного средства LOOP, поэтому я склонен рассматривать его как находящийся на основном языке.

Ответ 20

Вдохновленный предыдущим сообщением, 69 символов

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

EDIT: Вниз один char:

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

Ответ 21

Не самый короткий и очень важный факт, но я не мог не дать ему попробовать в MATLAB:

[email protected](s)all(s==fliplr(s));

24 символа.

Ответ 22

18 символов perl regex

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

Ответ 23

52 символа на C, с оговоркой, что до половины строки будет перезаписано:

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);}

Ответ 24

Haskell, 28 символов, требуется Control.Arrow импортировано.

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

Ответ 25

Простая реализация на C с использованием стандартных библиотечных функций, вдохновленная strlen в другом ответе C.

Число символов: 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];}

- до 73 символов; Я думаю о любых способах сделать это короче.

Ответ 26

Без использования каких-либо функций библиотеки (потому что вы действительно должны добавить стоимость #include), здесь версия С++ в 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);}

Ответ 27

Groovy 17B:

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

Недостатком является то, что он не работает с строкой emptry.

С другой стороны, исключение для пустой строки является разумным, так как вы не можете сказать, что ничто не является палиндром или нет.

Ответ 28

Clojure с использованием 37 символов:

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

Ответ 29

24 символа на Perl.

sub p{$_[0][email protected]_}

Ответ 30

Моя попытка в C (70 символов):

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

[Edit] Теперь действительно работаем [Редактировать 2] Уменьшено с 74 до 70 с использованием возврата по умолчанию

В ответ на некоторые из комментариев: я не уверен, связано ли это злоупотребление препроцессором - вы можете просто определить все это в командной строке и сделать функцию одним символом.