“吉萨数”（俗称“ 蒂米数”）是指数字代表金字塔的任何数字（A134810）。例如，“ 12321”是一个吉萨数字，因为它可以像这样可视化：

  3  
 2 2
1   1

但是，“ 123321”之类的字符不是吉萨币，因为金字塔的顶部有两位数字

  33  
 2  2
1    1

换句话说，如果满足以下所有条件，则数字为吉萨数：

• 它的位数是奇数，中间的数字是最大的

• 它是回文的（相同的向前或向后读取），并且

• 数字的前半部分严格增加一个。（由于必须是回文，这意味着数字的后半部分必须严格减少一位）

您必须编写一个采用正整数作为输入的完整程序或函数，并确定它是否为吉萨数。您可以将输入作为字符串或数字。如果它是吉萨数，则输出真实值。否则，将产生虚假的值。

共有45个吉萨数字，因此这些输入中的任何一个都应产生真实值：

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

任何其他输入都应给出虚假值。当然，您不必处理无效的输入，例如非正数，非整数或非数字。

像往常一样，这是code-golf，因此禁止了标准漏洞，以字节为单位的最短答案为胜！

Python 2，48 47 46字节

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

在Ideone上进行测试。

这个怎么运作

在Python中，当且仅当所有单个比较都相同时，链式比较才返回True。在此特定情况下，当且仅当满足以下所有条件时，我们的lambda 才会返回True。

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

  对于长度为2n +1的字符串s，返回〜（2n +1）/ 2 =-（2n + 2）/ 2 =-（n +1），因此产生s的最右边n +1个字符。~len(s)/2s[~len(s)/2:]

  类似地，对于长度为2n的字符串s，返回〜（2n）/ 2 =-（2n + 1）/ 2 =-（n + 1）（整数除法始终朝-∞取整，因此再次产生最右边的n + 1个的字符小号~len(s)/2s[~len(s)/2:]

  当且仅当最右边的n +1个字符形成的子字符串时，比较才会返回True。987654321

  请注意，如果他们这样做并且s具有2n个字符，则s不能是回文；的Ñ ^个和第（n + 1）^个从右侧的字符将是不同的，而后者是Ñ ^个从左侧字符。

• '987654321'>s

  这按字典顺序比较了字符串。由于9是唯一以9开头的吉萨数，因此所有吉萨数都满足此比较。

  请注意，比较这些字符串并不构成我们决策问题的一部分；>s比and s。短三个字符。

• s==s[::-1]

  当且仅当s是回文时，它返回True。

Perl，39 37 42 39 +1 = 40字节

使用一种新方法，我设法减少了大量字节。与-n标志一起运行。在运行时反复接受输入，相应地打印0或1。

我必须添加5个字节，因为我意识到没有它，该代码适用于1234567900987654321之类的输入，这不是吉萨编号。由于吉萨棉数字永远不会包含数字0（并且所有假阳性必然会包含数字0），因此这5个字节说明了这一点。

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

说明：

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.

替换正则表达式的目的是构造一个1的字符串，其长度是输入长度的一半，四舍五入。因此，输入12321会产生字符串111，然后将其平方（下面的解释）。偶数长度的输入将产生的字符串太小，无法确保最终的正则表达式成功。

该代码起作用的原因是由于以下原因：

        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中1的数目等于LHS大小的一半的1/2以上。（如果我们截断则再多1个）。另外：

567898765-123454321 = 444444444，仅重复4次。因此，当我们从数字中减去平方时，如果得到一个位数，则原始数字为吉萨数。

旧代码和旧方法（58 +1 = 59字节）

@Dada节省了1个字节

运行带有-n标志的管道，使用echo

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

计算由长度和前导整数确定的唯一吉萨棉编号，并查看它是否与输入匹配。

如果它是Giza编号，则作为echo -n "123454321" | perl -M5.010 -n giza.pl Return 运行1，否则返回null。

果冻，10 7 6 个字节

9ẆŒBḌċ

生成所有45个Giza号码，然后测试成员资格。

在线尝试！或查看生成的数字。

这个怎么运作

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字节

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

将输入作为字符串，并为真0和伪造返回一位数字的字符串。

基本思想是检查一些事情：

• 如果字符串是一个字符长，或者
• 第一个字符与最后一个字符相同，并且
• 中间部分也是吉萨号码，并且
• 第二个字符比第一个字符多一个。

Java 7中，128个119 105字节

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

没有更多的字符串！因此，现在我开始生成111...与输入（a）相同长度的数字，而短于平方（b）的数字。然后，您可以b*b从输入中减去并通过检查除数a。c只是在那里检查奇数/偶数，不用担心> _>

空格：

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

旧方法，119字节

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

遍历数组，检查每个数字之间的差是否为1（或-1，取决于哪一半）。然后只是检查看看长度是奇数。

空格：

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字节

Truthy是1，falsy是0。

9LŒ€ûJ¹å

使用CP-1252编码。在线尝试！

Python 2中，77，76，64，63个字节

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

一个简单的递归解决方案。检查第一个数字和最后一个数字是否相等，第二个数字是否减一。然后检查中间是否也是吉萨数。一旦下降到一位数，则返回true。

一个字节保存感谢@Rod，一吨的字节保存感谢DLosc和ETHProductions！

PowerShell的V3 +，147个 108 67字节

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

彻底改变的方法。生成所有可能的吉萨数，然后检查输入$args[0]是否-in为该集合。以下是吉萨数集合的形成方式：

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

示例运行：

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个字节

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

我不确定，但我认为这可行。

Python 2，68 73 66字节

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

滥用事实11^2=121，111^2=12321依此类推，我对此进行了计算并添加了1111..足够的时间作为偏移量。
例子：
23432=111^2+11111*1
676=11^2+111*5

Perl，41个字节

40个字节的代码+ -p标志。

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

如果输入为吉萨数，则输出1，否则为0。提供输入而无需最终换行符即可运行它：

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

说明：首先，s/(.)(?=(.))/$1-$2/ge用替换每个数字$1（后跟$2）$1-$2。如果它是吉萨（Giza）数字，则每个数字的开头比下一个数字少一个，而末尾的每个数字都多一个，那么该字符串应仅包含-1在第一部分中，而1在第二部分中（最后一个保留不变） 。那就是第二部分要/^(-1(?1)1|).$/检查的内容：查找，-1然后递归，然后是1。

-1字节感谢Martin Ender。

我以前的版本长15个字节（完全不同，所以我在这里放）：

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

> <>鱼57 52 49 48字节

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

编辑1：=如果为true，则返回0或1，因此删除了检查并使用了该值进行递增，然后无论如何都会检查相等性。（保存6个字节，新行丢失1个字节）。

编辑2：删除了3个方向标记，并在间隙中放置了11个标记，以使堆栈偏移到均匀的长度，以强制错误（节省3个字节）。

编辑3：将用于检查MOD的堆栈长度复制2和len（1），这是通过在以前将长度加倍两次来完成的，但是现在它在第2行填充了一个空白空间（节省了1个字节）。

C＃，120个 86 108 102 92字节

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

完整的程序和一些测试用例：

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

Hooray用于单行条件，现在击败了Java答案:)！还得写我的第一个解释性评论，尽管这可能是自我解释。感谢@Dada发现我的算法有问题（对于镜像为13631的数字来说确实如此）。现在sub 100因为显然检查length％2是多余的。

Bash，111个字节

更新

请注意，如果您只是将第一个数字加回到生成的GIZA编号中，则可以完全跳过输入编号规范化，如下所示：

01210 + 6 => 67876

然后直接将其与输入进行比较。

免责声明： 这不是一个真正的优化，所以它比真正的竞争者更能证明概念

打高尔夫球

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}

算法

可以将任何GIZA数字标准化为其规范形式，方法是将其第一个数字减去其余数字：

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

并且只有一个特定长度的规范GIZA编号。

知道这一点，我们可以根据输入的数字长度轻松生成规范的GIZA数字：

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

然后标准化输入数字：

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

并比较

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

测试

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

其实 22个位元组

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

在线尝试！

将输入作为带引号的字符串（例如"12321"）。对于true和0false ，输出是一个正整数。

说明：

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个字节

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

输入被视为字符串。

创建所有吉萨棉数字的列表，并检查数字是否在其中。由循环创建的列表中i通过'1'..'9'，然后j通过'1'..i和创造的元素j .. i-1 , i , i-1 .. j。

> <>，62字节

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

在线尝试！

输出1的吉萨编号；否则为0。通过将输入推入出队（正常情况下，是可逆堆栈）并反复测试两端的相等性，并确保它们比以前的值大一个，来工作。

CJam，20 19字节

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

测试套件。

说明

基本思想是找到最小和最大数字，然后从这些数字中创建一个吉萨数，然后检查其是否等于输入。

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.

除了相同的字节数，我们还可以使用第一个字符来代替最小字符：

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

Mathematica，62 61 60字节

^{由于@MartinEnder而节省了2个字节。}

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

功能组成。将数字作为输入并返回True或False作为输出。

Retina，55 54 36字节

字节数假定为ISO 8859-1编码。

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

在线尝试

将每个数字转换为一元，用冒号分隔。循环播放，如果下一个数字再多一位，则删除匹配的外数字。匹配一个剩余的数字。

PHP，71字节

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

从输入中获取最大数字并递减计数，然后将新数字添加到比较字符串中，直到输入和比较字符串相等-或$i为0。

打印Timmy编号的最低数字，0否则。

Pushy，30 15字节

我今天早上醒来，意识到我可以把答案的长度缩短一半。

s&K-kL2/OvhXwx#

_{（不竞争作为语言发布日期挑战）}

输入在命令行上给出$ pushy gizas.pshy 3456543。输出1为真和0为假。细目如下：

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

该算法受到bash答案的启发：首先，将数字（45654 -> 01210）归一化，然后生成相同长度（只有一个）的归一化giza数，然后进行比较。

旧解决方案

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

拍子292字节

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

取消高尔夫：

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

测试：

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

输出：

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

Java 8，162 + 19字节

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

对于其他Java答案，采用不同的方法，我想尝试使用创建所有可能的Timmy数字并检查是否包含我们的字符串的方法。

八度，56字节

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

在此处查看所有测试用例。

由于diff(n)适用于字符串，因此在MATLAB中将少两个字节。在Octave中，您需要diff(+n)。

说明：

@(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个字节

这要短一点：

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

Java 7中，129个119 109字节

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

旧的递归方法，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字节归功于Geobits。我们都被捆绑...

在线尝试！

Perl 6的，43个 34字节

感谢Jo King的-9个字节。

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

Gabriel Benamy的Perl解决方案端口。

在线尝试！

Cjam，35个字节

可能不是很理想...我有点不习惯了！

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

在线尝试！

Python 2中，50个 82 81 80字节

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

简单的方法。只需将字符串分成两半（如果中间字符长度相等，则省略中间字符或中间字符后一个），反转后半部分，然后将两者进行比较，并将前半部分与1到9的字符串进行比较。

编辑

在得到高尔夫球友的建设性反馈并意识到并纠正我的错误后，重新发布了帖子。

-1（用于浪费空间）

-1表示再次阅读问题并意识到我们不需要考虑0。漫长的一天工作后，真的必须停止打高尔夫球。