「ギザ番号」は、口語ではティミー番号とも呼ばれ、数字がピラミッドを表す任意の番号です（A134810）。たとえば、「12321」は次のように視覚化できるため、ギザ番号です。

  3  
 2 2
1   1

ただし、ピラミッドの上部に2桁があるため、「123321」のようなものはギザ番号ではありません

  33  
 2  2
1    1

つまり、次のすべての条件が満たされている場合、数字はギザの数字です。

• 桁数が奇数で、中央の桁が最大です

• それは回文的（同じ読み取り前方または後方）であり、

• 数字の前半は厳密に1ずつ増加しています。（それは回文的でなければならないので、これは数字の後半が厳密に1つ減少しなければならないことを意味します）

入力として正の整数を取る完全なプログラムまたは関数を作成し、それがギザ数であるかどうかを判断する必要があります。入力は文字列または数値として取得できます。それは場合であるギザ番号、出力truthy値。それ以外の場合、偽の値。

合計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なので、標準の抜け穴は禁止されており、バイト単位の最短回答が勝ちです！

パイソン2、48の 47 46バイト

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

Ideoneでテストします。

使い方

Pythonでは、すべての個々の比較が同じ場合にのみ、連鎖比較はTrueを返します。この特定のケースでは、以下の条件がすべて満たされている場合にのみ、ラムダはTrueを返します。

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

  ストリングのための長さの2N + 1、~len(s)/2戻り〜（2N + 1）/ 2 = - （2N + 2）/ 2 = - （N + 1） 、そうs[~len(s)/2:]右端得られるN + 1の文字Sは。

  同様に、文字列の長さの2N、~len(s)/2リターン〜（2N）/ 2 = - （2N + 1）/ 2 = - （N + 1） （分割整数常にラウンドに向かって-∞ので、s[~len(s)/2:]再び右端をもたらすN + sの1文字

  右端のn + 1文字がの部分文字列を形成する場合にのみ、比較はTrueを返します。987654321

  それらがそうであり、sに2n文字がある場合、sは回文ではないことに注意してください。n個^目と（N + 1）^番目の右の文字は、別個になり、後者は、N ^番目の左から文字。

• '987654321'>s

  これは、文字列を辞書式に比較します。以来9で始まるだけギザの数である9、すべてのギザの番号は、この比較を満たしています。

  これらの文字列を比較しても、決定問題の一部にはならないことに注意してください。>sは、よりも3文字短いだけand sです。

• s==s[::-1]

  これは、sが回文である場合にのみTrueを返します。

Perl、39 37 42 39 + 1 = 40バイト

新しい方法を使用して、膨大なバイト数を削減することができました。-nフラグを指定して実行します。実行時に繰り返し入力を受け入れ、それに応じて0または1を出力します。

5バイトを追加する必要がありました。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の文字列を作成することです。したがって、の入力は12321stringを生成し、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回の繰り返しです。したがって、数字から平方を引くと、repdigitを取得すると、元の数字はギザの数字になります。

古いコードと古いメソッド（58 + 1 = 59バイト）

@Dadaのおかげで1バイト節約

-nフラグを指定して実行し、テキストをパイプで使用してecho

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

長さと先頭の整数によって決定される一意のギザ番号を計算し、入力と一致するかどうかを確認します。

ギザ番号​​の場合はecho -n "123454321" | perl -M5.010 -n giza.pl Return as 1、それ以外の場合はnull として実行します。

ゼリー、10 7 6 バイト

9ẆŒBḌċ

45のギザ番号すべてを生成し、メンバーシップをテストします。

オンラインでお試しください！または生成された番号を参照してください。

使い方

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は真実の場合は1桁の文字列を返します。

基本的な考え方は、いくつかのことを確認することです。

• 文字列が1文字の場合、または
• 最初の文字は最後の文字と同じであり、
• 中央セクションはギザ番号でもあり、
• ここで、2番目の文字は最初の文字よりも1つ多くなっています。

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エンコードを使用します。オンラインでお試しください！

パイソン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]))

シンプルな再帰的ソリューション。最初の数字と最後の数字が互いに等しく、2番目の数字が1を引いているかどうかを確認します。次に、中央がギザ番号でもあるかどうかを確認します。1桁に達するとtrueを返します。

1つのバイトは@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を出力し、それ以外の場合は何も出力しません。最後の改行なしで入力して実行します：

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

説明：最初に、s/(.)(?=(.))/$1-$2/ge各数字を$1（に続く$2）に置き換えます$1-$2。ギザ番号​​の場合、各桁の最初の数字が次の数字よりも小さく、最後の数字が1つずつある場合、文字列-1には最初の部分と12番目の部分のみが含まれます（最後の部分は変更されません） 。それの何後半の/^(-1(?1)1|).$/チェックのための：ルックス-1が続く再帰が続きます1。

マーティン・エンダーのおかげで-1バイト。

私の以前のバージョンは15バイト長くなっています（まったく違うので、ここで説明します）。

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

> <> FISH 57 52 49 48バイト

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

編集1：= trueの場合、0または1を返すため、チェックを削除し、この値を使用してインクリメントし、とにかく等価性をチェックします。（6バイトを保存し、改行のために1を失った）。

編集2：3つの方向マーカーを削除し、11をギャップに配置してスタックを偶数長にオフセットし、強制的にfalseにしました（3バイト保存）。

編集3：MODを2とlen（1）でチェックするためにスタックの長さを複製します。これは2回前に長さを置くことで行われましたが、行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のようにミラーリングされた数値の場合はそうでした）。どうやら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番号は1つだけです。

これを知っていると、入力番号の長さに基づいて標準の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"。出力は、真のための正の整数であり、そして0偽のため。

説明：

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'..ij .. 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。入力をデキュー（OK、技術的にはリバーシブルスタック）にプッシュし、両端の等価性を繰り返しテストし、それらが前の値より正確に1つ大きいことを確認することで機能します。

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出力します。

網膜、55 54 36バイト

バイトカウントはISO 8859-1エンコードを前提としています。

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

オンラインで試す

コロンで区切られた各桁を単項に変換します。次の数字がもう1つである場合、一致する外側の数字を削除してループします。残りの1桁と一致します。

PHP、71バイト

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

入力から最大の数字を取得してカウントダウンし、入力と比較文字列が等しくなるか、または$iisになるまで、新しい数字を比較文字列に追加し0ます。

0それ以外の場合、Timmy Numberの最下位桁を出力します。

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）、次に同じ長さ（1つしかない）の正規化されたギザ数を生成し、比較します。

古いソリューション

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では2バイト少なくなります。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;}

Geobitsのおかげで-10バイト。私たちは縛られていた...

オンラインでお試しください！

Perl 6の、43の 34バイト

-9バイトのJo Kingに感謝します。

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

Port of Gabriel BenamyのPerlソリューション。

オンラインでお試しください！

Cjam、35バイト

おそらく非常に準最適です...私は少し練習していません！

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

オンラインでお試しください！

パイソン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つを削除）、後半を逆にしてから2つを比較し、前半を1〜9の文字列と比較します。

編集

仲間のゴルファーから建設的なフィードバックを受け、私の間違いを認識して修正した後に再投稿されました。

-1（スペースの無駄）を失う

質問を再度読み、0を考慮する必要がないことを認識した場合は-1。仕事で長い一日を過ごした後、本当にゴルフを止めなければなりません。