Un "numero Giza", noto anche colloquialmente come Timmy Number, è qualsiasi numero in cui le cifre rappresentano una piramide ( A134810 ). Ad esempio, "12321" è un numero di giza perché può essere visualizzato in questo modo:

  3  
 2 2
1   1

Tuttavia, qualcosa come "123321" non è un numero di Giza perché ci sono due cifre nella parte superiore della piramide

  33  
 2  2
1    1

In altre parole, un numero è un numero Giza se sono soddisfatte tutte le seguenti condizioni:

• Ha un numero dispari di cifre e la cifra centrale è la più grande

• È palindromico (la stessa lettura in avanti o all'indietro) e

• La prima metà delle cifre aumenta rigorosamente di una. (Dato che deve essere palindromico, ciò significa che la seconda metà delle cifre deve essere rigorosamente decrescente di uno)

È necessario scrivere un programma completo o una funzione che accetta un numero intero positivo come input e determinare se si tratta di un numero Giza o meno. È possibile accettare l'input come stringa o come numero. Se è un numero Giza, genera un valore veritiero . Altrimenti, un valore falso.

Ci sono un totale di 45 numeri Giza, quindi ognuno di questi input dovrebbe dare un valore di verità:

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

Qualsiasi altro input dovrebbe dare un valore falso. Naturalmente, non è necessario gestire input non validi, come numeri non positivi, non interi o non numeri.

Come al solito, si tratta di code-golf , quindi vengono eliminate le scappatoie standard e vince la risposta più breve in byte!

Python 2, 48 47 46 byte

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

Provalo su Ideone .

Come funziona

In Python, un confronto concatenato restituisce True se e solo se tutti i singoli confronti fanno lo stesso. In questo caso specifico, il nostro lambda restituisce True se e solo se sono soddisfatte tutte le seguenti condizioni.

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

  Per una stringa s di lunghezza 2n + 1 , ~len(s)/2restituisce ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , quindi s[~len(s)/2:]restituisce n + 1 caratteri più a destra di s .

  Allo stesso modo, per una stringa s di lunghezza 2n , ~len(s)/2restituisce ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (la divisione intera è sempre arrotondata verso -∞ , quindi s[~len(s)/2:]una volta di più produce l'estrema destra n + 1 carattere di s

  Il confronto restituisce True se e solo se i caratteri n + 1 più a destra formano una sottostringa di 987654321.

  Nota che se hanno e s ha 2n caratteri, s non può essere un palindromo; il n ^esimo e (n + 1) ^th caratteri da destra sarà separato, e quest'ultimo è il n ^° carattere da sinistra.

• '987654321'>s

  Questo confronta le stringhe lessicograficamente. Poiché 9 è l'unico numero Giza che inizia con 9 , tutti i numeri Giza soddisfano questo confronto.

  Si noti che il confronto di queste stringhe non fa parte del nostro problema decisionale; >sè semplicemente tre caratteri più corto di and s.

• s==s[::-1]

  Questo restituisce True se e solo se s è un palindromo.

Perl, 39 37 42 39 + 1 = 40 byte

Usando un nuovo metodo, sono riuscito a ridurre un numero enorme di byte. Corri con il-n bandiera. Accetta input ripetutamente in fase di esecuzione, stampando di conseguenza 0 o 1.

Ho dovuto aggiungere 5 byte perché mi sono reso conto senza di esso, il codice ha funzionato per input come 1234567900987654321, che non è un numero Giza. Dato che i numeri di Giza non contengono mai la cifra 0 (e tutti i falsi positivi per necessità conterrebbero la cifra 0), questi 5 byte lo spiegano.

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

Spiegazione:

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.

Lo scopo del regex di sostituzione è di costruire una stringa di 1s la cui lunghezza è metà della lunghezza dell'input, arrotondata per eccesso. Pertanto, un input di12321 produrrà la stringa 111, che verrà quindi quadrata (spiegazione di seguito). Gli input di lunghezza pari produrranno stringhe troppo piccole per garantire il successo della regex finale.

Il motivo per cui funziona questo codice è il seguente:

        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

Possiamo chiaramente vedere che il numero di 1 in RHS è uguale a 1/2 in più della metà della dimensione di LHS. (1 altro se tronciamo). Inoltre:

567898765 - 123454321 = 444444444, che è solo 4 ripetizioni. Quindi quando sottraggiamo il nostro quadrato dal nostro numero, se otteniamo una modifica, il nostro numero originale è un numero Giza.

Vecchio codice e vecchio metodo (58 + 1 = 59 byte)

Salvato 1 byte grazie a @Dada

Esegui con la -nbandiera, pipe il testo in usandoecho

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

Calcola il numero univoco di giza determinato dalla lunghezza e dal numero intero iniziale e vede se corrisponde all'input.

Esegui come echo -n "123454321" | perl -M5.010 -n giza.pl restituisce 1se si tratta di un numero Giza, null altrimenti.

Gelatina , 10 7 6 byte

9ẆŒBḌċ

Genera tutti i 45 numeri numeri Giza, quindi verifica l'adesione.

Provalo online! o vedere i numeri generati .

Come funziona

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 byte

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

Prende l'input come stringa e restituisce una stringa di una cifra per verità, 0per falsità.

L'idea di base è di verificare alcune cose:

• Se la stringa è lunga un carattere, OR
• il primo carattere è uguale all'ultimo carattere e
• la sezione centrale è anche un numero di Giza e
• il secondo carattere è uno in più rispetto al primo carattere qui.

Java 7, 128 119 105 byte

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

Niente più stringhe! Quindi, ora inizio generando un 111...numero della stessa lunghezza di input ( a) e uno più corto di square ( b). Quindi è possibile sottrarre b*bdall'input e verificare la divisibilità per a. cè lì solo per controllare pari / dispari, non pensarci> _>

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

Metodo precedente, 119 byte

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

Cammina attraverso l'array, verificando la differenza di 1 (o -1, a seconda della metà) tra ciascuna cifra. Quindi controlla solo che la lunghezza sia dispari.

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 byte

La verità è 1 , la falsità è 0 .

9LŒ€ûJ¹å

Utilizza la codifica CP-1252 . Provalo online!

Python 2, 77, 76, 64 , 63 byte

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

Una semplice soluzione ricorsiva. Verifica se la prima e l'ultima cifra sono uguali tra loro e la seconda cifra meno una. Quindi controlla se il centro è anche un numero Giza. Restituisce vero una volta che scende a una singola cifra.

Un byte salvato grazie a @Rod, un sacco di byte risparmiati grazie a DLosc ed ETHProductions!

PowerShell v3 +, 147 108 67 byte

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

Approccio radicalmente cambiato. Genera tutti i possibili numeri di Giza, quindi controlla se l'input $args[0]è -inquella raccolta. Di seguito è riportato come si forma la raccolta di numeri 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

Esempi di esecuzione:

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 byte

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

Non ne sono del tutto sicuro, ma penso che funzioni.

Python 2, 68 73 66 byte

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

abusando del fatto che 11^2=121, 111^2=12321e così via, lo calcolo e aggiungo 1111..abbastanza volte come offset.
Esempi:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 byte

40 byte di codice + -pflag.

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

Emette 1 se l'ingresso è un numero Giza, nient'altro. Fornire l'input senza newline finale per eseguirlo:

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

Spiegazioni : in primo luogo, s/(.)(?=(.))/$1-$2/gesostituire ogni cifra $1(seguita da $2) con $1-$2. Se è un numero Giza, quindi ogni cifra è una in meno di quella successiva all'inizio e una in più alla fine, quindi la stringa deve contenere solo -1nella prima parte e 1nella seconda (tranne l'ultima rimasta invariata) . Ecco cosa /^(-1(?1)1|).$/controlla la seconda parte : cerca un -1seguito da una ricorsione seguita da un 1.

-1 byte grazie a Martin Ender.

La mia versione precedente di 15 byte in più (abbastanza diversa, quindi la lascio qui):

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

> <> FISH 57 52 49 48 byte

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

Modifica 1: = restituisce 0 o 1 se true, quindi ha rimosso un segno di spunta e utilizzato questo valore per incrementare, quindi controlla l'uguaglianza dopo comunque. (salvato 6 byte, perso 1 per la nuova riga).

Modifica 2: 3 marcatori direzionali rimossi e 11 posizionati nello spazio per compensare lo stack su una lunghezza uniforme per forzare falso (3 byte salvati).,

Modifica 3: duplica la lunghezza dello stack per il controllo di MOD di 2 e len (1), questo è stato fatto inserendo la lunghezza due volte prima, ma questo ora riempiva uno spazio vuoto sulla linea 2 (1 byte salvato).

C #, 120 86 108 102 92 byte

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

Programma completo con alcuni casi di test:

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

Evviva i condizionali a linea singola, ora battendo la risposta Java :)! Devo anche scrivere i miei primi commenti esplicativi, anche se probabilmente è autoesplicativo. Grazie a @Dada per aver trovato un problema con il mio algoritmo (era vero per i numeri che si rispecchiavano come 13631). Ora sub 100 poiché apparentemente verifica la lunghezza% 2 è ridondante.

Bash, 111 byte

AGGIORNARE

Nota che probabilmente la normalizzazione dei numeri di input può essere completamente ignorata, se aggiungi semplicemente la prima cifra al tuo numero GIZA generato , in questo modo:

01210 + 6 => 67876

e poi confrontalo direttamente con l'input.

Disclaimer: questo non è davvero ottimizzato, quindi è più una prova di concetto che un vero contendente

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

Qualsiasi numero GIZA può essere normalizzato nella sua forma canonica, sottraendo la prima cifra dal resto:

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

e c'è un solo numero GIZA canonico di una lunghezza particolare.

Sapendo questo, possiamo facilmente generare un canonico numero GIZA basato sulla lunghezza del numero di input:

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

quindi normalizzare il numero di input:

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

e confronta

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

Test

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

In realtà , 22 byte

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

Provalo online!

Accetta l'input come stringa tra virgolette (ad es "12321".). L'output è un numero intero positivo per true e 0false.

Spiegazione:

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 byte

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

L'input è preso come una stringa.

Crea un elenco di tutti i numeri di Giza e verifica se il numero è presente. L'elenco è stato creato da loop iattraverso '1'..'9'e poi jattraverso '1'..ie la creazione di elementi j .. i-1 , i , i-1 .. j.

> <> , 62 byte

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

Provalo online!

Uscite 1 per un numero Giza; 0 altrimenti. Funziona spingendo l'input in un dequeue (ok, tecnicamente uno stack reversibile) e testando ripetutamente entrambe le estremità per l'uguaglianza, oltre a assicurarsi che siano esattamente uno più grande del valore precedente.

CJam , 20 19 byte

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

Suite di test.

Spiegazione

L'idea di base è quella di trovare la cifra minima e massima, quindi creare un numero Giza da quelli e quindi verificare che sia equivalente all'input.

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.

Invece del carattere minimo, possiamo anche usare il primo carattere, per lo stesso numero di byte:

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

Mathematica, 62 61 60 byte

^{Salvato 2 byte grazie a @MartinEnder .}

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

Composizione delle funzioni Prende un numero come input e restituisce Trueo Falsecome output.

Retina, 55 54 36 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online

Converti ogni cifra in unaria, separata da due punti. Ripeti, rimuovendo le cifre esterne corrispondenti se la cifra successiva è un'altra. Abbina una singola cifra rimanente.

PHP, 71 byte

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

recupera la cifra più grande dall'input e conta alla rovescia, aggiungendo la nuova cifra a una stringa di confronto fino a quando l'input e la stringa di confronto sono uguali - oppure $i è 0.

stampa la cifra più bassa per un numero Timmy, 0altrimenti.

Pushy , 30 15 byte

Mi sono svegliato questa mattina e mi sono reso conto che avrei potuto metà della lunghezza della mia risposta ...

s&K-kL2/OvhXwx#

_{(non in competizione con la sfida dei postdatati in lingua)}

Input è dato sulla riga di comando: $ pushy gizas.pshy 3456543. Output 1per verità e 0falsità. Ecco la ripartizione:

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

L'algoritmo è stato ispirato dalla risposta bash: in primo luogo, normalizzare il numero, ( 45654 -> 01210), quindi generare il numero di giza normalizzato della stessa lunghezza (ce n'è solo uno) e confrontare.

Vecchia soluzione

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

Racchetta 292 byte

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

test:

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

Produzione:

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

Java 8, 162 + 19 byte

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

Approccio diverso all'altra risposta Java, volevo provare ad usare il metodo per creare tutti i possibili numeri di Timmy e controllare se la nostra stringa fosse contenuta in essi.

Ottava, 56 byte

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

Dai un'occhiata a tutti i casi di test qui .

In MATLAB sarebbero due byte in meno, poiché diff(n)funziona per le stringhe. In Octave, hai bisogno diff(+n).

Spiegazione:

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

Questo è un po 'più breve:

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

Java 7, 129 119 109 byte

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

Vecchio metodo ricorsivo, 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 byte grazie a Geobits. Lo siamo stati legati ...

Provalo online!

Perl 6 , 43 34 byte

Grazie a Jo King per -9 byte.

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

La soluzione Perl del porto di Gabriel Benamy .

Provalo online!

Cjam, 35 byte

Probably very suboptimal... I'm a little out of practice!

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

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

Simple approach. Just splits the string in half (missing out the middle character or one after the middle character if it is of even length), reverses the second half then compares the two and compares the first half with a string of 1 to 9.

Edit

Reposted after constructive feedback from fellow golfers and realising and correcting my mistakes.

-1 for losing a (waste of) space

-1 for reading the question again and realising that we don't need to take 0 into account. Really must stop golfing after a long day at work.