„Liczba Giza”, zwana również potocznie liczbą Timmy'ego, to dowolna liczba, w której cyfry przedstawiają piramidę ( A134810 ). Na przykład „12321” jest liczbą Gizy, ponieważ można ją wizualizować w następujący sposób:

  3  
 2 2
1   1

Jednak coś takiego jak „123321” nie jest liczbą Giza, ponieważ na górze piramidy znajdują się dwie cyfry

  33  
 2  2
1    1

Innymi słowy, liczba jest liczbą Giza, jeśli spełnione są wszystkie następujące warunki:

• Ma nieparzystą liczbę cyfr, a środkowa cyfra jest największa

• Jest palindromiczny (ten sam odczyt do przodu lub do tyłu) i

• Pierwsza połowa cyfr rośnie ściśle o jeden. (Ponieważ musi być palindromiczny, oznacza to, że druga połowa cyfr musi ściśle zmniejszać się o jeden)

Musisz napisać pełny program lub funkcję, która przyjmuje dodatnią liczbę całkowitą jako dane wejściowe i ustalić, czy jest to liczba Giza, czy nie. Możesz wziąć dane wejściowe jako ciąg lub liczbę. Jeśli jest to liczba Giza, należy podać prawdziwą wartość . W przeciwnym razie wartość fałszowania.

Istnieje w sumie 45 liczb Giza, więc każde z tych danych wejściowych powinno dać prawdziwą wartość:

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

Wszelkie inne dane wejściowe powinny dawać wartość fałszowania. Oczywiście nie musisz obsługiwać nieprawidłowych danych wejściowych, takich jak liczby dodatnie, liczby całkowite lub liczby nieparzyste.

Jak zwykle jest to gra w golfa , więc standardowe luki są zakazane, a najkrótsza odpowiedź w bajtach wygrywa!

Python 2, 48 47 46 bajtów

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

Przetestuj na Ideone .

Jak to działa

W Pythonie porównanie łańcuchowe zwraca wartość True wtedy i tylko wtedy, gdy wszystkie indywidualne porównania robią to samo. W tym konkretnym przypadku nasza lambda zwraca wartość True wtedy i tylko wtedy, gdy spełnione są wszystkie następujące warunki.

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

  Dla łańcucha y o długości 2n + 1 , ~len(s)/2wraca ~ (2N + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , więc s[~len(s)/2:], otrzymuje się najbardziej na prawo N + 1 znaków s .

  Podobnie, dla struny s o długości 2n , ~len(s)/2powraca ~ (2 M) / 2 = - (2n + 1) / 2 = - (n + 1) (całkowita podział zawsze okrągły kierunku -∞ , więc s[~len(s)/2:]ponownie otrzymuje się najbardziej na prawo n + 1 znaków s

  Porównanie zwraca wartość True tylko wtedy, gdy skrajnie prawe n + 1 znaków tworzy podłańcuch 987654321.

  Zauważ, że jeśli tak, a s ma 2n znaków, s nie może być palindromem; n ^p i (n + 1) ^TH postacie z prawej być różne, a drugi jest n ^p postać z lewej strony.

• '987654321'>s

  To porównuje ciągi leksykograficzne. Ponieważ 9 jest jedyną liczbą w Gizie, która zaczyna się od 9 , wszystkie liczby w Gizie spełniają to porównanie.

  Pamiętaj, że porównywanie tych ciągów nie stanowi części naszego problemu decyzyjnego; >sjest po prostu o trzy znaki krótszy niż and s.

• s==s[::-1]

  Zwraca wartość True tylko wtedy, gdy s jest palindromem.

Perl, 39 37 42 39 + 1 = 40 bajtów

Dzięki nowej metodzie udało mi się zmniejszyć ogromną liczbę bajtów. Uruchom z -nflagą. Akceptuje dane wejściowe wielokrotnie w czasie wykonywania, odpowiednio drukując 0 lub 1.

Musiałem dodać 5 bajtów, ponieważ zdałem sobie sprawę, że bez tego kod działał dla danych wejściowych, takich jak 1234567900987654321, który nie jest liczbą Giza. Ponieważ liczby Giza nigdy nie zawierają cyfry 0 (a wszystkie fałszywie dodatnie z konieczności zawierałyby cyfrę 0), te 5 bajtów to wyjaśnia.

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

Wyjaśnienie:

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.

Celem wyrażenia regularnego podstawienia jest skonstruowanie ciągu 1s, którego długość stanowi połowę długości wejścia, zaokrągloną w górę. Zatem wejście 12321spowoduje wytworzenie ciągu 111, który następnie zostanie podniesiony do kwadratu (wyjaśnienie poniżej). Dane wejściowe o parzystej długości wytworzą łańcuchy, które są zbyt małe, aby zapewnić, że końcowy regex się powiedzie.

Przyczyną tego kodu jest to, że:

        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

Możemy wyraźnie zobaczyć, że liczba 1 w RHS jest równa 1/2 więcej niż połowa wielkości LHS. (1 więcej, jeśli obciemy). Do tego:

567898765 - 123454321 = 444444444, czyli tylko 4 powtórzenia. Kiedy więc odejmiemy nasz kwadrat od naszego numeru, jeśli otrzymamy powtórkę, naszym pierwotnym numerem jest liczba Giza.

Stary kod i stara metoda (58 + 1 = 59 bajtów)

Zapisano 1 bajt dzięki @Dada

Uruchom z -nflagą, potokuj za pomocą tekstuecho

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

Oblicza unikalną liczbę giza określoną na podstawie długości i wiodącej liczby całkowitej i sprawdza, czy pasuje do wartości wejściowej.

Uruchom jako echo -n "123454321" | perl -M5.010 -n giza.pl Zwraca, 1jeśli jest to liczba Giza, w przeciwnym razie zero.

Galaretka , 10 7 6 bajtów

9ẆŒBḌċ

Generuje wszystkie 45 numerów liczb Giza, a następnie testuje członkostwo.

Wypróbuj online! lub zobacz wygenerowane liczby .

Jak to działa

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 bajtów

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

Pobiera dane wejściowe jako ciąg znaków i zwraca jednocyfrowe ciągi znaków „prawda”, „ 0fałsz”.

Podstawowym pomysłem jest sprawdzenie kilku rzeczy:

• Jeśli ciąg ma jeden znak, LUB
• pierwszy znak jest taki sam jak ostatni znak, i
• środkowa sekcja to także liczba Giza, i
• drugi znak jest o jeden więcej niż pierwszy znak tutaj.

Java 7, 128 119 105 bajtów

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

Nigdy więcej strun! Teraz zaczynam od wygenerowania 111...liczby o tej samej długości co input ( a) i jednej krótszej do square ( b). Następnie możesz odjąć b*bod danych wejściowych i sprawdzić podzielność według a. cjest po to, by sprawdzić nieparzyste / parzyste, nie przejmuj się> _>

Białe znaki:

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

Stara metoda, 119 bajtów

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

Przechodzi przez tablicę, sprawdzając różnicę 1 (lub -1, w zależności od której połowy) między każdą cyfrą. Następnie sprawdza, czy długość jest nieparzysta.

Białe znaki:

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 bajtów

Prawda to 1 , fałsz to 0 .

9LŒ€ûJ¹å

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Python 2, 77, 76, 64 , 63 bajtów

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

Proste rozwiązanie rekurencyjne. Sprawdza, czy pierwsza i ostatnia cyfra są sobie równe, a druga cyfra minus jedna. Następnie sprawdza, czy środek jest również liczbą Giza. Zwraca wartość true, gdy dojdzie do jednej cyfry.

Jeden bajt zaoszczędzony dzięki @Rod, mnóstwo bajtów zaoszczędzonych dzięki DLosc i ETHProductions!

PowerShell v3 +, 147 108 67 bajtów

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

Radykalnie zmienione podejście. Generuje wszystkie możliwe liczby Giza, a następnie sprawdza, czy dane wejściowe $args[0]to -inta kolekcja. Poniżej powstaje zbiór liczb 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

Przykładowe przebiegi:

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 bajtów

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

Nie jestem do końca pewien, ale myślę, że to działa.

Python 2, 68 73 66 bajtów

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

nadużywa fakt 11^2=121, 111^2=12321i tak dalej, to obliczyć i dodać 1111..tyle razy jak offset.
Przykłady:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 bajtów

40 bajtów kodu + -pflagi.

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

Wysyła 1, jeśli wejście jest liczbą Giza, nic innego. Podaj dane wejściowe bez ostatniej nowej linii, aby je uruchomić:

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

Objaśnienia : najpierw s/(.)(?=(.))/$1-$2/gezamień każdą cyfrę $1(a następnie $2) na $1-$2. Jeśli jest to liczba Giza, to każda cyfra jest o jeden mniejsza niż następna na początku i jeszcze jedna na końcu, wówczas ciąg powinien zawierać tylko -1w pierwszej części, a 1w drugiej (z wyjątkiem ostatniej, która pozostaje niezmieniona) . Tak /^(-1(?1)1|).$/sprawdza druga część : szuka -1następnej rekurencji, po której następuje 1.

-1 bajt dzięki Martin Ender.

Moja poprzednia wersja 15 bajtów dłuższa (całkiem inna, więc pozwolę jej tutaj):

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

> <> RYBY 57 52 49 48 bajtów

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

Edycja 1: = zwraca 0 lub 1, jeśli prawda, więc usunęła czek i wykorzystała tę wartość do zwiększenia, a następnie sprawdza równość po tym. (zapisano 6 bajtów, utracono 1 dla nowej linii).

Edycja 2: 3 znaczniki kierunkowe usunięte i 11 umieszczone w szczelinie, aby przesunąć stos na równą długość, aby wymusić fałsz (zapisane 3 bajty).,

Edycja 3: Zduplikuj długość stosu, aby sprawdzić MOD przez 2 i len (1), zostało to zrobione przez dwukrotne umieszczenie długości, ale teraz wypełniło to puste miejsce w linii 2 (zapisano 1 bajt).

C #, 120 86 108 102 92 bajty

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

Pełny program z niektórymi przypadkami testowymi:

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

Brawo dla jednowierszowych warunków, teraz pokonując odpowiedź Java :)! Muszę też napisać moje pierwsze komentarze wyjaśniające, chociaż prawdopodobnie są one oczywiste. Dzięki @Dada za znalezienie problemu z moim algorytmem (było to prawdą w przypadku liczb, które były dublowane jak 13631). Teraz poniżej 100, ponieważ najwyraźniej sprawdzanie długości% 2 jest zbędne.

Bash, 111 bajtów

AKTUALIZACJA

Pamiętaj, że normalizację liczb wejściowych można prawdopodobnie całkowicie pominąć, jeśli po prostu dodasz pierwszą cyfrę z powrotem do wygenerowanego numeru GIZA , w ten sposób:

01210 + 6 => 67876

a następnie po prostu porównaj to bezpośrednio z danymi wejściowymi.

Oświadczenie: ten nie jest tak naprawdę zoptymalizowany, więc jest bardziej dowodem koncepcji niż prawdziwym rywalem

Grał w golfa

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}

Algorytm

Dowolną liczbę GIZA można znormalizować do postaci kanonicznej, odejmując pierwszą cyfrę od reszty:

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

i jest tylko jedna kanoniczna liczba GIZA o określonej długości.

Wiedząc o tym, możemy łatwo wygenerować kanoniczny numer GIZA na podstawie długości numeru wejściowego:

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

następnie znormalizuj numer wejściowy:

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

i porównaj

 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

Właściwie 22 bajty

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

Wypróbuj online!

Pobiera dane wejściowe jako cytowany ciąg (np "12321".). Wyjście jest dodatnią liczbą całkowitą dla wartości true i 0false.

Wyjaśnienie:

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 bajty

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

Dane wejściowe są traktowane jako ciąg.

Tworzy listę wszystkich numerów w Gizie i sprawdza, czy jest w niej numer. Lista jest tworzona przez zapętlenie ipoprzez '1'..'9'a następnie jpoprzez '1'..ii tworzenia elementów j .. i-1 , i , i-1 .. j.

> <> , 62 bajty

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

Wypróbuj online!

Wyjścia 1 dla numeru Giza; 0 w przeciwnym razie. Działa poprzez wpychanie danych wejściowych do dequeue (ok, technicznie odwracalny stos) i wielokrotne testowanie obu końców pod kątem równości, a także upewnienie się, że są dokładnie o jeden większe od poprzedniej wartości.

CJam , 20 19 bajtów

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

Zestaw testowy.

Wyjaśnienie

Podstawową ideą jest znalezienie minimalnej i maksymalnej cyfry, a następnie utworzenie z nich liczby Giza, a następnie sprawdzenie, czy jest ona równoważna z danymi wejściowymi.

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.

Zamiast znaku minimalnego możemy również użyć pierwszego znaku, dla tej samej liczby bajtów:

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

Mathematica, 62 61 60 bajtów

^{Zapisano 2 bajty dzięki @MartinEnder .}

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

Skład funkcji. Pobiera liczbę jako dane wejściowe i zwraca Truelub Falsedane wyjściowe.

Retina, 55 54 36 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online

Konwertuj każdą cyfrę na unarną, oddzieloną dwukropkami. Pętla, usuwając pasujące cyfry zewnętrzne, jeśli następna cyfra to jeszcze jedna. Dopasuj jedną pozostałą cyfrę.

PHP, 71 bajtów

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

pobiera największą cyfrę z wejścia i odlicza, dodając nową cyfrę do ciągu porównawczego, aż parametry wejściowe i porównawcze będą równe - lub $ibędzie 0.

wypisuje najniższą cyfrę dla Timmy Number, w przeciwnym razie 0.

Pushy , 30 15 bajtów

Obudziłem się dziś rano i zdaję sobie sprawę, że mogę o połowę dłużej odpowiedzieć ...

s&K-kL2/OvhXwx#

_{(niekonkuruje, ponieważ wyzwanie stanowi język po datach)}

Wejście jest podana w wierszu poleceń: $ pushy gizas.pshy 3456543. Wyjścia 1dla prawdy i 0fałszu. Oto podział:

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

Algorytm został zainspirowany odpowiedzią bash: najpierw normalizuj liczbę ( 45654 -> 01210), a następnie wygeneruj znormalizowaną liczbę giza o tej samej długości (jest tylko jedna) i porównaj.

Stare rozwiązanie

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

Rakieta 292 bajtów

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

Nie golfowany:

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

Testowanie:

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

Wynik:

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

Java 8, 162 + 19 bajtów

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

Odmiennie podchodząc do innej odpowiedzi Java, chciałem spróbować metody tworzenia wszystkich możliwych liczb Timmy'ego i sprawdzania, czy zawiera się w nich nasz łańcuch.

Oktawa, 56 bajtów

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

Sprawdź wszystkie przypadki testowe tutaj .

W MATLAB byłoby to o dwa mniej bajtów, ponieważ diff(n)działa na łańcuchy. W Octave potrzebujesz diff(+n).

Wyjaśnienie:

@(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 bajtów

To jest trochę krótsze:

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

Java 7, 129 119 109 bajtów

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

Stara metoda rekurencyjna, 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 bajtów dzięki Geobits. My są związane były ...

Wypróbuj online!

Perl 6 , 43 34 bajtów

Dzięki Jo King za -9 bajtów.

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

Rozwiązanie Perla dla portu Gabriela Benamy'ego .

Wypróbuj online!

Cjam, 35 bajtów

Prawdopodobnie bardzo nieoptymalny ... Jestem trochę poza praktyką!

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

Wypróbuj online!

Python 2, 50 82 81 80 bajtów

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

Proste podejście. Po prostu dzieli łańcuch na pół (brakuje środkowego znaku lub jeden po środku znaku, jeśli jest równej długości), odwraca drugą połowę, a następnie porównuje obie i porównuje pierwszą połowę ze łańcuchem od 1 do 9.

Edytować

Przesłane po konstruktywnej informacji zwrotnej od innych golfistów oraz uświadomieniu sobie i poprawieniu moich błędów.

-1 za utratę (marnotrawstwo) miejsca

-1 za ponowne przeczytanie pytania i uświadomienie sobie, że nie musimy brać pod uwagę 0. Naprawdę muszę przestać grać w golfa po długim dniu w pracy.