Un "numéro de Giza", également appelé familièrement un numéro de Timmy, est un nombre quelconque où les chiffres représentent une pyramide ( A134810 ). Par exemple, "12321" est un nombre giza car il peut être visualisé comme ceci:

  3  
 2 2
1   1

Cependant, quelque chose comme "123321" n'est pas un nombre de Giza, car il y a deux chiffres en haut de la pyramide.

  33  
 2  2
1    1

En d'autres termes, un nombre est un nombre de Giza si toutes les conditions suivantes sont remplies:

• Il a un nombre impair de chiffres et le chiffre du centre est le plus grand

• C'est palindromique (la même lecture en avant ou en arrière), et

• La première moitié des chiffres augmente strictement de un. (Puisqu'il doit être palindrome, cela signifie que la deuxième moitié des chiffres doit être strictement décroissante d'un)

Vous devez écrire un programme complet ou une fonction prenant un entier positif en entrée et déterminer s'il s'agit d'un nombre de Giza ou non. Vous pouvez prendre l’entrée sous forme de chaîne ou de nombre. S'il s'agit d' un nombre de Gizeh, indiquez une valeur de vérité . Sinon, une valeur de fausseté.

Il y a un total de 45 nombres de Giza, donc l'une quelconque de ces entrées doit donner une valeur de vérité:

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

Toute autre entrée doit donner une valeur de fausseté. Bien entendu, vous n'avez pas à gérer des entrées non valides, telles que des nombres non positifs, des nombres entiers ou des nombres.

Comme d'habitude, c'est du code-golf , donc les échappatoires standard sont interdites, et la réponse la plus courte en octets est gagnante!

Python 2, 48 47 46 octets

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

Testez-le sur Ideone .

Comment ça marche

En Python, une comparaison chaînée renvoie True si et seulement si toutes les comparaisons individuelles font la même chose. Dans ce cas particulier, notre lambda renvoie True si et seulement si toutes les conditions suivantes sont remplies.

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

  Pour une chaîne s de longueur 2n + 1 , ~len(s)/2retourne ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , s[~len(s)/2:]donne donc les n + 1 caractères les plus à droite de s .

  De même, pour une chaîne s de longueur 2n , ~len(s)/2retourne ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (la division entière toujours arrondie vers -∞ , de sorte s[~len(s)/2:]qu'une fois de plus, on obtient le n + le plus à droite 1 caractères de s

  La comparaison renvoie True si et seulement si les n + 1 caractères les plus à droite forment une sous-chaîne de 987654321.

  Notez que s'ils le font et que s a 2n caractères, s ne peut pas être un palindrome; la n ^ième et (n + 1) ^ième caractère de droite soient distinctes, et celui - ci est le n ^ième caractère de gauche.

• '987654321'>s

  Ceci compare les chaînes lexicographiquement. Comme 9 est le seul numéro de Gizeh commençant par 9 , tous les nombres de Gizeh satisfont à cette comparaison.

  Notez que la comparaison de ces chaînes ne fait pas partie de notre problème de décision; >sest simplement trois caractères plus court que and s.

• s==s[::-1]

  Cela renvoie True si et seulement si s est un palindrome.

Perl, 39 37 42 39 + 1 = 40 octets

En utilisant une nouvelle méthode, j'ai réussi à réduire un très grand nombre d'octets. Courez avec le -ndrapeau. Accepte les entrées à plusieurs reprises au moment de l'exécution, en imprimant 0 ou 1 en conséquence.

J'ai dû ajouter 5 octets parce que je réalisais que sans cela, le code fonctionnait pour des entrées telles que 1234567900987654321, qui n'est pas un nombre de Giza. Puisque les nombres de Giza ne contiennent jamais le chiffre 0 (et tous les faux positifs devraient nécessairement contenir le chiffre 0), ces 5 octets en tiennent compte.

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

Explication:

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.

Le but de la regex de substitution est de construire une chaîne de 1 dont la longueur est la moitié de la longueur de l'entrée, arrondie à la fin. Ainsi, une entrée de 12321produira la chaîne 111, qui sera alors quadrillée (explication ci-dessous). Les entrées de longueur égale produiront des chaînes trop petites pour assurer la regex finale.

Ce code fonctionne pour les raisons suivantes:

        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

Nous pouvons clairement voir que le nombre de 1 dans RHS est égal à 1/2 plus de la moitié de la taille de LHS. (1 de plus si on tronque). Aditionellement:

567898765 - 123454321 = 444444444, ce qui ne fait que répéter. Ainsi, lorsque nous soustrayons notre carré de notre nombre, si nous obtenons un repdigit, notre numéro d'origine est un nombre de Giza.

Ancien code et ancienne méthode (58 + 1 = 59 octets)

Enregistré 1 octet grâce à @Dada

Exécuter avec le -ndrapeau, le texte de pipe en utilisantecho

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

Calcule le nombre unique de giza déterminé par la longueur et le premier nombre, et vérifie s'il correspond à l'entrée.

Run as echo -n "123454321" | perl -M5.010 -n giza.pl Returns 1si c'est un nombre de Giza, null sinon.

Gelée , 10 7 6 octets

9ẆŒBḌċ

Génère les 45 numéros de Giza, puis teste son appartenance.

Essayez-le en ligne! ou voir les nombres générés .

Comment ça marche

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 octets

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

Prend les entrées sous forme de chaîne et renvoie une chaîne à un chiffre pour vérité, 0pour fausseté.

L'idée de base est de vérifier quelques points:

• Si la chaîne est longue d'un caractère, OU
• le premier caractère est identique au dernier, et
• la partie médiane est aussi un numéro de Giza, et
• le deuxième caractère est un de plus que le premier caractère ici.

Java 7, 128 119 105 octets

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

Pas plus de ficelles! Donc, maintenant je commence par générer un 111...nombre de la même longueur que input ( a), et un plus court en square ( b). Ensuite, vous pouvez soustraire b*bde l’entrée et vérifier la divisibilité par a. cest juste là pour vérifier impair / pair, payez-le sans souci> _>

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

Méthode ancienne, 119 octets

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

Parcourt le tableau en vérifiant la différence de 1 (ou -1, selon la moitié) entre chaque chiffre. Il suffit ensuite de vérifier que la longueur est impaire.

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 octets

La vérité est 1 , la fausseté est 0 .

9LŒ€ûJ¹å

Utilise le codage CP-1252 . Essayez-le en ligne!

Python 2, 77, 76, 64 , 63 octets

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

Une solution récursive simple. Vérifie si les premier et dernier chiffres sont égaux et le deuxième chiffre moins un. Puis vérifie si le milieu est aussi un numéro de Giza. Renvoie true une fois qu'il est passé à un chiffre.

Un octet enregistré grâce à @Rod, un tonne d'octets sauvegardée grâce à DLosc et ETHProductions!

PowerShell v3 +, 147 108 67 octets

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

Approche radicalement changée. Génère tous les nombres possibles de Giza, puis vérifie si l'entrée $args[0]est -incette collection. Voici comment se forme la collection de nombres 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

Exemple fonctionne:

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 octets

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

Je ne suis pas tout à fait sûr, mais je pense que cela fonctionne.

Python 2, 68 73 66 octets

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

en abusant du fait que 11^2=121, 111^2=12321et ainsi de suite, je calcule cela et ajoute 1111..suffisamment de temps pour compenser.
Exemples:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 octets

40 octets de code + -pdrapeaux.

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

Les sorties 1 si l’entrée est un nombre de Giza, rien sinon. Fournissez l'entrée sans nouvelle ligne finale pour l'exécuter:

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

Explications : s/(.)(?=(.))/$1-$2/geremplacez d’abord chaque chiffre $1(suivi de $2) par $1-$2. S'il s'agit d'un numéro de Gizeh, chacun des chiffres représentant un chiffre inférieur de moins au début et un chiffre supplémentaire à la fin, la chaîne ne doit contenir que -1la première partie et 1la seconde (sauf la dernière qui reste inchangée). . C’est ce que la deuxième partie /^(-1(?1)1|).$/vérifie: recherche d’un -1suivi de récursivité suivi d’un1 .

-1 octet grâce à Martin Ender.

Ma version précédente plus longue de 15 octets (assez différente donc je vais le laisser ici):

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

> <> POISSON 57 52 49 48 octets

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

Edit 1: = renvoie 0 ou 1 si true, supprime donc une vérification et utilise cette valeur pour incrémenter, puis il vérifie l’égalité après tout de même. (sauvegardé 6 octets, perdu 1 pour la nouvelle ligne).

Éditez 2: 3 marqueurs directionnels ont été retirés et 11 placés dans l’espace pour décaler la pile sur une longueur égale afin de forcer la valeur false (3 octets enregistrés).,

Edit 3: dupliquez la longueur de la pile pour vérifier MOD par 2 et len ​​(1), cela a été fait en mettant la longueur deux fois auparavant, mais cela remplit maintenant un espace vide sur la ligne 2 (1 octet enregistré).

C #, 120 86 108 102 92 octets

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

Programme complet avec quelques cas de 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
    }
}

Hourra pour les conditionnels simple ligne, battant maintenant la réponse Java :)! Je dois également écrire mes premiers commentaires explicatifs, même s’il s’agit probablement d’explications. Merci à @Dada pour avoir trouvé un problème avec mon algorithme (c'était vrai pour les nombres en miroir comme 13631). À présent, la valeur inférieure à 100, car apparemment la vérification de la longueur% 2 est redondante.

Bash, 111 octets

MISE À JOUR

Notez que la normalisation du nombre d'entrée peut probablement être complètement ignorée, si vous ajoutez simplement le premier chiffre à votre numéro GIZA généré , comme ceci:

01210 + 6 => 67876

et puis juste le comparer avec l'entrée directement.

Avertissement: celui-ci n'est pas vraiment optimisé, il s'agit donc davantage d'une preuve de concept que d'un véritable concurrent

Golfé

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}

Algorithme

Tout numéro GIZA peut être normalisé sous sa forme canonique, en soustrayant son premier chiffre du reste:

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

et il n'y a qu'un seul GIZA canonique numéro d’une longueur donnée.

Sachant cela, nous pouvons facilement générer un nombre canonique GIZA en fonction de la longueur du nombre entré:

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

puis normaliser le nombre saisi:

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

et comparer

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

Tester

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 fait , 22 octets

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

Essayez-le en ligne!

Prend l'entrée en tant que chaîne entre guillemets (par exemple "12321" ). La sortie est un entier positif pour true, et0 pour false.

Explication:

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 octets

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

L'entrée est prise comme une chaîne.

Crée une liste de tous les numéros de Giza et vérifie si le numéro y est indiqué. La liste est créée en ipassant en boucle '1'..'9'puis jen '1'..icréant les éléments j .. i-1 , i , i-1 .. j.

> <> , 62 octets

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

Essayez-le en ligne!

Sorties 1 pour un numéro de Giza; 0 sinon. Fonctionne en poussant l'entrée dans une file d'attente (ok, techniquement une pile réversible) et en testant à plusieurs reprises l'égalité, tout en s'assurant qu'elles sont exactement supérieures à la valeur précédente.

CJam , 20 19 octets

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

Suite de tests.

Explication

L'idée de base est de trouver les chiffres minimum et maximum, puis de créer un nombre de Gizeh à partir de ceux-ci et de vérifier qu'il correspond bien à la saisie.

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.

Au lieu du caractère minimum, nous pouvons également utiliser le premier caractère, pour le même nombre d'octets:

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

Mathematica, 62 61 60 octets

^{2 octets enregistrés en raison de @MartinEnder .}

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

Composition des fonctions. Prend un nombre en entrée et retourne Trueou Falseen sortie.

Retina, 55 54 36 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne

Convertissez chaque chiffre en unaire, séparé par des deux points. Boucle, en supprimant les chiffres externes correspondants si le prochain chiffre est un. Correspond à un seul chiffre restant.

PHP, 71 octets

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

récupère le chiffre le plus élevé de l'entrée et décompte, en ajoutant le nouveau chiffre à une chaîne de comparaison jusqu'à ce que l'entrée et la chaîne de comparaison soient égales - ou $isoit 0.

imprime le chiffre le plus bas pour un numéro Timmy, 0sinon.

Pushy , 30 15 octets

Je me suis réveillé ce matin et je me suis rendu compte que je pouvais faire la moitié de la longueur de ma réponse ...

s&K-kL2/OvhXwx#

_{(non concurrente car le défi linguistique postdates)}

Entrée est donnée sur la ligne de commande: $ pushy gizas.pshy 3456543. Sorties 1pour la vérité et 0pour la fausseté. Voici la ventilation:

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'algorithme a été inspiré par la réponse bash: normalisez d'abord le nombre ( 45654 -> 01210), puis générez le nombre giza normalisé de la même longueur (il n'y en a qu'un) et comparez.

Ancienne solution

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

Raquette 292 octets

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

Essai:

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

Sortie:

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

Java 8, 162 + 19 octets

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

Une approche différente de l'autre réponse Java, je voulais essayer d'utiliser la méthode de création de tous les nombres possibles de Timmy et de vérifier si notre chaîne y était contenue.

Octave, 56 octets

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

Découvrez tous les cas de test ici .

Ce serait deux octets de moins dans MATLAB, car cela diff(n)fonctionne pour les chaînes. Dans Octave, vous avez besoin diff(+n).

Explication:

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

C'est un peu plus court:

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

Java 7, 129 119 109 octets

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

Ancienne méthode récursive, 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 octets grâce à Geobits. Nous sommes liés

Essayez-le en ligne!

Perl 6, 43 34 bytes

Thanks to Jo King for -9 bytes.

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

Port of Gabriel Benamy's Perl solution.

Try it online!

Cjam, 35 bytes

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.