Um "número de Gizé", também conhecido coloquialmente como um número Timmy, é qualquer número em que os dígitos representem uma pirâmide ( A134810 ). Por exemplo, "12321" é um número de gizé porque pode ser visualizado da seguinte maneira:

  3  
 2 2
1   1

No entanto, algo como "123321" não é um número de Gizé porque existem dois dígitos no topo da pirâmide

  33  
 2  2
1    1

Em outras palavras, um número é um número de Gizé se todas as seguintes condições forem atendidas:

• Tem um número ímpar de dígitos, e o dígito central é o maior

• É palíndrico (a mesma leitura para frente ou para trás) e

• A primeira metade dos dígitos está aumentando estritamente em um. (Como deve ser palíndrico, isso significa que a segunda metade dos dígitos deve diminuir estritamente em um)

Você deve escrever um programa completo ou uma função que use um número inteiro positivo como entrada e determinar se é um número de Gizé ou não. Você pode considerar a entrada como uma sequência ou como um número. Se for um número de Gizé, produza um valor de verdade . Caso contrário, um valor falso.

Há um total de 45 números de Gizé, portanto, qualquer uma dessas entradas deve resultar em um valor verdadeiro:

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

Qualquer outra entrada deve fornecer um valor falso. Obviamente, você não precisa lidar com entradas inválidas, como números não positivos, números inteiros ou números não.

Como de costume, isso é código-golfe , então as brechas padrão são proibidas e a resposta mais curta em bytes vence!

Python 2, 48 47 46 bytes

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

Teste em Ideone .

Como funciona

No Python, uma comparação encadeada retorna True se e somente se todas as comparações individuais fizerem o mesmo. Nesse caso específico, nosso lambda retorna True se e somente se todas as seguintes condições forem atendidas.

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

  Para uma sequência s de comprimento 2n + 1 , ~len(s)/2retorna ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , portanto, s[~len(s)/2:]gera os n + 1 caracteres mais à direita de s .

  Da mesma forma, para uma sequência s de comprimento 2n , ~len(s)/2retorna ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (a divisão inteira sempre é arredondada para -∞ , portanto s[~len(s)/2:], mais uma vez, produz o n + mais à direita 1 caracteres de s

  A comparação retornará True se e somente se os caracteres n + 1 mais à direita formarem uma substring de 987654321.

  Note-se que se o fizerem e s tem 2n personagens, s não pode ser um palíndromo; o n ^th e (n + 1) ^th caracteres a partir da direita vai ser diferente, e o último é o n ^° de caracteres a partir da esquerda.

• '987654321'>s

  Isso compara as strings lexicograficamente. Como 9 é o único número de Gizé que começa com 9 , todos os números de Gizé satisfazem essa comparação.

  Observe que comparar essas cadeias não faz parte do nosso problema de decisão; >sé simplesmente três caracteres menor que and s.

• s==s[::-1]

  Isso retorna True se e somente se s for um palíndromo.

Perl, 39 37 42 39 + 1 = 40 bytes

Usando um novo método, consegui reduzir um grande número de bytes. Corra com a -nbandeira. Aceita entrada repetidamente em tempo de execução, imprimindo 0 ou 1 de acordo.

Eu tive que adicionar 5 bytes porque percebi que sem ele, o código funcionava para entradas como 1234567900987654321, que não é um número de Gizé. Como os números de Gizé nunca contêm o dígito 0 (e todos os falsos positivos, por necessidade, conteriam o dígito 0), esses 5 bytes são responsáveis ​​por isso.

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

Explicação:

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.

O objetivo do regex de substituição é construir uma sequência de 1s cujo comprimento seja metade do comprimento da entrada, arredondada para cima. Assim, uma entrada de 12321produzirá a string 111, que será quadrada (explicação abaixo). Entradas uniformes produzirão seqüências de caracteres muito pequenas para garantir que o regex final seja bem-sucedido.

O motivo desse código funcionar é o seguinte:

        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

Podemos ver claramente que o número de 1s no RHS é igual a 1/2 mais da metade do tamanho do LHS. (Mais 1 se truncarmos). Além disso:

567898765 - 123454321 = 444444444, que tem apenas 4 repetições. Portanto, quando subtraímos nosso quadrado do nosso número, se obtivermos um re-dígito, nosso número original é um número de Gizé.

Código antigo e método antigo (58 + 1 = 59 bytes)

Guardado 1 byte graças a @Dada

Execute com a -nbandeira, canalize o texto usandoecho

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

Calcula o número único de gizé determinado pelo comprimento e pelo número inteiro inicial e verifica se ele corresponde à entrada.

Executar como echo -n "123454321" | perl -M5.010 -n giza.pl Retorna 1se for um número de Gizé, caso contrário, nulo.

Geléia , 10 7 6 bytes

9ẆŒBḌċ

Gera todos os 45 números de números de Gizé e depois testa a associação.

Experimente online! ou veja os números gerados .

Como funciona

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 bytes

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

Pega a entrada como uma sequência e retorna uma sequência de um dígito 0para verdade , para falsidade.

A idéia básica é verificar algumas coisas:

• Se a string tiver um caractere, OU
• o primeiro caractere é o mesmo que o último caractere e
• a seção do meio também é um número de Gizé e
• o segundo caractere é um a mais que o primeiro caractere aqui.

Java 7, 128 119 105 bytes

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

Sem mais cordas! Então, agora começo gerando um 111...número do mesmo comprimento que input ( a) e um menor para o quadrado ( b). Em seguida, você pode subtrair b*bda entrada e verificar a divisibilidade por a. cestá lá para checar ímpares / pares, não importa> _>

Espaços em branco:

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

Método antigo, 119 bytes

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

Percorre a matriz, verificando a diferença de 1 (ou -1, dependendo da metade) entre cada dígito. Em seguida, basta verificar se o comprimento é ímpar.

Espaços em branco:

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 bytes

Verdade é 1 , falso é 0 .

9LŒ€ûJ¹å

Usa a codificação CP-1252 . Experimente online!

Python 2, 77, 76, 64 , 63 bytes

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

Uma solução recursiva simples. Verifica se o primeiro e o último dígito são iguais e o segundo dígito menos um. Em seguida, verifica se o meio também é um número de Gizé. Retorna true quando se reduz a um único dígito.

Um byte economizado graças ao @Rod, uma tonelada de bytes salvos graças ao DLosc e ETHProductions!

PowerShell v3 +, 147 108 67 bytes

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

Abordagem radicalmente alterada. Gera todos os números possíveis de Gizé e depois verifica se a entrada $args[0]é -inessa coleção. Abaixo está como a coleção de números de Gizé é formada:

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

Exemplo é executado:

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 bytes

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

Não tenho muita certeza, mas acho que isso funciona.

Python 2, 68 73 66 bytes

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

abusando do fato de que 11^2=121, 111^2=12321e assim por diante, eu calculo isso e adiciono 1111..tempos suficientes como deslocamento.
Exemplos:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 bytes

40 bytes de código + -psinalizadores.

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

Saídas 1 se a entrada for um número de Gizé, nada caso contrário. Forneça a entrada sem nova linha final para executá-la:

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

Explicações : primeiro, s/(.)(?=(.))/$1-$2/gesubstitua cada dígito $1(seguido por $2) por $1-$2. Se for um número de Gizé, então cada dígito será um a menos do que o próximo no início e mais um no final, a sequência deverá conter apenas -1na primeira parte e 1na segunda (exceto a última que permanece inalterada) . É isso que a segunda parte /^(-1(?1)1|).$/verifica: procura por um -1seguido de recursão seguido por a 1.

-1 byte graças a Martin Ender.

Minha versão anterior 15 bytes mais longa (bem diferente, então deixarei aqui):

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

> <> PEIXES 57 52 49 48 bytes

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

Edit 1: = retorna 0 ou 1 se true, então removeu uma verificação e usou esse valor para incrementar; depois, verifica a igualdade depois de qualquer maneira. (salvou 6 bytes, perdeu 1 para a nova linha).

Edite os marcadores direcionais 2: 3 removidos e 11 colocados no espaço para deslocar a pilha até um comprimento uniforme para forçar falso (3 bytes salvos).,

Edit 3: Duplique o comprimento da pilha para verificar MOD por 2 e len (1), isso foi feito colocando o comprimento duas vezes antes, mas agora preenchia um espaço vazio na linha 2 (1 byte salvo).

C #, 120 86 108 102 92 bytes

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

Programa completo com alguns casos de teste:

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

Viva as condições condicionais de linha única, agora superando a resposta Java :)! Também escrevi meus primeiros comentários explicativos, embora provavelmente seja auto-explicativo. Agradeço a @Dada por encontrar um problema com meu algoritmo (era verdade para números espelhados como 13631). Agora, sub 100, pois aparentemente a verificação do comprimento% 2 é redundante.

Bash, 111 bytes

ATUALIZAR

Observe que a normalização do número de entrada provavelmente pode ser ignorada completamente, se você apenas adicionar o primeiro dígito de volta ao seu número GIZA gerado , assim:

01210 + 6 => 67876

e então basta compará-lo com a entrada diretamente.

Isenção de responsabilidade: este não é realmente otimizado, por isso é mais uma prova de conceito do que um candidato real

Golfe

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}

Algoritmo

Qualquer número GIZA pode ser normalizado para sua forma canônica, subtraindo o primeiro dígito do resto:

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

e existe apenas um número canônico da GIZA de um comprimento específico.

Sabendo disso, podemos gerar facilmente um número GIZA canônico com base no comprimento do número de entrada:

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

normalize o número de entrada:

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

e compare

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

Teste

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

Na verdade , 22 bytes

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

Experimente online!

Recebe a entrada como uma string entre aspas (por exemplo "12321"). A saída é um número inteiro positivo para verdadeiro e 0para falso.

Explicação:

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 bytes

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

A entrada é tomada como uma sequência.

Cria uma lista de todos os números de Gizé e verifica se o número está nele. A lista é criada por looping iatravés de '1'..'9'e, em seguida, jatravés de '1'..ie criando os elementos j .. i-1 , i , i-1 .. j.

> <> , 62 bytes

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

Experimente online!

Saídas 1 para um número de Gizé; 0 caso contrário. Funciona empurrando a entrada para uma desenfileiramento (ok, tecnicamente uma pilha reversível) e testando repetidamente as duas extremidades quanto à igualdade, além de garantir que elas sejam exatamente uma maior que o valor anterior.

CJam , 20 19 bytes

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

Suíte de teste.

Explicação

A idéia básica é encontrar o dígito mínimo e máximo, criar um número de Giza a partir deles e verificar se é equivalente à entrada.

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.

Em vez do caractere mínimo, também podemos usar o primeiro caractere, para a mesma contagem de bytes:

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

Mathematica, 62 61 60 bytes

^{2 bytes salvos devido a @MartinEnder .}

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

Composição de funções. Pega um número como entrada e retorna Trueou Falsecomo saída.

Retina, 55 54 36 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online

Converta cada dígito em unário, separado por dois pontos. Loop, removendo dígitos externos correspondentes se o próximo dígito for mais um. Corresponde a um único dígito restante.

PHP, 71 bytes

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

busca o maior dígito da entrada e faz a contagem regressiva, adicionando o novo dígito a uma sequência de comparação até que a sequência de entrada e comparação seja igual - ou $iseja 0.

imprime o dígito mais baixo para um número Timmy, caso 0contrário.

Pushy , 30 15 bytes

Acordei esta manhã e percebi que podia metade da duração da minha resposta ...

s&K-kL2/OvhXwx#

_{(não concorrente como o idioma pós-desafio)}

A entrada é dado na linha de comando: $ pushy gizas.pshy 3456543. Saídas 1para verdade e 0falsidade. Aqui está o detalhamento:

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

O algoritmo foi inspirado na resposta do bash: primeiro, normalize o número ( 45654 -> 01210), gere o número de giza normalizado do mesmo tamanho (existe apenas um) e compare.

Solução antiga

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

Raquete 292 bytes

(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))))]
      )))

Teste:

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

Saída:

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

Java 8, 162 + 19 bytes

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

Abordagem diferente da outra resposta Java, eu queria tentar usar o método de criar todos os números Timmy possíveis e verificar se nossa string estava contida neles.

Oitava, 56 bytes

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

Confira todos os casos de teste aqui .

Seriam dois bytes a menos no MATLAB, pois diff(n)funciona para strings. No Octave, você precisa diff(+n).

Explicação:

@(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 bytes

Isso é um pouco mais curto:

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

Java 7, 129 119 109 bytes

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

Antigo método recursivo, 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 bytes graças ao Geobits. Nós são foram amarrados ...

Experimente online!

Perl 6 , 43 34 bytes

Agradecimentos a Jo King por -9 bytes.

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

Solução Perl do porto de Gabriel Benamy .

Experimente online!

Cjam, 35 bytes

Provavelmente muito abaixo do ideal ... Estou um pouco sem prática!

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

Experimente online!

Python 2, 50 82 81 80 bytes

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

Abordagem simples. Apenas divide a cadeia ao meio (perdendo o caractere do meio ou um após o caractere do meio, se tiver comprimento uniforme), inverte a segunda metade e depois compara as duas e compara a primeira metade com uma sequência de 1 a 9.

Editar

Reeditado após feedback construtivo de outros jogadores e percebendo e corrigindo meus erros.

-1 por perder um (desperdício de) espaço

-1 por ler a pergunta novamente e perceber que não precisamos levar 0 em consideração. Realmente deve parar de jogar golfe depois de um longo dia de trabalho.