Помогите решить головоломку

спасибо

Дубово, надёжно и предельно понятно:

function IsItPalindrom(n: longint): boolean;
var
 i, l: integer;
 s, z: string;

begin
 str(n, s);
 z := s;
 l := length(s);
 for i :=1 to l do z[i] := s[l-i+1];
 IsItPalindrom := (z=s);
end;

def f(number): if str(number) == str(number)[::-1]: return True else: return False

Что ты творишь? Не мучай так питон

f = lambda x : str(number) == str(number)[::-1]

>f = lambda x : str(number) == str(number)[::-1]

Только там не number, а x, ибо ошибся с копипастой.

То-же самое, но быстрей.

function IsItPalindrom(n: longint): boolean;
var
 i, l: integer;
 s: string;
begin
 str(n, s);
 i := 1;
 l := length(s);
 while(i < (l div 2)) do
 begin
  if (s[i] = s[l-i+1]) then IsItPalindrom := true
                       else begin IsItPalindrom := false; exit; end; 
  inc(i);
 end;
end;

Но правильней будет так:
[code=pascal]
function IsItPalindrom(s: string): boolean;
var
i, l: integer;
begin
i := 1;
l := length(s);
while(i < (l div 2)) do
begin
if (s[i] = s[l-i+1]) then IsItPalindrom := true
else begin IsItPalindrom := false; exit; end;
inc(i);
end;
end;
[/code]

> Язабан

я за удаление всего треда вместе с автором

делфикорни)

Вот ещё одна версия для Schemer-ов

(define (palindrom? number)
  (define (iter head tail)
    (if (> tail head)
        false
        (let ((next-head (quotient head 10))
              (next-tail (+ (* 10 tail) (remainder head 10))))
          (if (or (= head tail) (= head next-tail))
              true
              (iter next-head next-tail)))))

  (iter number 0))

Спасибо за идею о том, что на каждой итерации tail <= head, но зачем ты по два раза проверяешь все не подходящие пары tail, head? Для того чтобы съэкономить одну иетрацию? Кроме того, на мой взгляд, лучше подходит название reverse-tail, а не tail.

Мда... поспешил. Не сообразил сразу, что у тебя проверяется на равенство head с next-tail. А это необходимо для чисел с нечетным количеством цифр.

Наверно так будет выглядеть проще и при этом сохранится tail call:

(define (iter head rev-tail)
  (and (>= head rev-tail)
       (let ((next-head (quotient head 10))
             (next-rev-tail (+ (* 10 rev-tail) (remainder head 10))))
         (or (= head rev-tail)
             (= head next-rev-tail)
             (iter next-head next-rev-tail)))))

Проще или нет - вопрос спорный (программа длиной-то в несколько строк), но принимается :)

Действительно, and и or формы особые, и в соответствие с правилами их вычисления, возможно сохранить хвостовую рекурсию.

Вот такой вариант эффективнее. Здесь лишняя проверка выполняется на только на последнем шаге.

[code=scheme] (define (palindrome? number base) (define (iter head tail prev-head) (cond ((= head tail) true) ((> tail head) (= tail prev-head)) (else (iter (quotient head base) (+ (* base tail) (remainder head base)) head))))

(iter number 0 0)) [/code]

При подходящей реализации, операции проверки (= head tail), (> tail head) могут реально требовать порядка O(1) времени, поскольку практически всегда head и tail отличаются в base раз и более (это значит, что старшие цифры мантиссы в их реализации различны). Только на последней итерации это может быть не так.

http://www.labirint.ru/books/1983/

Для начинающих — самое то.

> старшие цифры мантиссы

или порядок - ты хотел добавить наверное:) не позорь анонимусов:)