Ayrıca Timmy Numarası olarak da bilinen bir "Giza numarası", rakamların bir piramidi temsil ettiği herhangi bir sayıdır ( A134810 ). Örneğin, "12321" bir giza numarasıdır, çünkü şu şekilde görselleştirilebilir:

  3  
 2 2
1   1

Bununla birlikte, "123321" gibi bir şey Giza numarası değildir, çünkü piramidin tepesinde iki rakam vardır.

  33  
 2  2
1    1

Başka bir deyişle, aşağıdaki koşulların tümü yerine getirildiğinde sayı Giza numarasıdır:

• Tek sayıda basamak vardır ve orta basamak en büyüğüdür.

• Palindromiktir (aynı ileri veya geri okunur) ve

• Rakamların ilk yarısı kesinlikle bir artış gösteriyor. (Palindromik olması gerektiğinden, bu rakamların ikinci yarısının bir ile kesinlikle azalması gerektiği anlamına gelir)

Tam bir program veya girdi olarak pozitif bir tamsayı alan bir işlev yazmalı ve bunun bir Giza numarası olup olmadığını belirlemelisiniz. Girişi bir dize veya sayı olarak alabilirsiniz. O takdirde ise bir Giza numarası çıkışı truthy değer . Aksi takdirde, sahte bir değerdir.

Toplam 45 Giza numarası vardır, bu nedenle bu girdilerden herhangi birinin bir gerçek değeri ile sonuçlanması gerekir:

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

Başka herhangi bir giriş sahte bir değer vermelidir. Tabii ki, pozitif olmayan sayılar, tam sayı olmayanlar veya sayı olmayanlar gibi geçersiz girişleri işlemeniz gerekmez.

Her zaman olduğu gibi, bu kod golf , yani standart boşluklar yasaklandı ve bayt cinsinden en kısa cevap kazanıldı!

Python 2, 48 47 46 bayt

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

İdeone üzerinde test et .

Nasıl çalışır

Python'da zincirleme bir karşılaştırma, eğer ve eğer tüm bireysel karşılaştırmalar aynı olursa , True döndürür . Bu özel durumda, lambda , aşağıdaki koşulların tümü yerine getirildiğinde ve yalnızca gerçekleşirse True değerini döndürür .

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

  Bir dizi için s uzunluğunun 2n + 1 , ~len(s)/2döner (2n + 2) / 2 = - - (n + 1) ~ (2n + 1) / 2 = yüzden s[~len(s)/2:]en sağdaki verir , n + 1 ve karakter s .

  Benzer şekilde, bir dize için in uzunluğu 2n , ~len(s)/2döner ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) , her zaman yuvarlak doğru (tamsayı bölme -oo , bu yüzden s[~len(s)/2:]bir kere daha sağdaki verir + n 1 s karakter

  Karşılaştırma, eğer sadece en sağdaki n + 1 karakterleri bir alt dizini oluşturuyorsa True döndürür .987654321

  Yaptıkları ve eğer Not ler vardır 2n karakterleri, s bir palindrom olamaz; N ^inci ve (n + 1) ^inci sağdan karakterleri ayrı olacak ve ikincisi , n ^inci soldan karakteri.

• '987654321'>s

  Bu, dizeleri sözlüksel olarak karşılaştırır. Yana 9 ile başlar sadece Giza sayıdır 9'a , tüm Giza numaraları bu karşılaştırmayı karşılamaktadır.

  Bu dizelerin karşılaştırılmasının karar sorunumuzun bir parçası olmadığını unutmayın; >ssadece üç karakterden daha kısa and s.

• s==s[::-1]

  Bu, eğer ve sadece s bir palindrom ise True döndürür .

Perl, 39 37 42 39 + 1 = 40 bayt

Yeni bir yöntem kullanarak çok sayıda baytı kesmeyi başardım. -nBayrakla koş . Çalışma zamanında girişi art arda kabul eder, buna göre 0 veya 1 yazdırır.

5 bayt eklemek zorunda kaldım, çünkü onsuz anladım, kod Giza numarası olmayan 1234567900987654321 gibi girdiler için çalışıyordu. Giza sayıları hiçbir zaman 0 rakamını içermediğinden (ve zorunlu olarak tüm hatalı pozitifler 0 rakamını içerdiğinden), bu 5 bayt bunu hesaba katar.

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

Açıklama:

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.

İkame regex'in amacı, uzunluğu girişin uzunluğunun yarısı kadar yuvarlanmış 1'lik bir ip oluşturmaktır. Böylece, bir girdi , daha sonra kareleşen 12321dizeyi üretecektir 111(aşağıdaki açıklama). Düzgün girişler, son regex'in başarılı olmasını sağlamak için çok küçük olan dizeler üretecektir.

Bu kodun çalışmasının nedeni aşağıdakilerden kaynaklanıyor:

        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

RHS'deki 1 sayısının LHS boyutunun yarısından 1 / 2'sine eşit olduğunu açıkça görebiliyoruz. (Eğer kısalırsak 1 tane daha). Bunlara ek olarak:

567898765 - 123454321 = 444444444, ki bu sadece 4 tekrar ediyor. Yani, karemizi sayılarımızdan çıkardığımızda, eğer bir repdigit alırsak, orijinal numaramız Giza numarasıdır.

Eski kod ve eski yöntem (58 + 1 = 59 bayt)

@Dada sayesinde 1 bayt kaydedildi

-nBayrakla çalıştır , boru metnini kullanecho

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

Uzunluk ve ana tamsayı tarafından belirlenen benzersiz giza sayısını hesaplar ve girdiyle eşleşip eşleşmediğini görür.

Eğer bir Giza numarasıysa echo -n "123454321" | perl -M5.010 -n giza.pl İade olarak çalıştırın 1, aksi takdirde null olur.

Jöle , 10 7 6 bayt

9ẆŒBḌċ

Tüm 45 Giza sayı numaralarını oluşturur, ardından üyeliği test eder.

Çevrimiçi deneyin! veya üretilen sayıları görün .

Nasıl çalışır

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 bayt

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

Girdiyi bir dizge olarak alır ve yanlışlık 0için truthy için tek basamaklı bir dizge döndürür .

Temel fikir birkaç şeyi kontrol etmektir:

• Dize bir karakter uzunluğundaysa, VEYA
• ilk karakter son karakterle aynıdır ve
• orta kısım aynı zamanda bir Giza numarasıdır ve
• İkinci karakter, buradaki ilk karakterden bir tanesidir.

Java 7, 128 119 105 bayt

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

Artık ip yok! Bu yüzden şimdi 111..., input ( a) ile aynı uzunlukta ve bir kareye daha kısa bir sayı üreterek başlıyorum b. Sonra b*bgirişten çıkartabilir ve bölüştürülebilirliğini kontrol edebilirsiniz a. cTek / çiftleri kontrol etmek için sadece orada, aldırış etmeyin> _>

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

Eski Yöntem, 119 bayt

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

Dizinin içinde yürür ve her bir hane arasındaki hangi yarıya bağlı olarak 1 (veya -1) farkını kontrol eder. Sonra sadece uzunluğu tek görmek için kontrol eder.

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 bayt

Gerçek 1 , sahte 0 .

9LŒ€ûJ¹å

CP-1252 kodlamasını kullanır . Çevrimiçi deneyin!

Python 2, 77, 76, 64 , 63 bayt

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

Basit bir özyinelemeli çözüm. İlk ve son hanelerin birbirlerine eşit olup olmadığını ve ikinci hanenin eksi olduğunu kontrol eder. Ardından orta kısmın da Giza numarası olup olmadığını kontrol eder. Tek bir basamağa indiğinde true değerini döndürür.

@Rod sayesinde bir bayt, DLosc ve ETHProductions sayesinde bir ton bayt kurtarıldı!

PowerShell v3 +, 147 108 67 bayt

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

Köklü olarak değişen yaklaşım. Giriş olsun tüm olası Giza numaraları ve ardından çekleri üretir $args[0]olduğunu -inolduğunu koleksiyonu. Giza numaralarının nasıl oluştuğunu aşağıda bulabilirsiniz:

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

Örnek çalıştırır:

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 bayt

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

Tamamen emin değilim, ama bence işe yarıyor.

Python 2, 68 73 66 bayt

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

ve bunun 11^2=121gibi şeyleri kötüye kullanmak 111^2=12321, bunu hesaplar ve 1111..ofset olarak yeterli zaman eklerim .
Örnekler:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 bayt

40 bayt kod + -pbayrakları.

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

Giriş bir Giza numarası ise 1, aksi takdirde hiçbir şey çıkmaz. Çalıştırmak için girişi son satırsonu olmadan verin:

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

Açıklamalar : İlk önce s/(.)(?=(.))/$1-$2/geher rakamı $1(ardından $2) ile değiştirin $1-$2. Eğer bu bir Giza numarasıysa, her rakam başlangıçta bir sonrakinden daha az ve sonda bir tane olmak üzere, o zaman dize yalnızca -1ilk bölümde ve 1ikinci sırada (değişmeden kalan son hariç) bulunmalıdır. . Yani en neyi ikinci bölümü /^(-1(?1)1|).$/denetler: a için görünüyor -1izledi özyineleme bir takip 1.

Martin Ender sayesinde -1 bayt.

Önceki sürümüm 15 bayt daha uzun (oldukça farklı yani buraya izin vereceğim):

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

> <> FISH 57 52 49 48 bayt

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

Edit 1: = true olursa 0 veya 1 değerini döndürür, böylece bir onay kaldırılır ve bu değeri artırma için kullanır, sonra yine de eşitliği denetler. (6 bayt kaydedildi, yeni satır için 1 kaybedildi).

2: 3 yönlü işaretleyicileri düzenleyin ve 11, istifin yanlış bir şekilde (3 bayt kaydedildi) zorlanacak şekilde sabitlenmesi için boşluğa yerleştirildi.

Düzenleme 3: MOD'u kontrol etmek için yığının uzunluğunu 2 ve len (1) olarak çoğaltın, bu, uzunluğu daha önce iki kez koymak suretiyle yapıldı, ancak bu şimdi satır 2'de (1 bayt kaydedilmiş) boş bir alanı doldurdu.

C #, 120 86 108 102 92 bayt

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

Bazı test durumları ile tam program:

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

Tek satır koşullandırma için yaşasın, şimdi Java cevabını dayak :)! Ayrıca ilk açıklamalarımı da açıklamalıyım, ancak muhtemelen kendi kendini açıklayıcı. Algoritmamla ilgili bir sorun buldukları için @Dada'ya teşekkür ederim (13631 gibi yansıtılmış sayılar için doğruydu). Şimdi% 100 alt uzunluğu görünüşte% 2 uzunluğunu kontrol etmekte fazlalık var

Bash, 111 bayt

GÜNCELLEME

Girdi numarası normalizasyonunun muhtemelen tamamen atlanabileceğini unutmayın, eğer sadece ilk basamağı oluşturulan GIZA numaranıza geri eklerseniz , şöyle:

01210 + 6 => 67876

ve sonra doğrudan girişle karşılaştırın.

Feragatname: Bu gerçekten optimize edilmiş değil, bu yüzden gerçek bir rakipten daha kavramının bir kanıtı

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}

Algoritma

Herhangi bir GIZA numarası, ilk basamağını diğerlerinden çıkararak kanonik olarak normalleştirilebilir:

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

ve belirli bir uzunlukta yalnızca bir tane kanonik GIZA numarası vardır.

Bunu bilerek giriş numarası uzunluğuna göre kolayca kanonik bir GIZA numarası oluşturabiliriz :

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

daha sonra giriş numarasını normalleştirin:

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

ve karşılaştır

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

Ölçek

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

Aslında , 22 bayt

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

Çevrimiçi deneyin!

Girdiyi bir alıntı dizesi olarak alır (örn. "12321"). Çıktı, doğru ve 0yanlış için pozitif bir tamsayıdır .

Açıklama:

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 bayt

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

Giriş bir dize olarak alınır.

Sayının içinde olup olmadığını kontrol eden tüm Giza numaralarının bir listesini oluşturur. Liste döngü tarafından oluşturulur iiçinden '1'..'9've daha sonra jiçinden '1'..ive elemanlarını oluşturmak j .. i-1 , i , i-1 .. j.

> <> , 62 bayt

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

Çevrimiçi deneyin!

Giza numarası için 1 çıkışı; Aksi halde 0. Girişi bir dequeue (tamam, teknik olarak geri dönüşümlü bir yığın) içine iterek ve her iki ucu eşitlik için tekrar tekrar test ederek ve önceki değerden tam olarak daha büyük olduklarından emin olarak çalışır.

CJam , 20 19 bayt

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

Test odası.

açıklama

Temel fikir, minimum ve maksimum rakamları bulmak, ardından bunlardan bir Giza numarası oluşturmak ve sonra bunun girişe eşdeğer olduğunu kontrol etmektir.

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.

Minimum karakter yerine, aynı karakteri bayt için ilk karakteri de kullanabiliriz:

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

Mathematica, 62 61 60 bayt

^{@MartinEnder nedeniyle 2 bayt kaydedildi .}

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

Fonksiyonların bileşimi. Bir sayıyı girdi olarak alır ve geri döndürür Trueveya Falseçıktı olarak alır.

Retina, 55 54 36 bayt

Bayt sayısı, ISO 8859-1 kodlamasını varsayar.

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

Çevrimiçi deneyin

Her basamağı virgülle ayırarak, tekliğe dönüştürün. Döngü, bir sonraki hane bir tane ise eşleşen dış hanelerin kaldırılması. Kalan tek bir rakamla eşleştirin.

PHP, 71 bayt

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

girişten büyük rakamı getirir ve giriş ve karşılaştırma dize eşit olana kadar bir karşılaştırma dizeye yeni rakam ekleyerek geri sayım - veya $ibir 0.

Timmy Number için en düşük basamağı yazdırır, 0başka.

Pushy , 30 15 bayt

Bu sabah uyandım ve cevabımın yarısını alabileceğimi farkettim ...

s&K-kL2/OvhXwx#

_{(dilin yayınlanma tarihi sonrası mücadelesi olarak rekabet etmeyen)}

Girdi komut satırında verilir: $ pushy gizas.pshy 3456543. Çıkışlar 1truthy için ve 0falsy için. İşte döküm:

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

Algoritma bash cevabından ilham aldı: ilk önce sayıyı normalleştirin, ( 45654 -> 01210), sonra aynı uzunluktaki normalize giza sayısını (sadece bir tane var) oluşturun ve karşılaştırın.

Eski çözüm

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

Raket 292 bayt

(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 yapmak:

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

Çıktı:

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

Java 8, 162 + 19 bayt

19 için 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);}

Diğer Java cevabına farklı bir yaklaşım olarak, mümkün olan tüm Timmy numaralarını yaratma yöntemini ve dizimizin içinde olup olmadığını kontrol etmeye çalışmayı denemek istedim.

Octave, 56 bayt

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

Tüm test durumlarına buradan göz atın .

Bu, diff(n)dizgiler için çalıştığından , MATLAB'da iki az bayt olacaktır . Octave'da ihtiyacın var diff(+n).

Açıklama:

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

Bu biraz daha kısa:

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

Java 7, 129 119 109 bayt

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

Eski Özyinelemeli Yöntem, 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;}

Geobits sayesinde -10 bayt. Biz edilir bağlandı ...

Çevrimiçi deneyin!

Perl 6 , 43 34 bayt

-9 baytlık Jo King'e teşekkürler.

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

Port Gabriel Benamy Perl çözüm .

Çevrimiçi deneyin!

Cjam, 35 bayt

Muhtemelen çok suboptimal ... Biraz pratik yapıyorum!

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

Çevrimiçi deneyin!

Python 2, 50 82 81 80 bayt

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

Basit bir yaklaşım. Sadece dizeyi ikiye böler (orta karakterden veya orta uzunlukta olan karakterden biri uzunsa), ikinci yarıyı ters çevirir, sonra ikisini karşılaştırır ve ilk yarıyı 1 ila 9 dizeyle karşılaştırır.

Düzenle

Diğer golfçülerden gelen yapıcı geri bildirimlerden sonra hata yaptım ve hatalarımı düzelttim ve düzelttim.

-1 (boşa) alanını kaybetmek için

-1 soruyu tekrar okumak ve 0'ı hesaba katmamız gerekmediğinin farkına varmak için. İş yerindeki uzun bir günün ardından golf oynamayı bırakmalı.