Цель: любой язык. Самая маленькая функция, которая вернет, является ли строка палиндром. Вот мой in Python:
R=lambda s:all(a==b for a,b in zip(s,reversed(s)))
50 символов.
Принятый ответ будет самым маленьким - это изменится по мере того, как будут найдены более мелкие. Укажите язык, в котором находится ваш код.
7 символов в J: Не уверен, что это лучший способ, я несколько новичок в J:)
p=:-:|.
объяснение: |. меняет вход. -: сравнивает. операнды неявны.
p 'radar'
1
p 'moose'
0
Здесь моя; он написан на языке, специфичном для домена, который я изобрел, называемом "палиндром".
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.
К сожалению, я не могу попасть под тысячу слов...
(LabVIEW. Да, они позволят почти любой пост hobo здесь;)
Haskell, 15:
p=ap(==)reverse
Более читаемая версия, 16:
p x=x==reverse x
Еще одна версия python, которая короче (21 символ):
R=lambda s:s==s[::-1]
Рискуя получить голоса, большинство из них просто называет команду реверсом какого-то типа, который скрывает всю реальную логику программирования.
Интересно, что самый короткий ручной способ сделать это на каждом из этих языков.
С операторами С# и 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);
}
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());}
мир:)
Бесцельная версия Haskell (15 символов, хотя на самом деле не работает, если вы не включили Control.Arrow и Control.Monad и игнорируете ограничение мономорфизма):
p=ap(==)reverse
(equal p (reverse p))
lisp. 18 символов.
ok, это особый случай. Это будет работать, если набрать непосредственно в интерпретаторе lisp и p уже определен.
в противном случае это было бы необходимо:
(defun g () (equal p (reverse p)))
28 символов.
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('')}
Я возьму его немного дальше: полный код 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;}
PHP:
function p($s){return $s==strrev($s);} // 38 chars
или просто
$s==strrev($s); // 15 chars
Не использует ли обратная функция в вашем языке тип обмана? Я имею в виду, глядя на решение 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
F # (очень похоже на пример С#)
let p s=let i=0;let l=s.Length;while(++i<l)if(s[i]!=[l-i-1]) 0; 1;;
Golfscript, 5 char
.-1%=
$ echo -n abacaba | ruby golfscript.rb palindrome.gs
1
$ echo -n deadbeef | ruby golfscript.rb palindrome.gs
0
С# Без обратной функции 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
Общая 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, поэтому я склонен рассматривать его как находящийся на основном языке.
Вдохновленный предыдущим сообщением, 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;}
Не самый короткий и очень важный факт, но я не мог не дать ему попробовать в MATLAB:
[email protected](s)all(s==fliplr(s));
24 символа.
18 символов perl regex
/^(.?|(.)(?1)\2)$/
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);}
Haskell, 28 символов, требуется Control.Arrow импортировано.
p=uncurry(==).(id&&&reverse)
Простая реализация на 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 символов; Я думаю о любых способах сделать это короче.
Без использования каких-либо функций библиотеки (потому что вы действительно должны добавить стоимость #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);}
Groovy 17B:
p={it==it[-1..0]}
Недостатком является то, что он не работает с строкой emptry.
С другой стороны, исключение для пустой строки является разумным, так как вы не можете сказать, что ничто не является палиндром или нет.
Clojure с использованием 37 символов:
user=> (defn p[s](=(seq s)(reverse(seq s))))
#'user/p
user=> (p "radar")
true
user=> (p "moose")
false
24 символа на Perl.
sub p{$_[0][email protected]_}
Моя попытка в 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 с использованием возврата по умолчанию
В ответ на некоторые из комментариев: я не уверен, связано ли это злоупотребление препроцессором - вы можете просто определить все это в командной строке и сделать функцию одним символом.