«Число Гизы», также в разговорной речи известное как номер Тимми, - это любое число, цифры которого представляют пирамиду ( A134810 ). Например, «12321» - это номер Гизы, потому что его можно визуализировать так:

  3  
 2 2
1   1

Тем не менее, что-то вроде «123321» не является числом Гизы, потому что есть две цифры в верхней части пирамиды

  33  
 2  2
1    1

Другими словами, число - это число Гизы, если выполнены все следующие условия:

• Он имеет нечетное количество цифр, а центральная цифра является самой большой

• Это палиндромное (то же самое читается вперед или назад), и

• Первая половина цифр строго увеличивается на одну. (Так как он должен быть палиндромным, это означает, что вторая половина цифр должна строго уменьшаться на единицу)

Вы должны написать полную программу или функцию, которая принимает положительное целое число в качестве входных данных, и определить, является ли это число Гизы или нет. Вы можете принять ввод как строку или как число. Если это число Гиза, выводить значение truthy . В противном случае ложное значение.

Всего существует 45 чисел Гизы, поэтому любой из этих входных данных должен привести к истинному значению:

1
2
3
4
5
6
7
8
9
121
232
343
454
565
676
787
898
12321
23432
34543
45654
56765
67876
78987
1234321
2345432
3456543
4567654
5678765
6789876
123454321
234565432
345676543
456787654
567898765
12345654321
23456765432
34567876543
45678987654
1234567654321
2345678765432
3456789876543
123456787654321
234567898765432
12345678987654321

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

Как обычно, это код-гольф , поэтому стандартные лазейки запрещены, и выигрывает самый короткий ответ в байтах!

Python 2, 48 47 46 байт

lambda s:s[~len(s)/2:]in'987654321'>s==s[::-1]

Проверьте это на Ideone .

Как это работает

В Python цепочечное сравнение возвращает True тогда и только тогда, когда все индивидуальные сравнения делают то же самое. В этом конкретном случае наша лямбда возвращает True тогда и только тогда, когда выполнены все следующие условия.

• s[~len(s)/2:]in'987654321'

  Для строки ев длины 2n + 1 , ~len(s)/2возвращает ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (п + 1) , так что s[~len(s)/2:]дает крайний правый п + 1 символов с .

  Аналогичным образом , для строки сек длины 2n , ~len(s)/2возвращает ~ (2n) / 2 = - (2n + 1) / 2 = - (п + 1) (целочисленное деление всегда округляет в сторону -∞ , так что s[~len(s)/2:]еще раз дает крайний правый N + 1 символов с

  Сравнение возвращает True тогда и только тогда, когда самые правые n + 1 символов образуют подстроку 987654321.

  Обратите внимание, что если они имеют и s имеет 2n символов, s не может быть палиндромом; п - ^й и (п + 1) ^й персонажи справа будет различен, а последний является п - ^й символом слева.

• '987654321'>s

  Это сравнивает строки лексикографически. Поскольку 9 - единственное число Гизы, которое начинается с 9 , все числа Гизы удовлетворяют этому сравнению.

  Обратите внимание, что сравнение этих строк не является частью нашей проблемы решения; >sпросто три символа короче and s.

• s==s[::-1]

  Возвращает True тогда и только тогда, когда s - палиндром.

Perl, 39 37 42 39 + 1 = 40 байт

Используя новый метод, мне удалось сократить огромное количество байтов. Беги с -nфлагом. Принимает ввод повторно во время выполнения, печатая 0 или 1 соответственно.

Мне пришлось добавить 5 байтов, потому что я понял, что без него код работал для таких входных данных, как 1234567900987654321, который не является числом Гизы. Так как числа Гизы никогда не содержат цифру 0 (и все ложные срабатывания по необходимости будут содержать цифру 0), эти 5 байтов учитывают это.

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/

Объяснение:

say!/0/*($_- s/..?/1/gr**2)=~/^(.)\1*$/  #$_ contains input by default.
   !/0/                                  #Ensure that the initial text doesn't contain the number 0
       *                                 #Since both halves of this line return either 0 or 1, multiplying them together only yields 1 if both are true (which we want).
             s/   / /gr                  #Perform a substitution regex on $_ (see below)
                                         #/g means keep replacing, /r means don't modify original string; return the result instead
               ..?                       #Replace 1 or 2 characters (2, if possible)...
                   1                     #...with the number 1
                       **2               #Square this number...
        ($_-              )              #...and subtract it from the input
                           =~            #Do a regex match on the result
                             /^      $/  #Make sure the regex matches the WHOLE string
                               (.)       #Match any character...
                                  \1*    #...followed by itself 0 or more times
say                                      #Finally, output the result of the whole line of code.

Цель регулярного выражения замещения состоит в том, чтобы создать строку из 1 с длиной, равной половине длины ввода, округленной в большую сторону. Таким образом, ввод 12321будет производить строку 111, которая затем возводится в квадрат (объяснение ниже). Входные данные четной длины будут создавать строки, которые слишком малы, чтобы обеспечить успешное окончательное регулярное выражение.

Причина, по которой этот код работает, заключается в следующем:

        1         =         1**2
       121        =        11**2
      12321       =       111**2
     1234321      =      1111**2
    123454321     =     11111**2
   12345654321    =    111111**2
  1234567654321   =   1111111**2
 123456787654321  =  11111111**2
12345678987654321 = 111111111**2

Мы ясно видим, что число единиц в RHS равно 1/2 больше, чем половина размера LHS. (Еще 1, если мы усекаем). Дополнительно:

567898765 - 123454321 = 444444444, то есть всего 4 повторения. Таким образом, когда мы вычитаем наш квадрат из нашего числа, если мы получаем повторную цифру, наше первоначальное число является числом Гизы.

Старый код и старый метод (58 + 1 = 59 байт)

Сохранено 1 байт благодаря @Dada

Запустить с -nфлагом, передать текст с помощьюecho

say$_==($;=join"",/(.)/..($==y///c/2+/(.)/)-1).$=.reverse$

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

Run as echo -n "123454321" | perl -M5.010 -n giza.pl Возвращает, 1если это число Гизы, иначе ноль.

Желе , 10 7 6 байт

9ẆŒBḌċ

Генерирует все 45 чисел Гизы, затем проверяет членство.

Попробуйте онлайн! или посмотрите сгенерированные числа .

Как это работает

9ẆŒBḌċ  Main link. Argument: n

9       Set the return value to 9.
 Ẇ      Windows; yield all "substrings" of [1, ..., 9].
  ŒB    Bounce; map each [a, ..., b] to [a, ..., b, ..., a].
    Ḍ   Undecimal; convert the digit arrays to integers.
     ċ  Count the number of occurrences of n.

JavaScript (ES6), 46 45 42 41 байт

f=([c,...s])=>s+s&&c-s.pop()|c-~-f(s)?0:c

Принимает входные данные в виде строки и возвращает однозначную строку для истинности, 0для ложного.

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

• Если строка длиной в один символ, ИЛИ
• первый символ совпадает с последним символом, и
• средняя часть также является числом Гизы, и
• второй символ здесь на один больше, чем первый.

Java 7, 128 119 105 байт

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

Нет больше строк! Итак, теперь я начинаю с генерации 111...числа такой же длины, что и input ( a), и на одну короче квадратной ( b). Затем вы можете вычесть b*bиз ввода и проверить делимость на a. cтолько там, чтобы проверить нечетное / четное, не обращайте внимания> _>

Whitespaced:

boolean t(long n){
    long a=1,b=1,c=0;
    for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)
        a=a*10+1;
    return(n-b*b)%a<1&c<1;
}

Старый метод, 119 байт

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

Просматривает массив, проверяя разницу в 1 (или -1, в зависимости от того, какая половина) между каждой цифрой. Затем просто проверяет, является ли длина нечетной.

Whitespaced:

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}

05AB1E , 9 8 байт

Истина 1 , ложь 0 .

9LŒ€ûJ¹å

Использует кодировку CP-1252 . Попробуйте онлайн!

Python 2, 77, 76, 64 , 63 байта

f=lambda s:2>len(s)or(s[0]==s[-1]==`int(s[1])-1`and f(s[1:-1]))

Простое рекурсивное решение. Проверяет, равны ли первая и последняя цифры друг другу, а вторая - минус один. Затем проверяет, является ли середина также числом Гизы. Возвращает истину, как только становится одной цифрой.

Один байт сохранен благодаря @Rod, тонна байтов сохранена благодаря DLosc и ETHProductions!

PowerShell v3 +, 147 108 67 байт

$args[0]-in(1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}}))

Радикально изменился подход. Генерирует все возможные числа Гизы, а затем проверяет, $args[0]является ли ввод -inэтой коллекцией. Ниже показано, как формируется коллекция чисел Гизы:

1..9+(1..8|%{$i=$_;++$_..9|%{-join($i..$_+--$_..$i)}})
      1..8|%{                                       }  # Loop from 1 up to 8
             $i=$_;                                    # Set $i to the current number
                   ++$_..9|%{                      }   # Loop from one higher up to 9
                                   $i..$_+--$_..$i     # Build two ranges and concatenate
                                                       # E.g., 2..5 + 4..2
                             -join(               )    # Join into a single string
1..9+(                                               ) # Array concatenate with 1 to 9

Пример работы:

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False

Python 3, 65 байт

lambda x:len(x)<18and x[:len(x)//2+1]in'0123456789'and x[::-1]==x

Я не совсем уверен, но я думаю, что это работает.

Python 2, 68 73 66 байт

lambda n:n==`int('1'+len(n)/2%9*'1')**2+int(len(n)*`int(n[0])-1`)`

злоупотребляя тот факт , что 11^2=121, 111^2=12321и так далее, я вычислить это и добавить 1111..достаточное количество раз , как смещение.
Примеры:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 байт

40 байтов кода + -pфлаги.

s/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/

Выходы 1, если вход представляет собой число Гизы, иначе ничего. Введите ввод без заключительного перевода строки для его запуска:

echo -n '123456787654321' | perl -pe 's/(.)(?=(.))/$1-$2/ge;$_=/^(-1(?1)1|).$/'

Пояснения : сначала s/(.)(?=(.))/$1-$2/geзамените каждую цифру $1(затем $2) на $1-$2. Если это число Гизы, то каждая цифра на одну единицу меньше следующей в начале и еще на одну в конце, тогда строка должна содержаться только -1в первой части и 1во второй (кроме последней, оставленной без изменений) , Это то, что /^(-1(?1)1|).$/проверяет вторая часть : ищет -1последующую рекурсию с последующим1 .

-1 байт благодаря Мартину Эндеру.

Моя предыдущая версия на 15 байт длиннее (совсем по-другому, поэтому я позволю это здесь):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'

> <> РЫБА 57 52 49 48 байт

i:1+?!vi00.;n1<
%?v0n;>~l:1-?!^2
{:<11 ^?:=@:$+=

Edit 1: = возвращает 0 или 1, если true, поэтому удалил проверку и использовал это значение для приращения, затем он проверяет равенство после в любом случае. (сохранено 6 байт, потеряно 1 для новой строки).

Редактировать 2: убраны 3 указателя направления и 11 помещены в зазор, чтобы сместить стопку до четной длины, чтобы форсировать ложь (сохранено 3 байта).,

Редактировать 3: Дублируйте длину стека для проверки MOD на 2 и len (1), это было сделано путем помещения длины в два раза раньше, но теперь это заняло пустое место в строке 2 (1 байт сохранен).

C #, 120 86 108 102 92 байта

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

Полная программа с некоторыми тестами:

class a
{
    static void Main()
    {
        Func<string, bool> x = null;

        x = I=>
        {
            var Z=I.Length;
            return Z==1?                           // length == 1?
                     1>0:                          // return true (middle of #)
                     I[0]==I[Z-1]&I[1]-0==I[0]+1?  // else start == end and the next number is 1 above the current?
                       x(I.Substring(1,Z-2)):      // recursive call on middle
                       0>1;                        // else false
        };

        Console.WriteLine("1 -> " + (x("1") == true));
        Console.WriteLine("9 -> " + (x("9") == true));
        Console.WriteLine("121 -> " + (x("121") == true));
        Console.WriteLine("12321 -> " + (x("12321") == true));
        Console.WriteLine("4567654 -> " + (x("4567654") == true));
        Console.WriteLine("12345678987654321 -> " + (x("12345678987654321") == true));
        Console.WriteLine("12 -> " + (x("12") == false));
        Console.WriteLine("1221 -> " + (x("1221") == false));
        Console.WriteLine("16436346 -> " + (x("16436346") == false));
        Console.WriteLine("123321 -> " + (x("123321") == false));
        Console.WriteLine("3454321 -> " + (x("3454321") == false));
        Console.WriteLine("13631 -> " + (x("13631") == false));
        Console.WriteLine("191 -> " + (x("13631") == false));
        Console.Read(); // For Visual Studio
    }
}

Ура для однострочных условных выражений, теперь победив Java-ответ :)! Также надо написать мои первые поясняющие комментарии, хотя, вероятно, это говорит само за себя. Спасибо @Dada за нахождение проблемы с моим алгоритмом (было верно для чисел, которые были отражены как 13631). Теперь подпункт 100, так как, очевидно, проверка длины% 2 является излишней.

Баш, 111 байт

ОБНОВИТЬ

Обратите внимание, что нормализацию входного номера, вероятно, можно полностью пропустить, если вы просто добавите первую цифру обратно к сгенерированному номеру GIZA , например:

01210 + 6 => 67876

а затем просто сравните его с входными данными напрямую.

Отказ от ответственности: этот не очень оптимизирован, так что это скорее доказательство концепции, чем реальный соперник

Golfed

G() { I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`;Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z`;cmp -s <(echo $I) <<<$Z${A:1}

Алгоритм

Любой номер GIZA можно нормализовать до его канонической формы, вычтя его первую цифру из остальных:

67876 - 6 => 01210
78987 - 7 => 01210

и существует только один канонический номер GIZA определенной длины.

Зная это, мы можем легко сгенерировать канонический номер GIZA на основе длины входного номера:

 Z=`seq 0 $((${#1}/2))`;A=`rev <<<$Z` => $Z${A:1}

затем нормализуйте введенный номер:

 I=`sed "s/./\0-${1::1}\n/g"<<<$1|bc`

и сравнить

 cmp -s <(echo $I) <<<$Z${A:1};

Тест

for i in `seq 0 1000`; do G $i && echo $i; done

0
1
2
3
4
5
6
7
8
9    
121
232
343
454
565
676
787
898

...

G 12345678987654321 && echo "OK" || echo FALSE     
OK

G 123456789987654321 && echo "OK" || echo FALSE
FALSE

На самом деле , 22 байта

9uR;∙`xR;RdX+εj`M;░#íu

Попробуйте онлайн!

Принимает ввод в виде строки в кавычках (например, "12321" ). Вывод является положительным целым числом для истины и 0ложь.

Объяснение:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership

Haskell, 62 байта

(`elem`[[j..pred i]++[i,pred i..j]|i<-['1'..'9'],j<-['1'..i]])

Ввод принимается как строка.

Создает список всех номеров Гизы и проверяет, есть ли номер в нем. Список создается с помощью цикла iчерез , '1'..'9'а затем jчерез '1'..iи создания элементов j .. i-1 , i , i-1 .. j.

> <> , 62 байта

i:0(   ?v
v!1&!~{!<:=$:@&-1=+2=*>l!-3!1(!:?
>l!;2!n=!0?!<-1=n;

Попробуйте онлайн!

Выходы 1 для номера Гизы; 0 иначе Работает, помещая входные данные в очередь (нормально, технически обратимый стек) и неоднократно проверяя оба конца на равенство, а также удостоверяясь, что они точно на один больше, чем предыдущее значение.

CJam , 20 19 байтов

l_$_W=),\ci>_W<W%+=

Тестирование.

объяснение

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

l       e# Read input.
_$      e# Get a sorted copy of the input.
_W=     e# Get its last character, i.e. the maximum digit M.
),      e# Get a string with all characters from the null byte up to M.
\c      e# Get the first character of the sorted string, i.e. the minimum
        e# character m.
i>      e# Convert to its character code and discard that many leading
        e# characters from the string we generated before. Now we've got
        e# a string with all digits from m to M, inclusive.
_W<W%+  e# Palindromise it, by appending a reversed copy without M.
=       e# Check that it's equal to the input.

Вместо минимального символа мы также можем использовать первый символ для того же количества байтов:

l_:e>),1$ci>_W<W%+=

Mathematica, 62 61 60 байт

^{Сохранено 2 байта благодаря @MartinEnder .}

MatchQ[{a:1...,b___}/;{b}==-{a}]@*Differences@*IntegerDigits

Композиция функций. Принимает число как ввод и возвращает Trueили Falseкак вывод.

Сетчатка, 55 54 36 байт

Число байтов предполагает кодировку ISO 8859-1.

.
$*1:
+`^(1+:)(1\1.*)\b\1$
$2
^1+:$

Попробуйте онлайн

Перевести все цифры в одинарные, разделенные двоеточиями. Цикл, удаляя соответствующие внешние цифры, если следующая цифра - еще одна. Совпадение с одной оставшейся цифрой.

PHP, 71 байт

for($t=$i=max(str_split($s=$argv[1]));$t!=$s&&--$i;)$t="$i$t$i";echo$i;

извлекает наибольшую цифру из ввода и ведет обратный отсчет, добавляя новую цифру в строку сравнения до тех пор, пока строка ввода и строка сравнения не станут равными или не $iстанет0 .

печатает самую младшую цифру для номера Тимми, 0иначе.

Напористый , 30 15 байт

Я проснулся этим утром и понял, что мог бы на половину длины моего ответа ...

s&K-kL2/OvhXwx#

_{(неконкурентоспособен как вызов языковых постдатов)}

Ввод задается в командной строке: $ pushy gizas.pshy 3456543. Выходы 1для правдивых и 0ложных. Вот разбивка:

s                  % Split the number into its individual digits
 &K-               % Subtract all digits by the last 
    kL2/  h        % Get the halved length of the stack (+1)
        Ov X       % In stack 2, generate range (0, halved length)
            w      % Mirror the range 
             x#    % Check stack equality and output

Алгоритм был основан на ответе bash: сначала нормализуйте число ( 45654 -> 01210), затем сгенерируйте нормализованное число Гизы той же длины (есть только один) и сравните.

Старое решение

s&K-Y?kL2%?L2/:.;&OvhXx#i;;;0#

Ракетка 292 байта

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

Ungolfed:

(define(f n)
  (let* ((s (number->string n))
         (sn string->number)
         (st string)
         (lr list-ref)
         (sl (string->list s))
         (g (λ (i) (- (sn(st(lr sl (add1 i))))
                      (sn(st(lr sl i)))))))
    (cond
      [(even? (string-length s))
       #f]
      [(not(equal? s (list->string (reverse sl))))
       #f]
      [else
       (andmap identity
               (for/list ((i (floor(/(length sl)2))))
                 (= 1 (g i))))]
      )))

Тестирование:

(f 12321) 
(f 123321)  ; only this should be false; 

(f 9)
(f 787)
(f 67876)
(f 4567654)
(f 123454321)
(f 12345654321)
(f 1234567654321)
(f 123456787654321)
(f 12345678987654321)

Выход:

#t
#f
#t
#t
#t
#t
#t
#t
#t
#t
#t

Java 8, 162 + 19 байт

19 для import java.util.*;

s->{List f=new ArrayList();for(int i=0;i<9;){String l=String.valueOf(++i);for(int j=i;j>0;){f.add(l);String k=String.valueOf(--j);l=k+l+k;}}return f.contains(s);}

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

Октава, 56 байт

@(n)nnz(n)<2||~(abs(diff(+n))-1)&&diff(+n(1:1+end/2))==1

Проверьте все контрольные примеры здесь .

Это было бы на два байта меньше в MATLAB, так как diff(n)работает для строк. В Октаве вам нужно diff(+n).

Объяснение:

@(n)                  % Anonymous function taking a string `n` as argument
    nnz(n)<2          % True if there is only one element in n
            ||        % Short circuit or operator. Expression will be true if this is true
~(abs(diff(+n))-1)    % Takes the absolute value of the difference between adjacent numbers
                      % which should always be 1. Subtracts 1, to get 0
                      % and negates it to get 1 (true)
diff(+n(1:1+end/2))==1   % Checks if the difference between the first half of the numbers
                         % is 1.
                      % If either the first, or both the second and third argument is true
                      % then the function will return 1, otherwise 0. 

Mathematica, 56 байт

Это немного короче:

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&

Java 7, 129 119 109 байт

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

Старый рекурсивный метод, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

-10 байтов благодаря Geobits. Мы в были связаны ...

Попробуйте онлайн!

Perl 6 , 43 34 байта

Спасибо Джо Кингу за -9 байт.

{!/0/==set comb $_- S:g/..?/1/²:}

Порт решения Perl Габриэля Бенами .

Попробуйте онлайн!

Cjam, 35 байт

Наверное, очень неоптимальный ... Я немного не на практике!

q__W%=\_,_2%@@2/)<2ew{:-}%e`,1=]:e&

Попробуйте онлайн!

Python 2, 50 82 81 80 байт

def f(a):b=len(a)/2+1;print(1,0)[a[:b-1]!=a[b:][::-1]or a[:b]not in'123456789']

Простой подход Просто разбивает строку пополам (пропуская средний символ или один после среднего символа, если он имеет четную длину), переворачивает вторую половину, затем сравнивает два и сравнивает первую половину со строкой от 1 до 9.

редактировать

Перемещено после конструктивной обратной связи с другими игроками в гольф и осознания и исправления моих ошибок.

-1 за потерю пространства

-1 за повторное чтение вопроса и понимание того, что нам не нужно принимать во внимание 0. Действительно должен прекратить играть в гольф после долгого рабочего дня.