Eine "Gizeh-Nummer", umgangssprachlich auch als Timmy-Nummer bezeichnet, ist eine beliebige Zahl, bei der die Ziffern eine Pyramide darstellen ( A134810 ). Beispiel: "12321" ist eine Gizeh-Nummer, weil sie folgendermaßen dargestellt werden kann:

  3  
 2 2
1   1

Etwas wie "123321" ist jedoch keine Gizeh-Zahl, da sich oben in der Pyramide zwei Ziffern befinden

  33  
 2  2
1    1

Mit anderen Worten, eine Zahl ist eine Gizeh-Zahl, wenn alle folgenden Bedingungen erfüllt sind:

• Es hat eine ungerade Anzahl von Ziffern, und die mittlere Ziffer ist die größte

• Es ist palindromisch (das gleiche vorwärts oder rückwärts lesen), und

• Die erste Hälfte der Ziffern erhöht sich strikt um eins. (Da es palindrom sein muss, bedeutet dies, dass die zweite Hälfte der Ziffern streng um eins verringert werden muss.)

Sie müssen ein vollständiges Programm oder eine Funktion schreiben, die eine positive Ganzzahl als Eingabe verwendet, und feststellen, ob es sich um eine Gizeh-Zahl handelt oder nicht. Sie können die Eingabe als Zeichenfolge oder als Zahl annehmen. Wenn es sich um eine Gizeh-Zahl handelt, geben Sie einen Wahrheitswert aus . Ansonsten ein falscher Wert.

Es gibt insgesamt 45 Giza-Zahlen, daher sollte jede dieser Eingaben einen Wahrheitswert ergeben:

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

Jede andere Eingabe sollte einen falschen Wert ergeben. Natürlich müssen Sie keine ungültigen Eingaben wie nicht positive Zahlen, nicht ganze Zahlen oder nicht Zahlen verarbeiten.

Wie üblich ist dies Codegolf , so dass Standard-Schlupflöcher verboten werden und die kürzeste Antwort in Bytes gewinnt!

Python 2, 48 47 46 Bytes

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

Teste es auf Ideone .

Wie es funktioniert

In Python gibt ein verketteter Vergleich nur dann True zurück, wenn alle Einzelvergleiche dasselbe tun. In diesem speziellen Fall gibt unser Lambda nur dann True zurück, wenn alle folgenden Bedingungen erfüllt sind.

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

  Für einen String s der Länge 2N + 1 , ~len(s)/2kehrt ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , so s[~len(s)/2:]ergibt sich die am weitesten rechts stehenden n + 1 - Zeichen von s .

  Auf ähnliche Weise für eine Zeichenfolge s der Länge 2n , ~len(s)/2kehrt ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (ganzzahlige Division immer rund Richtung -∞ , so s[~len(s)/2:]wieder ergibt die am weitesten rechts liegenden n + 1 Zeichen von s

  Der Vergleich gibt nur dann True zurück, wenn die am weitesten rechts stehenden n + 1 Zeichen eine Teilzeichenfolge von bilden 987654321.

  Beachten Sie, dass wenn sie es tun und s hat 2n Zeichen, s kein Palindrom sein kann; Das n- ^te und (n + 1) ^-te Zeichen von rechts ist verschieden, und das letztere ist das n- ^te Zeichen von links.

• '987654321'>s

  Dies vergleicht die Saiten lexikographisch. Da 9 die einzige Gizeh-Zahl ist, die mit 9 beginnt , erfüllen alle Gizeh-Zahlen diesen Vergleich.

  Beachten Sie, dass der Vergleich dieser Zeichenfolgen nicht Teil unseres Entscheidungsproblems ist. >sist einfach drei Zeichen kürzer als and s.

• s==s[::-1]

  Dies gibt nur dann True zurück, wenn s ein Palindrom ist.

Perl, 39 37 42 39 + 1 = 40 Bytes

Mit einer neuen Methode gelang es mir, eine große Anzahl von Bytes zu reduzieren. Laufen Sie mit der -nFlagge. Akzeptiert wiederholte Eingaben zur Laufzeit und druckt entsprechend 0 oder 1.

Ich musste 5 Bytes hinzufügen, weil mir klar wurde, dass der Code für Eingaben wie 1234567900987654321 funktioniert, was keine Gizeh-Nummer ist. Da Gizeh-Zahlen niemals die Ziffer 0 enthalten (und alle False Positives zwangsläufig die Ziffer 0 enthalten würden), machen diese 5 Bytes das aus.

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

Erläuterung:

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.

Der Zweck des Substitutions-Regex besteht darin, einen String von 1s zu konstruieren, dessen Länge die Hälfte der Länge der Eingabe ist, aufgerundet. Eine Eingabe von 12321erzeugt also den String 111, der dann quadriert wird (Erklärung unten). Bei Eingaben mit gerader Länge werden Zeichenfolgen erzeugt, die zu klein sind, um sicherzustellen, dass die endgültige Regex erfolgreich ist.

Der Grund, warum dieser Code funktioniert, ist folgender:

        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

Wir können deutlich sehen, dass die Anzahl der Einsen in RHS gleich 1/2 mehr als die Hälfte der Größe von LHS ist. (1 mehr, wenn wir abschneiden). Zusätzlich:

567898765 - 123454321 = 444444444, was nur 4 Wiederholungen entspricht. Wenn wir also unser Quadrat von unserer Zahl abziehen, ist unsere ursprüngliche Zahl eine Gizeh-Zahl, wenn wir eine Nachziffer erhalten.

Alter Code und alte Methode (58 + 1 = 59 Byte)

1 Byte dank @Dada gespeichert

Laufen Sie mit der -nFlagge und leiten Sie den Text mit einecho

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

Berechnet die eindeutige Giza-Nummer, die durch die Länge und die führende Ganzzahl bestimmt wird, und überprüft, ob sie mit der Eingabe übereinstimmt.

Run as echo -n "123454321" | perl -M5.010 -n giza.pl Gibt zurück, 1wenn es sich um eine Gizeh-Zahl handelt, andernfalls null.

Jelly , 10 7 6 Bytes

9ẆŒBḌċ

Generiert alle 45 Giza-Nummern und testet dann die Mitgliedschaft.

Probieren Sie es online! oder sehen Sie die generierten Zahlen .

Wie es funktioniert

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

Nimmt Eingaben als Zeichenfolge und gibt eine einstellige Zeichenfolge für Wahr oder 0Falsch zurück.

Die Grundidee ist, nach ein paar Dingen zu suchen:

• Wenn die Zeichenfolge ein Zeichen lang ist, ODER
• der erste Buchstabe ist der gleiche wie der letzte Buchstabe, und
• der Mittelteil ist auch eine Gizeh-Nummer, und
• Das zweite Zeichen ist hier ein Zeichen mehr als das erste.

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

Keine Saiten mehr! Nun beginne ich mit der Generierung einer 111...Zahl mit der gleichen Länge wie input ( a) und einer, die kürzer als square ( b) ist. Dann können Sie b*bvon der Eingabe subtrahieren und die Teilbarkeit durch prüfen a. cist nur da, um ungerade / gerade zu prüfen, es macht nichts aus> _>

Leerzeichen:

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

Alte Methode, 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;}

Durchläuft das Array und prüft, ob zwischen den einzelnen Ziffern ein Unterschied von 1 (oder -1, je nach der Hälfte) besteht. Überprüfen Sie dann einfach, ob die Länge ungerade ist.

Leerzeichen:

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

Wahrheit ist 1 , falsch ist 0 .

9LŒ€ûJ¹å

Verwendet die CP-1252- Codierung. Probieren Sie es 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]))

Eine einfache rekursive Lösung. Prüft, ob die erste und die letzte Ziffer gleich sind und die zweite Ziffer minus eins. Dann wird geprüft, ob die Mitte auch eine Gizeh-Nummer ist. Gibt true zurück, sobald eine einzelne Ziffer erreicht ist.

Dank @Rod ein Byte gespart, dank DLosc und ETHProductions eine Tonne Bytes!

PowerShell v3 +, 147 108 67 Byte

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

Radikal veränderte Herangehensweise. Erzeugt alle möglichen Giza Zahlen, und dann überprüft , ob die Eingabe $args[0]ist , -indass Sammlung. Nachfolgend sehen Sie, wie die Sammlung der Gizeh-Zahlen gebildet wird:

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

Beispiel läuft:

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

Ich bin nicht ganz sicher, aber ich denke, das funktioniert.

Python 2, 68 73 66 Bytes

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

Missbrauche die Tatsache, dass 11^2=121, 111^2=12321und so weiter, ich dies berechne und 1111..genug Male als Offset hinzufüge .
Beispiele:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 Bytes

40 Byte Code + -pFlags.

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

Gibt 1 aus, wenn die Eingabe eine Giza-Nummer ist, sonst nichts. Geben Sie die Eingabe ohne letzten Zeilenumbruch ein, um sie auszuführen:

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

Erklärungen : s/(.)(?=(.))/$1-$2/geErsetzen Sie zuerst jede Ziffer $1(gefolgt von $2) durch $1-$2. Wenn es sich um eine Gizeh-Zahl handelt, ist jede Ziffer am Anfang eine Stelle weniger als die nächste und am Ende eine weitere Stelle. Die Zeichenfolge sollte nur -1im ersten Teil und 1im zweiten Teil enthalten sein (mit Ausnahme der letzten, die unverändert bleibt). . Das ist , was der zweite Teil /^(-1(?1)1|).$/überprüft: Aussehen für eine -1gefolgt von Rekursion , gefolgt von einem 1.

-1 Byte dank Martin Ender.

Meine vorherige Version ist 15 Bytes länger (ganz anders, also lasse ich es hier):

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

> <> FISH 57 52 49 48 Bytes

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

Edit 1: = gibt 0 oder 1 zurück, wenn true, also ein Häkchen entfernt und diesen Wert zum Inkrementieren verwendet, dann wird die Gleichheit trotzdem überprüft. (6 Bytes gespeichert, 1 für neue Zeile verloren).

Bearbeiten Sie 2: 3 Richtungsmarkierungen entfernt und 11 in die Lücke gesetzt, um den Stapel auf eine gerade Länge zu versetzen, um false (3 Bytes gespeichert) zu erzwingen.

Edit 3: Duplizieren Sie die Länge des Stapels zum Prüfen von MOD mit 2 und len (1). Dies wurde durch zweimaliges Anlegen der Länge durchgeführt, aber dies füllte jetzt einen leeren Raum in Zeile 2 (1 Byte gespeichert).

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

Volles Programm mit einigen Testfällen:

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 für Single-Line-Bedingungen, die jetzt die Java-Antwort schlagen :)! Ich muss auch meine ersten erklärenden Kommentare schreiben, obwohl es wahrscheinlich selbsterklärend ist. Vielen Dank an @Dada für das Auffinden eines Problems mit meinem Algorithmus (gilt für Zahlen, die wie 13631 gespiegelt wurden). Jetzt unter 100, da anscheinend die Überprüfung auf Länge% 2 überflüssig ist.

Bash, 111 Bytes

AKTUALISIEREN

Beachten Sie, dass die Normalisierung von Eingabenummern möglicherweise vollständig übersprungen werden kann, wenn Sie einfach die erste Ziffer wie folgt zu Ihrer generierten GIZA- Nummer hinzufügen :

01210 + 6 => 67876

und dann einfach mit dem eingang direkt vergleichen.

Haftungsausschluss: Dieser ist nicht wirklich optimiert, daher handelt es sich eher um einen Proof of Concept als um einen echten Konkurrenten

Golf gespielt

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}

Algorithmus

Jede GIZA- Nummer kann auf ihre kanonische Form normiert werden, indem die erste Ziffer vom Rest abgezogen wird:

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

und es gibt nur eine kanonische GIZA- Nummer einer bestimmten Länge.

Wenn wir das wissen, können wir leicht eine kanonische GIZA- Nummer generieren, die auf der Länge der eingegebenen Nummer basiert:

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

dann normalisiere die eingegebene Nummer:

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

und vergleichen

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

Prüfung

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

Eigentlich 22 Bytes

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

Probieren Sie es online!

Nimmt Eingaben in Anführungszeichen (zB "12321"). Die Ausgabe ist eine positive Ganzzahl für true und 0false.

Erläuterung:

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

Die Eingabe wird als Zeichenfolge verwendet.

Erstellt eine Liste aller Gizeh-Nummern und prüft, ob die Nummer darin enthalten ist. Die Liste wird durch Schleifen erstellt idurch '1'..'9'und dann jdurch '1'..iund die Schaffung der Elemente 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;

Probieren Sie es online!

Gibt 1 für eine Gizeh-Nummer aus; 0 sonst. Schieben Sie die Eingabe in eine Warteschlange (technisch gesehen ein umkehrbarer Stapel) und testen Sie wiederholt beide Enden auf Gleichheit und stellen Sie sicher, dass sie genau um eins größer als der vorherige Wert sind.

CJam , 20 bis 19 Bytes

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

Testsuite.

Erläuterung

Die Grundidee besteht darin, die minimale und maximale Ziffer zu finden, dann eine Gizeh-Zahl daraus zu erstellen und dann zu überprüfen, ob sie der Eingabe entspricht.

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.

Anstelle des Mindestzeichens können wir auch das erste Zeichen für dieselbe Bytezahl verwenden:

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

Mathematica, 62 61 60 Bytes

^{2 Bytes aufgrund von @MartinEnder gespeichert .}

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

Zusammensetzung der Funktionen. Nimmt eine Zahl als Eingabe und gibt sie zurück Trueoder Falseals Ausgabe.

Netzhaut, 55 54 36 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online aus

Konvertieren Sie jede Ziffer in eine unäre Zahl, die durch Doppelpunkte getrennt ist. Schleife zum Entfernen übereinstimmender äußerer Ziffern, wenn die nächste Ziffer eine weitere ist. Ordnen Sie eine einzelne verbleibende Ziffer zu.

PHP, 71 Bytes

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

Ruft die größte Ziffer von der Eingabe ab und zählt abwärts, wobei die neue Ziffer zu einer Vergleichszeichenfolge hinzugefügt wird, bis Eingabe und Vergleichszeichenfolge gleich sind - oder $iist 0.

druckt die niedrigste Ziffer für eine Timmy-Nummer, 0sonst.

Aufdringlich , 30 15 Bytes

Ich bin heute Morgen aufgewacht und habe gemerkt, dass ich die Hälfte meiner Antwort haben könnte ...

s&K-kL2/OvhXwx#

_{(Nicht konkurrierend, da die Sprache nach dem Termin eine Herausforderung darstellt)}

Die Eingabe wird in der Befehlszeile angegeben: $ pushy gizas.pshy 3456543. Ausgänge 1für wahr und 0für falsch. Hier ist die Aufteilung:

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

Der Algorithmus wurde von der Bash-Antwort inspiriert: Zuerst die Zahl normalisieren ( 45654 -> 01210), dann die normalisierte Giza-Zahl der gleichen Länge generieren (es gibt nur eine) und vergleichen.

Alte Lösung

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

Schläger 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))))]
      )))

Testen:

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

Ausgabe:

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

Java 8, 162 + 19 Bytes

19 für 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);}

Anders als bei der anderen Java-Antwort wollte ich versuchen, alle möglichen Timmy-Zahlen zu erstellen und zu überprüfen, ob unsere Zeichenfolge in ihnen enthalten war.

Oktave, 56 Bytes

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

Schauen Sie sich alle Testfälle hier .

Dies wären in MATLAB zwei Bytes weniger, da dies diff(n)für Zeichenfolgen funktioniert. In Octave brauchen Sie diff(+n).

Erläuterung:

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

Das ist etwas kürzer:

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

Alte rekursive Methode, 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 dank Geobits. Wir sind gebunden waren ...

Probieren Sie es online!

Perl 6 , 43 34 Bytes

Vielen Dank an Jo King für -9 Bytes.

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

Portierung der Perl-Lösung von Gabriel Benamy .

Probieren Sie es online!

Cjam, 35 Bytes

Wahrscheinlich sehr suboptimal ... Ich bin ein wenig außer Übung!

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

Probieren Sie es 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']

Einfacher Ansatz. Teilen Sie die Zeichenfolge einfach in zwei Hälften auf (ohne das mittlere Zeichen oder eins nach dem mittleren Zeichen, wenn es gerade ist), kehren Sie die zweite Hälfte um, vergleichen Sie die beiden und vergleichen Sie die erste Hälfte mit einer Zeichenfolge von 1 bis 9.

Bearbeiten

Reposted nach konstruktivem Feedback von anderen Golfern und dem Erkennen und Korrigieren meiner Fehler.

-1 für den Verlust eines (verschwendeten) Platzes

-1 für das erneute Lesen der Frage und das Erkennen, dass wir 0 nicht berücksichtigen müssen. Muss nach einem langen Arbeitstag unbedingt aufhören zu golfen.