"Số Giza", còn được gọi chung là Số Timmy là bất kỳ số nào trong đó các chữ số đại diện cho một kim tự tháp ( A134810 ). Ví dụ: "12321" là số giza vì nó có thể được hiển thị như thế này:

  3  
 2 2
1   1

Tuy nhiên, một cái gì đó như "123321" không phải là số Giza vì có hai chữ số ở trên cùng của kim tự tháp

  33  
 2  2
1    1

Nói cách khác, một số là một số Giza nếu đáp ứng tất cả các điều kiện sau:

• Nó có số chữ số lẻ và chữ số trung tâm là lớn nhất

• Đó là palindromic (cùng đọc tiến hoặc lùi) và

• Nửa đầu của các chữ số đang tăng nghiêm ngặt một. (Vì nó phải là palindromic, điều này có nghĩa là nửa sau của các chữ số phải được giảm một cách nghiêm ngặt)

Bạn phải viết một chương trình đầy đủ hoặc một hàm lấy số nguyên dương làm đầu vào và xác định xem đó có phải là số Giza hay không. Bạn có thể lấy đầu vào dưới dạng chuỗi hoặc số. Nếu đó là số Giza, hãy xuất giá trị trung thực . Nếu không, một giá trị giả.

Có tổng cộng 45 số Giza, do đó, bất kỳ một trong những đầu vào này sẽ dẫn đến một giá trị trung thực:

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

Bất kỳ đầu vào khác sẽ cung cấp một giá trị giả. Tất nhiên, bạn không phải xử lý các đầu vào không hợp lệ, chẳng hạn như số không dương, số không hoặc số không.

Như thường lệ, đây là môn đánh gôn , vì vậy các sơ hở tiêu chuẩn bị cấm và câu trả lời ngắn nhất trong byte sẽ thắng!

Python 2, 48 47 46 byte

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

Kiểm tra nó trên Ideone .

Làm thế nào nó hoạt động

Trong Python, một phép so sánh được trả về True khi và chỉ khi tất cả các phép so sánh riêng lẻ làm như vậy. Trong trường hợp cụ thể này, lambda của chúng tôi trả về True khi và chỉ khi tất cả các điều kiện sau được đáp ứng.

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

  Đối với một chuỗi s có độ dài 2n + 1 , ~len(s)/2trả về ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n + 1) , do đó s[~len(s)/2:]mang lại n + 1 ký tự bên phải của s .

  Tương tự, đối với một chuỗi s có độ dài 2n , ~len(s)/2trả về ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (phép chia số nguyên luôn làm tròn về phía -∞ , do đó, s[~len(s)/2:]một lần nữa sẽ mang lại n + ngoài cùng bên phải 1 ký tự của s

  So sánh trả về True khi và chỉ khi các ký tự n + 1 ngoài cùng bên phải tạo thành một chuỗi con của 987654321.

  Lưu ý rằng nếu chúng làm và s có 2n ký tự, s không thể là một bảng màu; các n ^th và (n + 1) ^{lần thứ} ký tự từ bên phải sẽ rõ rệt, và sau này là n ^thứ nhân vật từ bên trái.

• '987654321'>s

  Điều này so sánh các chuỗi từ vựng. Vì 9 là số Giza duy nhất bắt đầu bằng 9 , nên tất cả các số Giza đều thỏa mãn so sánh này.

  Lưu ý rằng so sánh các chuỗi này không phải là một phần của vấn đề quyết định của chúng tôi; >schỉ đơn giản là ba ký tự ngắn hơn and s.

• s==s[::-1]

  Điều này trả về True khi và chỉ khi s là một palindrom.

Perl, 39 37 42 39 + 1 = 40 byte

Sử dụng một phương thức mới, tôi đã quản lý để cắt giảm một số lượng lớn byte. Chạy với -ncờ. Chấp nhận đầu vào nhiều lần trong thời gian chạy, in 0 hoặc 1 tương ứng.

Tôi đã phải thêm 5 byte vì tôi nhận ra rằng không có nó, mã làm việc cho các đầu vào như 1234567900987654321, không phải là số Giza. Vì các số Giza không bao giờ chứa chữ số 0 (và tất cả các số dương sai do sự cần thiết sẽ chứa chữ số 0), 5 byte này chiếm tài khoản đó.

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

Giải trình:

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.

Mục đích của biểu thức thay thế là xây dựng chuỗi 1s có độ dài bằng một nửa chiều dài của đầu vào, được làm tròn lên. Do đó, một đầu vào của 12321sẽ tạo ra chuỗi 111, sau đó được bình phương (giải thích bên dưới). Các đầu vào có độ dài chẵn sẽ tạo ra các chuỗi quá nhỏ để đảm bảo regex cuối cùng thành công.

Lý do mã này hoạt động là vì những điều sau đây:

        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

Chúng ta có thể thấy rõ rằng số 1 trong RHS bằng 1/2 hơn một nửa kích thước của LHS. (1 thêm nếu chúng tôi cắt ngắn). Ngoài ra:

567898765 - 123454321 = 444444444, chỉ 4 lần lặp lại. Vì vậy, khi chúng tôi trừ đi hình vuông của chúng tôi từ số của chúng tôi, nếu chúng tôi nhận được một chữ số, số ban đầu của chúng tôi là một số Giza.

Mã cũ và phương thức cũ (58 + 1 = 59 byte)

Đã lưu 1 byte nhờ @Dada

Chạy với -ncờ, văn bản ống trong sử dụngecho

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

Tính số giza duy nhất được xác định bởi độ dài và số nguyên đầu và xem nó có khớp với đầu vào không.

Chạy dưới dạng echo -n "123454321" | perl -M5.010 -n giza.pl Trả về 1nếu đó là số Giza, nếu không.

Thạch , 10 7 6 byte

9ẆŒBḌċ

Tạo tất cả 45 số Giza, sau đó kiểm tra tư cách thành viên.

Hãy thử trực tuyến! hoặc xem các số được tạo .

Làm thế nào nó hoạt động

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

Lấy đầu vào dưới dạng một chuỗi và trả về một chuỗi một chữ số cho sự thật, 0cho sai.

Ý tưởng cơ bản là kiểm tra một vài thứ:

• Nếu chuỗi dài một ký tự, HOẶC
• char đầu tiên giống như char cuối cùng, và
• phần giữa cũng là số Giza và
• char thứ hai là một char nhiều hơn char đầu tiên ở đây.

Java 7, 128 119 105 byte

boolean t(long n){long a=1,b=1,c=0;for(;a<n/10;b=b*b<=n/10?b*10+1:b,c^=1)a=a*10+1;return(n-b*b)%a<1&c<1;}

Không còn chuỗi! Vì vậy, bây giờ tôi bắt đầu bằng cách tạo một 111...số có cùng độ dài với đầu vào ( a) và một số ngắn hơn thành hình vuông ( b). Sau đó, bạn có thể trừ đi b*bđầu vào và kiểm tra tính phân chia bằng cách a. cchỉ ở đó để kiểm tra lẻ / chẵn, không cần bận tâm> _>

Đánh trắng:

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

Phương thức cũ, 119 byte

boolean g(char[]a){int i=1,l=a.length,b=1,d;for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)d=a[i]-a[i-1];return b>0?l%2>0:0>1;}

Đi qua mảng, kiểm tra sự khác biệt 1 (hoặc -1, tùy thuộc vào một nửa) giữa mỗi chữ số. Sau đó chỉ cần kiểm tra để xem chiều dài là số lẻ.

Đánh trắng:

boolean g(char[]a){
    int i=1,l=a.length,b=1,d;
    for(;i<l;b*=i++>l/2?d==-1?1:0:d==1?1:0)
        d=a[i]-a[i-1];
    return b>0?l%2>0:0>1;
}

05AB1E , 9 8 byte

Sự thật là 1 , giả là 0 .

9LŒ€ûJ¹å

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến!

Python 2, 77, 76, 64 , 63 byte

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

Một giải pháp đệ quy đơn giản. Kiểm tra xem các chữ số đầu tiên và cuối cùng có bằng nhau và chữ số thứ hai trừ đi một chữ số không. Sau đó kiểm tra xem giữa có phải là số Giza không. Trả về true khi nó xuống một chữ số.

Một byte được lưu nhờ @Rod, một tấn byte được lưu nhờ DLosc và ETH Productstions!

PowerShell v3 +, 147 108 67 byte

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

Cách tiếp cận thay đổi hoàn toàn. Tạo tất cả các số Giza có thể, và sau đó kiểm tra xem đầu vào $args[0]có phải là -inbộ sưu tập đó không. Dưới đây là cách tập hợp các số Giza được hình thành:

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

Ví dụ chạy:

PS C:\Tools\Scripts\golfing> 12321,5678765,121,4,123321,1232,5678,13631|%{"$_ --> "+(.\giza-numbers.ps1 "$_")}
12321 --> True
5678765 --> True
121 --> True
4 --> True
123321 --> False
1232 --> False
5678 --> False
13631 --> False

Python 3, 65 byte

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

Tôi không hoàn toàn chắc chắn, nhưng tôi nghĩ rằng điều này hoạt động.

Python 2, 68 73 66 byte

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

lạm dụng thực tế 11^2=121, 111^2=12321và như vậy, tôi tính toán điều này và thêm 1111..đủ số lần là bù.
Ví dụ:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 byte

40 byte mã + -pcờ.

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

Đầu ra 1 nếu đầu vào là số Giza, không có gì khác. Cung cấp đầu vào mà không có dòng mới cuối cùng để chạy nó:

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

Giải thích : đầu tiên, s/(.)(?=(.))/$1-$2/gethay thế từng chữ số $1(tiếp theo $2) bằng $1-$2. Nếu đó là số Giza, thì mỗi chữ số nhỏ hơn một chữ số tiếp theo ở đầu và một chữ số cuối cùng, thì chuỗi chỉ nên chứa -1trong phần đầu tiên và 1trong phần thứ hai (ngoại trừ phần cuối không thay đổi) . Rằng những gì phần thứ hai /^(-1(?1)1|).$/kiểm tra: ngoại hình cho một -1tiếp theo đệ quy theo sau là một 1.

-1 byte nhờ Martin Ender.

Phiên bản trước của tôi dài hơn 15 byte (khá khác nhau nên tôi sẽ để nó ở đây):

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

> <> CÁ 57 52 49 48 byte

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

Chỉnh sửa 1: = trả về 0 hoặc 1 nếu đúng vì vậy đã xóa một kiểm tra và sử dụng giá trị này để tăng, sau đó nó sẽ kiểm tra sự bằng nhau sau đó. (đã lưu 6 byte, mất 1 cho dòng mới).

Chỉnh sửa 2: 3 đánh dấu hướng được loại bỏ và 11 được đặt vào khoảng trống để bù cho ngăn xếp thành một chiều dài chẵn để buộc sai (lưu 3 byte).,

Chỉnh sửa 3: Sao y chiều dài của ngăn xếp để kiểm tra MOD bằng 2 và len (1), điều này được thực hiện bằng cách đặt độ dài lên hai lần trước nhưng giờ đây đã lấp đầy một khoảng trống trên dòng 2 (đã lưu 1 byte).

C #, 120 86 108 102 92 byte

x=I=>{var Z=I.Length;return Z<2?1>0:I[0]==I[Z-1]&I[1]-0==I[0]+1?x(I.Substring(1,Z-2)):0>1;};

Chương trình đầy đủ với một số trường hợp thử nghiệm:

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

Hoan hô cho các điều kiện dòng đơn, bây giờ đánh bại câu trả lời Java :)! Cũng phải viết bình luận giải thích đầu tiên của tôi, mặc dù nó có thể tự giải thích. Cảm ơn @Dada vì đã tìm ra vấn đề với thuật toán của tôi (đúng với các số được nhân đôi như 13631). Bây giờ phụ 100 vì rõ ràng việc kiểm tra độ dài% 2 là không cần thiết.

Bash, 111 byte

CẬP NHẬT

Lưu ý rằng có thể bỏ hoàn toàn chuẩn hóa số đầu vào, nếu bạn chỉ cần thêm chữ số đầu tiên trở lại số GIZA đã tạo , như thế:

01210 + 6 => 67876

và sau đó chỉ cần so sánh nó với đầu vào trực tiếp.

Disclaimer: cái này không thực sự được tối ưu hóa, vì vậy nó là một bằng chứng về khái niệm hơn là một ứng cử viên thực sự

Chơi gôn

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}

Thuật toán

Bất kỳ số GIZA nào cũng có thể được chuẩn hóa thành dạng chính tắc của nó, bằng cách trừ chữ số đầu tiên của nó khỏi phần còn lại:

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

và chỉ có một số GIZA chính tắc có độ dài cụ thể.

Biết được điều này, chúng ta có thể dễ dàng tạo ra số GIZA chuẩn dựa trên độ dài số đầu vào:

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

sau đó bình thường hóa số đầu vào:

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

và so sánh

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

Kiểm tra

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

Trên thực tế , 22 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng một chuỗi trích dẫn (ví dụ "12321"). Đầu ra là một số nguyên dương cho đúng và 0sai.

Giải trình:

9uR;∙`xR;RdX+εj`M;░#íu
9uR;∙                   cartesian product of [1,2,3,4,5,6,7,8,9,10] with itself
     `xR;RdX+εj`M       for each pair:
      x                   construct the half-open (end-exclusive) range ([1, 5] -> [1, 2, 3, 4])
       R                  reverse
        ;RdX+             duplicate, reverse, remove first element, prepend ([1, 2, 3, 4] -> [1, 2, 3, 4, 3, 2, 1])
             εj           concatenate into a string
                 ;░     filter out empty strings
                   #íu  test for membership

Haskell, 62 byte

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

Đầu vào được lấy dưới dạng một chuỗi.

Tạo một danh sách tất cả các số Giza một kiểm tra nếu số đó nằm trong đó. Danh sách được tạo bằng cách lặp iqua '1'..'9'và sau đó jthông qua '1'..ivà tạo các phần tử j .. i-1 , i , i-1 .. j.

> <> , 62 byte

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

Hãy thử trực tuyến!

Đầu ra 1 cho số Giza; 0 khác. Hoạt động bằng cách đẩy đầu vào vào một dequeue (ok, về mặt kỹ thuật là một ngăn xếp có thể đảo ngược) và liên tục kiểm tra cả hai đầu để tìm sự bằng nhau, cũng như đảm bảo rằng chúng chính xác hơn một giá trị lớn hơn giá trị trước đó.

CJam , 20 19 byte

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

Bộ thử nghiệm.

Giải trình

Ý tưởng cơ bản là tìm chữ số tối thiểu và tối đa, sau đó tạo số Giza từ số đó và sau đó kiểm tra xem nó có tương đương với đầu vào không.

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.

Thay vì ký tự tối thiểu, chúng ta cũng có thể sử dụng ký tự đầu tiên, cho cùng một số byte:

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

Toán học, 62 61 60 byte

^{Đã lưu 2 byte do @MartinEnder .}

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

Thành phần của các chức năng. Lấy một số làm đầu vào và trả về Truehoặc Falselà đầu ra.

Võng mạc, 55 54 36 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Dùng thử trực tuyến

Chuyển đổi từng chữ số thành unary, cách nhau bằng dấu hai chấm. Lặp lại, loại bỏ các chữ số bên ngoài phù hợp nếu chữ số tiếp theo là một chữ số nữa. Ghép một chữ số còn lại.

PHP, 71 byte

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

tìm nạp chữ số lớn nhất từ ​​đầu vào và đếm ngược, thêm chữ số mới vào chuỗi so sánh cho đến khi chuỗi đầu vào và chuỗi so sánh bằng nhau - hoặc $ilà 0.

in chữ số thấp nhất cho số Timmy, 0khác.

Đẩy , 30 15 byte

Tôi thức dậy sáng nay và nhận ra tôi có thể giảm một nửa câu trả lời của mình ...

s&K-kL2/OvhXwx#

_{(không cạnh tranh như thách thức ngôn ngữ postdates)}

Đầu vào được đưa ra trên dòng lệnh : $ pushy gizas.pshy 3456543. Đầu ra 1cho sự thật và giả 0. Đây là sự cố:

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

Thuật toán được lấy cảm hứng từ câu trả lời bash: đầu tiên, chuẩn hóa số, ( 45654 -> 01210), sau đó tạo số giza được chuẩn hóa có cùng độ dài (chỉ có một) và so sánh.

Giải pháp cũ

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

Vợt 292 byte

(let*((s(number->string n))(sn string->number)(st string)(lr list-ref)(sl(string->list s))(g(λ(i)(-(sn(st(lr sl(add1 i))))
(sn(st(lr sl i)))))))(cond[(even?(string-length s))#f][(not(equal? s(list->string(reverse sl))))#f][(andmap identity
(for/list((i(floor(/(length sl)2))))(= 1(g i))))]))

Ung dung:

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

Kiểm tra:

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

Đầu ra:

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

Java 8, 162 + 19 byte

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

Cách tiếp cận khác nhau đối với câu trả lời Java khác, tôi muốn thử và sử dụng phương pháp tạo tất cả các số Timmy có thể và kiểm tra xem chuỗi của chúng tôi có được chứa trong chúng không.

Octave, 56 byte

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

Kiểm tra tất cả các trường hợp thử nghiệm ở đây .

Đây sẽ là hai byte ít hơn trong MATLAB, vì diff(n)hoạt động cho chuỗi. Trong Octave, bạn cần diff(+n).

Giải trình:

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

Toán học, 56 byte

Cái này ngắn hơn một chút:

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

Java 7, 129 119 109 byte

boolean e(char[]a){int l=a[0]-1,f=0,b=a.length-1;for(;f<b&&a[f]==++l&a[f++]==a[b--];);return f==b&l==a[b]-1;}

Phương pháp đệ quy cũ, 119

boolean b(char[]a){int b=a.length;return b>1&&a[0]==a[b-1]&a[0]+1==a[1]?b(java.util.Arrays.copyOfRange(a,1,b-1)):b==1;}

-10 byte nhờ Geobits. Chúng tôi đang bị trói ...

Hãy thử trực tuyến!

Perl 6 , 43 34 byte

Cảm ơn Jo King cho -9 byte.

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

Giải pháp Perl của cảng Gabriel Benamy .

Hãy thử trực tuyến!

Cjam, 35 byte

Có lẽ là rất tối ưu ... Tôi hơi mất tập luyện!

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

Hãy thử trực tuyến!

Python 2, 50 82 81 80 byte

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

Cách tiếp cận đơn giản. Chỉ cần tách một nửa chuỗi (bỏ lỡ ký tự giữa hoặc một ký tự sau ký tự giữa nếu nó có độ dài chẵn), đảo ngược nửa thứ hai sau đó so sánh hai và so sánh nửa đầu với một chuỗi từ 1 đến 9.

Biên tập

Đăng lại sau phản hồi mang tính xây dựng từ những người chơi golf và nhận ra và sửa chữa sai lầm của tôi.

-1 vì mất một không gian (lãng phí)

-1 để đọc lại câu hỏi và nhận ra rằng chúng ta không cần phải tính đến 0. Thực sự phải dừng chơi golf sau một ngày dài làm việc.