Палиндром Гольф

Сценарий оболочки (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());}

Вышеупомянутое не работает, ой!

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

Ew.

Определенно не самое маленькое, но я все еще хотел добавить запись:

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

ржавый tho Моего perl и это не тестируются.

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;

Groovy 17B:

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

Оборотная сторона - то, что это не работает со строкой emptry.

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

Стандартный ML (34 символа и скучный):

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

C, никакие библиотеки, 70 символов:

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

Как один из комментариев к другому упомянутому решению C, прототипы являются абсолютно дополнительными в C, int принят везде, тип пошел бы, но не упоминается. Никто никогда не программировал в предварительном ANSI C?

Редактирование: короче и пустые строки дескрипторов.

JavaScript: 55 символов

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

Вышеупомянутое не будет работать, потому что необходимо звонить join с ""

JavaScript: 55 символов

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

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

C, 68 символов, нет освобождает:

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

Clojure с помощью 37 символов:

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

Отрывок Java Josh's выше возвратит true каждый раз.

CFScript, 39 символов:

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

я никогда не был очень хорош в гольфе.

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

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

С операторами C# и LINQ:

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

, Если Вы рассматриваете Реверс как обман, можно сделать всю вещь с сокращением:

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

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

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

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

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

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

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

:)

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

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

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

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

24 символа в Perl.

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

Бессмысленная версия Haskell (15 символов, хотя действительно не работает, если Вы не включаете Управление. Стрелка и Управление. Монада и игнорирует ограничение мономорфизма):

p=ap(==)reverse

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('')}

(equal p (reverse p))

шепелявость. 18 символов.

хорошо, это - особый случай. Это работало бы, если введено непосредственно в интерпретатор шепелявости, и p был уже определен.

иначе, это было бы необходимо:

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

28 символов.

Haskell, 15 символы:

p=ap(==)reverse

p x=x==reverse x

Другая версия Python, которая скорее короче (21 символ):

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

Простая реализация в 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 символам; я думаю о любых способах сделать это короче.

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

Язык Common LISP, версия закорачивать-и-обманывать (23 символа):

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

#L является символом макроса читателя, реализованным SHARPL-ЧИТАТЕЛЕМ в выполнить итерации пакете. Это в основном эквивалентно (лямбда (! 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)))))))

Снова, это использует, выполняют итерации, который является в основном более чистой версией встроенного средства ЦИКЛА, таким образом, я склонен рассматривать его как являющийся на базовом языке.

Разве использование не является обратной функцией в Вашем виде языка обмана немного? Я имею в виду, смотрение на решение 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

Вдохновленный предыдущим сообщением, 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;}