Un "número de Giza", también conocido coloquialmente como un número de Timmy, es cualquier número donde los dígitos representan una pirámide ( A134810 ). Por ejemplo, "12321" es un número de giza porque se puede visualizar así:

  3  
 2 2
1   1

Sin embargo, algo como "123321" no es un número de Giza porque hay dos dígitos en la parte superior de la pirámide

  33  
 2  2
1    1

En otras palabras, un número es un número de Giza si se cumplen todas las siguientes condiciones:

• Tiene un número impar de dígitos, y el dígito central es el más grande.

• Es palindrómico (la misma lectura hacia adelante o hacia atrás), y

• La primera mitad de los dígitos aumenta estrictamente en uno. (Dado que debe ser palindrómico, esto significa que la segunda mitad de los dígitos debe estar disminuyendo estrictamente en uno)

Debe escribir un programa completo o una función que tome un entero positivo como entrada, y determinar si es un número de Giza o no. Puede tomar la entrada como una cadena o como un número. Si es un número de Giza, genera un valor verdadero . De lo contrario, un valor falso.

Hay un total de 45 números de Giza, por lo que cualquiera de estas entradas debería dar como resultado un valor verdadero:

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

Cualquier otra entrada debe dar un valor falso. Por supuesto, no tiene que manejar entradas no válidas, como números no positivos, no enteros o no números.

Como de costumbre, este es el código de golf , por lo que las lagunas estándar están prohibidas y la respuesta más corta en bytes gana.

Python 2, 48 47 46 bytes

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

Pruébalo en Ideone .

Cómo funciona

En Python, una comparación encadenada devuelve True si y solo si todas las comparaciones individuales hacen lo mismo. En este caso específico, nuestra lambda devuelve True si y solo si se cumplen todas las siguientes condiciones.

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

  Para una cadena s de longitud 2n + 1 , ~len(s)/2devuelve ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , por lo que s[~len(s)/2:]produce los n + 1 caracteres más a la derecha de s .

  Del mismo modo, para una cadena s de longitud 2n , ~len(s)/2devuelve ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (la división entera siempre se redondea hacia -∞ , por lo que s[~len(s)/2:]una vez más se obtiene el n + más a la derecha 1 caracteres de s

  La comparación devuelve True si y solo si los n + 1 más a la derecha forman una subcadena de 987654321.

  Tenga en cuenta que si lo hacen y s tiene 2n caracteres, s no puede ser un palíndromo; el n ^º y (n + 1) ^th personajes de la derecha será distinto, y el segundo es el n ^º personaje de la izquierda.

• '987654321'>s

  Esto compara las cadenas lexicográficamente. Como 9 es el único número de Giza que comienza con 9 , todos los números de Giza satisfacen esta comparación.

  Tenga en cuenta que comparar estas cadenas no forma parte de nuestro problema de decisión; >ses simplemente tres caracteres más cortos que and s.

• s==s[::-1]

  Esto devuelve True si y solo si s es un palíndromo.

Perl, 39 37 42 39 + 1 = 40 bytes

Usando un nuevo método, logré reducir una gran cantidad de bytes. Corre con la -nbandera. Acepta la entrada repetidamente en tiempo de ejecución, imprimiendo 0 o 1 en consecuencia.

Tuve que agregar 5 bytes porque me di cuenta de que sin él, el código funcionaba para entradas como 1234567900987654321, que no es un número de Giza. Como los números de Giza nunca contienen el dígito 0 (y todos los falsos positivos necesariamente contendrían el dígito 0), estos 5 bytes explican eso.

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

Explicación:

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.

El propósito de la expresión regular de sustitución es construir una cadena de 1s cuya longitud es la mitad de la longitud de la entrada, redondeada hacia arriba. Por lo tanto, una entrada de 12321producirá la cadena 111, que luego se eleva al cuadrado (explicación a continuación). Las entradas de longitud uniforme producirán cadenas que son demasiado pequeñas para garantizar que la expresión regular final sea exitosa.

La razón por la que funciona este código se debe a lo siguiente:

        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 el número de 1 en RHS es igual a 1/2 más de la mitad del tamaño de LHS. (1 más si truncamos). Adicionalmente:

567898765 - 123454321 = 444444444, que es solo 4 repeticiones. Entonces, cuando restamos nuestro cuadrado de nuestro número, si obtenemos un repdigit, nuestro número original es un número de Giza.

Código antiguo y método antiguo (58 + 1 = 59 bytes)

Guardado 1 byte gracias a @Dada

Ejecutar con la -nbandera, el texto de la tubería al usarecho

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

Calcula el número único de giza determinado por la longitud y el entero principal, y ve si coincide con la entrada.

Ejecutar como echo -n "123454321" | perl -M5.010 -n giza.pl devoluciones 1si es un número de Giza, de lo contrario es nulo.

Gelatina , 10 7 6 bytes

9ẆŒBḌċ

Genera los 45 números de números de Giza, luego prueba la membresía.

Pruébalo en línea! o ver los números generados .

Cómo 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

Toma la entrada como una cadena y devuelve una cadena de un solo dígito para verdadero, 0para falso.

La idea básica es verificar algunas cosas:

• Si la cadena tiene una longitud de caracteres, O
• el primer carácter es igual al último carácter y
• la sección central también es un número de Giza, y
• el segundo personaje es uno más que el primer personaje aquí.

Java 7, 128119105 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;}

¡No más cuerdas! Entonces, ahora empiezo generando un 111...número de la misma longitud que input ( a), y uno más corto a square ( b). Luego puede restar b*bde la entrada y verificar la divisibilidad por a. csolo está ahí para verificar impar / par, no le prestes atención

Espacio en blanco:

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

Recorre la matriz y comprueba una diferencia de 1 (o -1, según la mitad) entre cada dígito. Luego solo verifica que la longitud sea extraña.

Espacio en blanco:

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

La verdad es 1 , la falsedad es 0 .

9LŒ€ûJ¹å

Utiliza la codificación CP-1252 . Pruébalo en línea!

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

Una solución recursiva simple. Comprueba si el primer y el último dígito son iguales y el segundo dígito menos uno. Luego comprueba si el centro también es un número de Giza. Devuelve verdadero una vez que se reduce a un solo dígito.

¡Un byte guardado gracias a @Rod, una tonelada de bytes guardados gracias a DLosc y ETHProductions!

PowerShell v3 +, 147 108 67 bytes

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

Enfoque radicalmente cambiado. Genera todos los números posibles de Giza y luego verifica si la entrada $args[0]es -inesa colección. A continuación se muestra cómo se forma la colección de números de Giza:

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

Ejecuciones de ejemplo:

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

No estoy completamente seguro, pero creo que esto 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 del hecho de que 11^2=121, 111^2=12321y así sucesivamente, calculo esto y agrego 1111..suficientes veces como compensación.
Ejemplos:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 bytes

40 bytes de código + -pbanderas.

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

Salidas 1 si la entrada es un número de Giza, nada de lo contrario. Proporcione la entrada sin nueva línea final para ejecutarla:

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

Explicaciones : primero, s/(.)(?=(.))/$1-$2/gereemplace cada dígito $1(seguido de $2) por $1-$2. Si es un número de Giza, entonces cada dígito es uno menos que el siguiente al principio y uno más al final, entonces la cadena debe contener solo -1en la primera parte y 1en la segunda (excepto la última que no se modifica) . Eso es lo que /^(-1(?1)1|).$/verifica la segunda parte : busca un -1seguido de recursión seguido de a 1.

-1 byte gracias a Martin Ender.

Mi versión anterior 15 bytes más (bastante diferente, así que lo dejaré aquí):

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

> <> PESCADO 57 52 49 48 bytes

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

Editar 1: = devuelve 0 o 1 si es verdadero, por lo que eliminó una verificación y usó este valor para incrementar, luego verifica la igualdad después de todos modos. (guardado 6 bytes, perdido 1 para la nueva línea).

Editar 2: 3 marcadores direccionales eliminados y 11 colocados en el espacio para compensar la pila a una longitud uniforme para forzar falso (3 bytes guardados).

Edición 3: Duplique la longitud de la pila para verificar MOD por 2 y len (1), esto se hizo poniendo la longitud dos veces antes, pero ahora llena un espacio vacío en la línea 2 (1 byte guardado).

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 con algunos casos de prueba:

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

¡Hurra por los condicionales de una sola línea, ahora superando la respuesta de Java :)! También pude escribir mis primeros comentarios explicativos, aunque probablemente se explica por sí mismo. Gracias a @Dada por encontrar un problema con mi algoritmo (fue cierto para los números que se reflejaron como 13631). Ahora sub 100 ya que aparentemente la comprobación de la longitud% 2 es redundante.

Bash, 111 bytes

ACTUALIZAR

Tenga en cuenta que la normalización del número de entrada probablemente se puede omitir por completo, si solo agrega el primer dígito a su número GIZA generado , así:

01210 + 6 => 67876

y luego simplemente compárelo con la entrada directamente.

Descargo de responsabilidad: este no está realmente optimizado, por lo que es más una prueba de concepto que un verdadero contendiente

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}

Algoritmo

Cualquier número de GIZA se puede normalizar a su forma canónica, restando su primer dígito del resto:

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

y solo hay un número canónico GIZA de una longitud particular.

Sabiendo esto, podemos generar fácilmente un número canónico de GIZA basado en la longitud del número de entrada:

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

luego normalice el número de entrada:

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

y comparar

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

Prueba

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

En realidad , 22 bytes

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

Pruébalo en línea!

Toma la entrada como una cadena entre comillas (por ejemplo "12321"). La salida es un entero positivo para verdadero y 0para falso.

Explicación:

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

La entrada se toma como una cadena.

Crea una lista de todos los números de Giza y comprueba si el número está en él. La lista se crea un bucle ia través '1'..'9'y luego ja través '1'..iy la creación de los 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;

Pruébalo en línea!

Salidas 1 para un número de Giza; 0 de lo contrario. Funciona empujando la entrada a una cola (ok, técnicamente una pila reversible) y probando repetidamente ambos extremos para la igualdad, así como asegurándose de que sean exactamente uno más grande que el valor anterior.

CJam , 20 19 bytes

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

Banco de pruebas.

Explicación

La idea básica es encontrar el dígito mínimo y máximo, luego crear un número de Giza a partir de ellos y luego verificar que sea equivalente a la 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.

En lugar del carácter mínimo, también podemos usar el primer carácter, para el mismo número de bytes:

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

Mathematica, 62 61 60 bytes

^{Se guardaron 2 bytes debido a @MartinEnder .}

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

Composición de funciones. Toma un número como entrada y devuelve Trueo Falsecomo salida.

Retina, 55 54 36 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea

Convierta cada dígito a unario, separado por dos puntos. Bucle, eliminando los dígitos externos coincidentes si el siguiente dígito es uno más. Une un solo dígito restante.

PHP, 71 bytes

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

recupera el dígito más grande de la entrada y cuenta hacia atrás, agregando el nuevo dígito a una cadena de comparación hasta que la entrada y la cadena de comparación sean iguales, o lo $isean 0.

imprime el dígito más bajo para un número de Timmy, de lo 0contrario.

Pushy , 30 15 bytes

Me desperté esta mañana y me di cuenta de que podía responder la mitad de mi respuesta ...

s&K-kL2/OvhXwx#

_{(no compite como el desafío de las fechas posteriores al idioma)}

De entrada se da en la línea de comandos: $ pushy gizas.pshy 3456543. Salidas 1para la verdad y 0para la falsedad. Aquí está el desglose:

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

El algoritmo se inspiró en la respuesta bash: primero, normalice el número, ( 45654 -> 01210), luego genere el número de giza normalizado de la misma longitud (solo hay uno) y compare.

Antigua solución

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

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

Sin golf:

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

Pruebas:

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

Salida:

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

Enfoque diferente a la otra respuesta de Java, quería probar y usar el método de crear todos los números de Timmy posibles y verificar si nuestra cadena estaba contenida en ellos.

Octava, 56 bytes

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

Echa un vistazo a todos los casos de prueba aquí .

Esto sería dos bytes menos en MATLAB, ya que diff(n)funciona para cadenas. En Octave, lo necesitas diff(+n).

Explicació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 bytes

Esto es un poco más corto:

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

Java 7, 129119109 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;}

Viejo 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 gracias a Geobits. Nos estamos ataron ...

Pruébalo en línea!

Perl 6 , 43 34 bytes

Gracias a Jo King por -9 bytes.

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

Puerto de la solución Perl de Gabriel Benamy .

Pruébalo en línea!

Cjam, 35 bytes

Probablemente muy subóptima ... ¡Estoy un poco fuera de práctica!

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

Pruébalo en línea!

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']

Enfoque simple Simplemente divide la cadena por la mitad (omitiendo el carácter del medio o uno después del carácter del medio si es de longitud uniforme), invierte la segunda mitad y luego compara los dos y compara la primera mitad con una cadena del 1 al 9.

Editar

Publicado de nuevo después de comentarios constructivos de otros jugadores de golf y al darme cuenta y corregir mis errores.

-1 por perder un (desperdicio de) espacio

-1 para leer la pregunta nuevamente y darse cuenta de que no necesitamos tener 0 en cuenta. Realmente debe dejar de jugar al golf después de un largo día de trabajo.