"หมายเลข Giza" หรือที่รู้จักกันเรียกขานว่าTimmy Numberคือหมายเลขใด ๆ ที่ตัวเลขแสดงถึงปิรามิด ( A134810 ) ตัวอย่างเช่น "12321" เป็นหมายเลข giza เพราะสามารถมองเห็นเป็นดังนี้:

  3  
 2 2
1   1

อย่างไรก็ตามบางอย่างเช่น "123321" ไม่ใช่หมายเลขกิซ่าเพราะมีสองหลักที่ด้านบนของปิรามิด

  33  
 2  2
1    1

กล่าวอีกนัยหนึ่งตัวเลขคือหมายเลข Giza หากตรงตามเงื่อนไขต่อไปนี้ทั้งหมด:

• มีเลขคี่เป็นเลขหลักสำคัญและเลขกลางนั้นใหญ่ที่สุด

• มันเป็น Palindromic (อ่านไปข้างหน้าหรือข้างหลังเดียวกัน) และ

• ในช่วงครึ่งแรกของตัวเลขจะเพิ่มขึ้นอย่างเข้มงวดโดยหนึ่ง (เนื่องจากต้องเป็น palindromic นี่หมายความว่าครึ่งหลังของตัวเลขจะต้องลดลงอย่างเข้มงวดโดยหนึ่ง)

คุณต้องเขียนโปรแกรมเต็มรูปแบบหรือฟังก์ชั่นที่ใช้จำนวนเต็มบวกเป็นอินพุตและตรวจสอบว่าเป็นหมายเลข Giza หรือไม่ คุณอาจรับอินพุตเป็นสตริงหรือเป็นตัวเลขก็ได้ หากเป็นหมายเลข Giza ให้ส่งออกค่าจริง มิฉะนั้นค่าเท็จ

มีหมายเลขกิซ่าทั้งหมด 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

อินพุตอื่นใดควรให้ค่าที่ผิดพลาด แน่นอนคุณไม่ต้องจัดการกับอินพุตที่ไม่ถูกต้องเช่นตัวเลขที่ไม่ใช่บวก, ไม่ใช่จำนวนเต็มหรือไม่ใช่ตัวเลข

ตามปกตินี่คือโค้ดกอล์ฟดังนั้นช่องโหว่มาตรฐานจึงถูกแบนและคำตอบที่สั้นที่สุดในการชนะไบต์!

Python 2, 48 47 46 ไบต์

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

ทดสอบบนIdeone

มันทำงานอย่างไร

ใน Python การเปรียบเทียบแบบลูกโซ่จะคืนค่าTrueถ้าหากการเปรียบเทียบแบบเดี่ยวทั้งหมดทำแบบเดียวกัน ในกรณีเฉพาะนี้แลมบ์ดาของเราจะคืนค่าเป็นจริงหากตรงตามเงื่อนไขต่อไปนี้ทั้งหมดเท่านั้น

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

  สำหรับสตริงs ที่มีความยาว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 1ตัวอักษรของs

  การเปรียบเทียบผลตอบแทนที่แท้จริงและถ้าหากขวาสุด1 + n987654321ตัวอักษรรูปแบบย่อยของ

  โปรดทราบว่าหากพวกเขาทำและsมีตัวอักษร2n , sไม่สามารถเป็นแบบสีเดียวได้; n ^THและ(n + 1) ^{วันที่}ตัวละครจากขวาจะมีความแตกต่างและหลังเป็นn ^THตัวอักษรจากทางด้านซ้าย

• '987654321'>s

  สิ่งนี้เปรียบเทียบสตริงตามพจนานุกรม เนื่องจาก9เป็นหมายเลข Giza เดียวที่ขึ้นต้นด้วย9หมายเลข Giza ทั้งหมดจะเป็นไปตามการเปรียบเทียบนี้

  โปรดทราบว่าการเปรียบเทียบสตริงเหล่านี้ไม่ได้เป็นส่วนหนึ่งของปัญหาการตัดสินใจของเรา เป็นเพียงตัวละครทั้งสามที่สั้นกว่า>sand s

• s==s[::-1]

  สิ่งนี้จะคืนค่าเป็นTrueถ้าหากsเป็นแบบ palindrome

Perl, 39 37 42 39 + 1 = 40 ไบต์

ด้วยวิธีการใหม่ฉันจัดการเพื่อลดจำนวนไบต์ขนาดใหญ่ วิ่งด้วย-nธง ยอมรับอินพุตซ้ำ ๆ ณ รันไทม์โดยพิมพ์ 0 หรือ 1 ตามลำดับ

ฉันต้องเพิ่ม 5 ไบต์เพราะฉันรู้ว่าไม่มีรหัสทำงานสำหรับอินพุตเช่น 1234567900987654321 ซึ่งไม่ใช่ตัวเลข Giza เนื่องจากตัวเลข Giza ไม่เคยมีตัวเลข 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.

วัตถุประสงค์ของการทดแทน regex คือการสร้างสตริงของ 1s ซึ่งความยาวครึ่งหนึ่งของความยาวของอินพุตถูกปัดขึ้น ดังนั้นการป้อนข้อมูลของ12321จะผลิตสตริง111ซึ่งจากนั้นจะได้รับกำลังสอง (คำอธิบายด้านล่าง) อินพุตที่มีความยาวเท่ากันจะสร้างสตริงที่เล็กเกินไปที่จะทำให้แน่ใจว่า regex สุดท้ายนั้นจะประสบความสำเร็จ

สาเหตุที่รหัสนี้ใช้งานได้เนื่องจากสาเหตุดังต่อไปนี้:

        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

เราสามารถเห็นได้อย่างชัดเจนว่าจำนวนของ 1 ใน RHS เท่ากับ 1/2 มากกว่าครึ่งหนึ่งของขนาด LHS (อีก 1 ถ้าเราตัดทอน) นอกจากนี้:

567898765 - 123454321 = 444444444 ซึ่งเป็นเพียง 4 ซ้ำ ดังนั้นเมื่อเราลบสแควร์ของเราจากหมายเลขของเราถ้าเราได้ repdigit หมายเลขเดิมของเราคือหมายเลข Giza

รหัสเก่าและวิธีเก่า (58 + 1 = 59 ไบต์)

บันทึก 1 ไบต์ขอบคุณ @Dada

เรียกใช้ด้วย-nแฟล็กข้อความไพพ์ในการใช้echo

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

คำนวณหมายเลข giza ที่ไม่ซ้ำกันซึ่งกำหนดโดยความยาวและจำนวนเต็มนำและดูว่าตรงกับอินพุตหรือไม่

เรียกใช้เป็นecho -n "123454321" | perl -M5.010 -n giza.pl ผลตอบแทน1หากเป็นหมายเลข Giza เป็นอย่างอื่น

เยลลี่ , 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สำหรับเท็จ

แนวคิดพื้นฐานคือการตรวจสอบบางสิ่ง:

• ถ้าสตริงมีความยาวหนึ่งอักขระหรือ
• ถ่านตัวแรกนั้นเหมือนกับถ่านตัวสุดท้ายและ
• ส่วนตรงกลางยังเป็นหมายเลข Giza และ
• ถ่านตัวที่สองเป็นมากกว่าถ่านตัวแรกที่นี่

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 อยู่ตรงนั้นเพื่อตรวจสอบคี่ / คู่ไม่ต้องจ่ายเงินเลย> _>ac

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

วิธีเก่า 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 ขึ้นอยู่กับว่าครึ่งใด) ระหว่างแต่ละหลัก จากนั้นเพียงตรวจสอบเพื่อดูความยาวคี่

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 ไบต์

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

โซลูชันแบบเรียกซ้ำง่าย ๆ ตรวจสอบเพื่อดูว่าตัวเลขตัวแรกและตัวสุดท้ายมีค่าเท่ากันและตัวเลขที่สองเป็นลบ จากนั้นตรวจสอบว่าตรงกลางเป็นหมายเลข Giza ด้วยหรือไม่ ผลตอบแทนจริงเมื่อมันลงไปที่ตัวเลขหนึ่งหลัก

หนึ่งไบต์ได้รับการบันทึกด้วย @Rod จำนวนตันที่บันทึกได้ด้วย DLosc และ ETHProductions!

PowerShell v3 +, 147 108 67 ไบต์

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

วิธีการเปลี่ยนแปลงอย่างรุนแรง สร้างหมายเลข Giza ที่เป็นไปได้ทั้งหมดแล้วตรวจสอบว่าอินพุต$args[0]นั้นเป็น-inชุดสะสมหรือไม่ ด้านล่างนี้เป็นวิธีการรวบรวมตัวเลข 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

ตัวอย่างการทำงาน:

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 หากอินพุตเป็นหมายเลข Giza ไม่มีอะไรเป็นอย่างอื่น จัดหาอินพุตโดยไม่ขึ้นบรรทัดใหม่เพื่อรัน:

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

> <> FISH 57 52 49 48 ไบต์

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

แก้ไข 1: = ส่งคืน 0 หรือ 1 ถ้าเป็นจริงเอาการตรวจสอบออกและใช้ค่านี้เพื่อเพิ่มขึ้นจากนั้นจะตรวจสอบความเท่าเทียมกันหลังจากนั้น (บันทึก 6 ไบต์และหายไป 1 รายการสำหรับบรรทัดใหม่)

แก้ไข 2: 3 markers directions ถูกลบและ 11 วางลงในช่องว่างเพื่อชดเชย stack ให้มีความยาวเท่ากันเพื่อบังคับ false (บันทึก 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
    }
}

ไชโยสำหรับเงื่อนไขบรรทัดเดียวตอนนี้เต้นคำตอบ Java :)! นอกจากนี้ยังต้องเขียนความเห็นครั้งแรกของฉันอธิบายแม้ว่ามันอาจจะอธิบายด้วยตนเอง ขอบคุณ @Dada สำหรับการค้นหาปัญหาเกี่ยวกับอัลกอริทึมของฉัน (เป็นจริงสำหรับตัวเลขที่ทำมิเรอร์เช่น 13631) ตอนนี้ sub 100 เนื่องจากเห็นได้ชัดว่าการตรวจสอบความยาว% 2 ซ้ำซ้อน

Bash, 111 ไบต์

UPDATE

โปรดทราบว่าการปรับมาตรฐานหมายเลขอินพุตสามารถข้ามได้อย่างสมบูรณ์หากคุณเพียงเพิ่มตัวเลขแรกกลับไปที่หมายเลข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") เอาท์พุทเป็นจำนวนเต็มบวกสำหรับจริงและ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]])

อินพุตถูกใช้เป็นสตริง

สร้างรายการหมายเลข Giza ทั้งหมดที่จะตรวจสอบว่ามีหมายเลขนั้นอยู่หรือไม่ รายการจะสร้างขึ้นโดยการวนลูป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 สำหรับหมายเลข Giza; 0 มิฉะนั้น ทำงานโดยการกดอินพุตลงใน dequeue (ตกลง, เป็นสแต็กที่สามารถย้อนกลับได้ทางเทคนิค) และทดสอบซ้ำทั้งสองด้านเพื่อความเท่าเทียมเช่นเดียวกับตรวจสอบให้แน่ใจว่ามันมีขนาดใหญ่กว่าค่าก่อนหน้าอย่างแน่นอน

CJam , 20 19 ไบต์

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

ชุดทดสอบ

คำอธิบาย

แนวคิดพื้นฐานคือการหาตัวเลขต่ำสุดและสูงสุดแล้วสร้างหมายเลข Giza จากนั้นตรวจสอบว่ามันเทียบเท่ากับการป้อนข้อมูล

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 ไบต์

^{ที่บันทึกไว้ 2 ไบต์เนื่องจาก@MartinEnder}

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

องค์ประกอบของฟังก์ชั่น ใช้ตัวเลขเป็นอินพุตและส่งคืนTrueหรือFalseเป็นเอาต์พุต

เรติน่า, 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;

เรียกหลักที่ใหญ่ที่สุดจากการป้อนข้อมูลและนับลงเพิ่มหลักใหม่เพื่อเปรียบเทียบสตริงจนเข้าและสตริงเปรียบเทียบมีค่าเท่ากัน - หรือเป็น $i0

พิมพ์ตัวเลขที่ต่ำที่สุดสำหรับจำนวนทิม0อื่น

รุก , 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))))]))

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

การทดสอบ:

(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

ตรวจสอบกรณีทดสอบทั้งหมดที่นี่

นี่จะน้อยกว่าสองไบต์ใน MATLAB เนื่องจากdiff(n)ทำงานเพื่อสตริง 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/²:}

พอร์ตของกาเบรียล Benamy ทางออก

ลองออนไลน์!

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 จริงๆต้องหยุดเล่นกอล์ฟหลังจากวันที่ยาวนานในที่ทำงาน