"Angka Giza", juga dikenal dengan sebutan Nomor Timmy adalah angka di mana angka-angka tersebut mewakili piramida ( A134810 ). Misalnya, "12321" adalah angka giza karena dapat divisualisasikan seperti ini:

  3  
 2 2
1   1

Namun, sesuatu seperti "123321" bukan angka Giza karena ada dua digit di bagian atas piramida

  33  
 2  2
1    1

Dengan kata lain, angka adalah angka Giza jika semua kondisi berikut dipenuhi:

• Ini memiliki angka ganjil, dan digit tengah adalah yang terbesar

• Ini palindromic (baca sama maju atau mundur), dan

• Bagian pertama dari digit benar-benar meningkat satu per satu. (Karena itu harus palindromik, ini berarti paruh kedua digit harus dikurangi secara ketat oleh satu)

Anda harus menulis program lengkap atau fungsi yang mengambil bilangan bulat positif sebagai input, dan menentukan apakah itu nomor Giza atau tidak. Anda dapat mengambil input sebagai string atau sebagai angka. Jika adalah sejumlah Giza, output nilai truthy . Jika tidak, nilai palsu.

Ada total 45 angka Giza, jadi salah satu dari input ini harus menghasilkan nilai yang benar:

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

Input lainnya harus memberikan nilai palsu. Tentu saja, Anda tidak harus menangani input yang tidak valid, seperti angka non-positif, non-integer, atau non-angka.

Seperti biasa, ini adalah kode-golf , sehingga celah standar dilarang, dan jawaban terpendek dalam byte menang!

Python 2, 48 47 46 byte

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

Uji di Ideone .

Bagaimana itu bekerja

Dalam Python, perbandingan dirantai mengembalikan Benar jika dan hanya jika semua perbandingan individu melakukan hal yang sama. Dalam kasus khusus ini, lambda kami mengembalikan True jika dan hanya jika semua kondisi berikut ini terpenuhi.

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

  Untuk string s dengan panjang 2n + 1 , ~len(s)/2mengembalikan ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (n +1) , jadi s[~len(s)/2:]menghasilkan n paling tepat 1 karakter dari s .

  Demikian pula, untuk string s dengan panjang 2n , ~len(s)/2menghasilkan ~ (2n) / 2 = - (2n + 1) / 2 = - (n + 1) (divisi integer selalu membulatkan ke -∞ , jadi s[~len(s)/2:]sekali lagi menghasilkan n paling kanan 1 karakter s

  Perbandingan mengembalikan True jika dan hanya jika karakter paling kanan n + 1 membentuk substring 987654321.

  Perhatikan bahwa jika mereka dan s memiliki karakter 2n , s tidak dapat menjadi palindrome; yang n ^th dan (n + 1) ^th karakter dari kanan akan berbeda, dan yang terakhir adalah n ^th karakter dari kiri.

• '987654321'>s

  Ini membandingkan string secara leksikografis. Karena 9 adalah satu-satunya nomor Giza yang dimulai dengan 9 , semua nomor Giza memenuhi perbandingan ini.

  Perhatikan bahwa membandingkan string ini tidak menjadi bagian dari masalah keputusan kami; >shanya tiga karakter lebih pendek dari and s.

• s==s[::-1]

  Ini mengembalikan True jika dan hanya jika s adalah palindrome.

Perl, 39 37 42 39 + 1 = 40 byte

Dengan menggunakan metode baru, saya berhasil mengurangi sejumlah besar byte. Jalankan dengan -nbendera. Menerima input berulang kali saat runtime, mencetak 0 atau 1 yang sesuai.

Saya harus menambahkan 5 byte karena saya sadar tanpa itu, kode berfungsi untuk input seperti 1234567900987654321, yang bukan nomor Giza. Karena angka Giza tidak pernah mengandung angka 0 (dan semua positif palsu karena keperluan akan mengandung angka 0), 5 byte ini bertanggung jawab untuk itu.

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

Penjelasan:

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.

Tujuan dari substitusi pengganti adalah untuk membangun string 1s yang panjangnya setengah panjang input, dibulatkan ke atas. Dengan demikian, input 12321akan menghasilkan string 111, yang kemudian akan dikuadratkan (penjelasan di bawah). Input dengan panjang genap akan menghasilkan string yang terlalu kecil untuk memastikan regex akhir berhasil.

Alasan kode ini bekerja adalah karena hal berikut:

        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

Kita dapat dengan jelas melihat bahwa angka 1 dalam RHS sama dengan 1/2 lebih dari setengah ukuran LHS. (1 lagi jika kita potong). Selain itu:

567898765 - 123454321 = 444444444, yang hanya 4 berulang. Jadi ketika kita mengurangi kuadrat dari nomor kita, jika kita mendapatkan repdigit, nomor asli kita adalah nomor Giza.

Kode lama dan metode lama (58 + 1 = 59 byte)

Disimpan 1 byte berkat @Dada

Jalankan dengan -nbendera, gunakan pipa teksecho

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

Menghitung angka giza unik yang ditentukan oleh panjang dan bilangan bulat terkemuka, dan melihat apakah cocok dengan input.

Jalankan sebagai echo -n "123454321" | perl -M5.010 -n giza.pl Pengembalian 1jika nomor Giza, nol sebaliknya.

Jelly , 10 7 6 byte

9ẆŒBḌċ

Menghasilkan semua 45 nomor nomor Giza, lalu menguji keanggotaan.

Cobalah online! atau lihat nomor yang dihasilkan .

Bagaimana itu bekerja

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

Mengambil input sebagai string dan mengembalikan string satu digit untuk yang benar, 0untuk yang palsu.

Ide dasarnya adalah memeriksa beberapa hal:

• Jika string panjangnya satu karakter, ATAU
• char pertama sama dengan char terakhir, dan
• bagian tengah juga merupakan nomor Giza, dan
• char kedua adalah satu lebih dari char pertama di sini.

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

Tidak ada lagi string! Jadi, sekarang saya mulai dengan menghasilkan 111...sejumlah panjang yang sama dengan input ( a), dan satu lebih pendek ke kotak ( b). Kemudian Anda dapat mengurangi b*bdari input dan memeriksa pembagian dengan a. chanya ada di sana untuk memeriksa ganjil / genap, bayar tidak keberatan> _>

Berputar:

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

Metode Lama, 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;}

Berjalan melalui array, memeriksa perbedaan 1 (atau -1, tergantung pada bagian mana) di antara setiap digit. Kemudian hanya memeriksa untuk melihat panjangnya yang aneh.

Berputar:

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

Truthy is 1 , falsy adalah 0 .

9LŒ€ûJ¹å

Menggunakan pengkodean CP-1252 . Cobalah online!

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

Solusi rekursif sederhana. Cek untuk melihat apakah digit pertama dan terakhir sama satu sama lain dan digit kedua minus satu. Kemudian periksa apakah tengahnya juga nomor Giza. Mengembalikan nilai true setelah turun ke satu digit.

Satu byte disimpan berkat @Rod, satu ton byte yang disimpan berkat DLosc dan ETHProductions!

PowerShell v3 +, 147 108 67 byte

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

Pendekatan yang berubah secara radikal. Menghasilkan semua nomor Giza yang mungkin, dan kemudian memeriksa apakah inputnya $args[0]adalah -inkoleksi itu. Di bawah ini adalah bagaimana koleksi angka Giza terbentuk:

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

Contoh berjalan:

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

Saya tidak sepenuhnya yakin, tapi saya pikir ini berhasil.

Python 2, 68 73 66 byte

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

menyalahgunakan fakta itu 11^2=121, 111^2=12321dan seterusnya, saya menghitung ini dan menambahkan 1111..waktu yang cukup sebagai offset.
Contoh:
23432=111^2+11111*1
676=11^2+111*5

Perl, 41 byte

40 byte kode + -pbendera.

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

Output 1 jika input adalah nomor Giza, tidak ada yang sebaliknya. Masukkan input tanpa baris akhir terakhir untuk menjalankannya:

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

Penjelasan : pertama, s/(.)(?=(.))/$1-$2/geganti setiap digit $1(diikuti oleh $2) oleh $1-$2. Jika itu adalah nomor Giza, maka setiap digit menjadi satu kurang dari yang berikutnya di awal, dan satu lagi di akhir, maka string harus berisi hanya -1di bagian pertama, dan 1di yang kedua (kecuali yang terakhir tidak berubah) . Itulah yang /^(-1(?1)1|).$/diperiksa bagian kedua : mencari -1diikuti oleh rekursi diikuti oleh a 1.

-1 byte terima kasih kepada Martin Ender.

Versi saya sebelumnya 15 byte lebih lama (sangat berbeda jadi saya akan membiarkannya di sini):

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

> <> IKAN 57 52 49 48 byte

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

Sunting 1: = mengembalikan 0 atau 1 jika benar begitu menghapus cek dan menggunakan nilai ini untuk kenaikan, lalu memeriksa kesetaraan setelahnya. (disimpan 6 byte, hilang 1 untuk baris baru).

Sunting 2: 3 marka arah dihilangkan dan 11 ditempatkan pada celah untuk mengimbangi tumpukan hingga panjang genap untuk memaksakan false (3 byte disimpan).,

Sunting 3: Gandakan panjang tumpukan untuk memeriksa MOD dengan 2 dan len (1), ini dilakukan dengan meletakkan panjang dua kali sebelumnya, tetapi ini sekarang mengisi ruang kosong pada baris 2 (disimpan 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;};

Program lengkap dengan beberapa kasus uji:

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

Hore untuk conditional satu baris, sekarang mengalahkan jawaban Java :)! Juga harus menulis komentar menjelaskan pertama saya, meskipun mungkin cukup jelas. Terima kasih kepada @Dada untuk menemukan masalah dengan algoritme saya (berlaku untuk angka yang dicerminkan seperti 13631). Sekarang sub 100 karena tampaknya memeriksa panjang% 2 mubazir.

Bash, 111 byte

MEMPERBARUI

Perhatikan bahwa normalisasi nomor input mungkin dapat dilewati sepenuhnya, jika Anda hanya menambahkan digit pertama kembali ke nomor GIZA yang Anda hasilkan , seperti itu:

01210 + 6 => 67876

dan kemudian bandingkan saja dengan input secara langsung.

Penafian: yang ini tidak benar-benar dioptimalkan, jadi itu lebih merupakan bukti konsep daripada pesaing nyata

Golf

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

Setiap nomor GIZA dapat dinormalisasi ke bentuk kanoniknya, dengan mengurangi digit pertama dari yang lain:

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

dan hanya ada satu nomor GIZA kanonik dengan panjang tertentu.

Mengetahui hal ini kita dapat dengan mudah menghasilkan nomor GIZA kanonik berdasarkan panjang nomor input:

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

kemudian menormalkan nomor input:

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

dan bandingkan

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

Uji

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

Sebenarnya , 22 byte

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

Cobalah online!

Mengambil input sebagai string yang dikutip (mis "12321".). Output adalah bilangan bulat positif untuk true, dan 0untuk false.

Penjelasan:

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

Input diambil sebagai string.

Membuat daftar semua nomor Giza dan memeriksa jika nomor itu ada di dalamnya. Daftar ini dibuat dengan perulangan imelalui '1'..'9'dan kemudian jmelalui '1'..idan membuat elemen 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;

Cobalah online!

Output 1 untuk nomor Giza; 0 sebaliknya. Bekerja dengan mendorong input ke dequeue (ok, secara teknis stack reversibel) dan berulang kali menguji kedua ujung untuk kesetaraan, serta memastikan mereka tepat satu lebih besar dari nilai sebelumnya.

CJam , 20 19 byte

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

Suite uji.

Penjelasan

Ide dasarnya adalah untuk menemukan digit minimum dan maksimum, kemudian buat nomor Giza dari mereka dan kemudian periksa apakah itu setara dengan input.

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.

Alih-alih karakter minimum, kita juga dapat menggunakan karakter pertama, untuk jumlah byte yang sama:

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

Mathematica, 62 61 60 byte

^{Disimpan 2 byte karena @MartinEnder .}

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

Komposisi fungsi. Mengambil angka sebagai input dan mengembalikan Trueatau Falsesebagai output.

Retina, 55 54 36 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

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

Cobalah online

Ubah setiap digit menjadi unary, dipisahkan oleh titik dua. Loop, menghapus digit luar yang cocok jika digit berikutnya adalah satu lagi. Cocokkan satu digit yang tersisa.

PHP, 71 byte

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

mengambil digit terbesar dari input dan menghitung mundur, menambahkan digit baru ke string perbandingan hingga input dan string perbandingan sama - atau $isama 0.

mencetak angka terendah untuk Nomor Timmy, yang 0lain.

Pushy , 30 15 byte

Saya bangun pagi ini dan menyadari bahwa saya dapat setengah dari jawaban saya ...

s&K-kL2/OvhXwx#

_{(non-bersaing sebagai tantangan postdates bahasa)}

Input diberikan pada baris perintah: $ pushy gizas.pshy 3456543. Keluaran 1untuk kebenaran dan 0kepalsuan. Berikut rinciannya:

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 ini terinspirasi oleh jawaban bash: pertama, menormalkan angka, ( 45654 -> 01210), kemudian menghasilkan angka giza yang dinormalisasi dengan panjang yang sama (hanya ada satu), dan membandingkan.

Solusi Lama

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

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

Tidak Disatukan:

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

Pengujian:

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

Keluaran:

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

Java 8, 162 + 19 byte

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

Pendekatan yang berbeda dengan jawaban Java lainnya, saya ingin mencoba dan menggunakan metode membuat semua nomor Timmy yang mungkin dan memeriksa untuk melihat apakah string kami terkandung di dalamnya.

Oktaf, 56 byte

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

Periksa semua kotak uji di sini .

Ini akan menjadi dua byte lebih sedikit di MATLAB, karena diff(n)berfungsi untuk string. Di Octave, Anda perlu diff(+n).

Penjelasan:

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

Ini sedikit lebih pendek:

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

Metode Rekursif Lama, 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 terima kasih kepada Geobits. Kami sedang terikat ...

Cobalah online!

Perl 6 , 43 34 byte

Terima kasih kepada Jo King untuk -9 byte.

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

Solusi Port of Gabriel Benamy's Perl .

Cobalah online!

Cjam, 35 byte

Mungkin sangat suboptimal ... Saya sedikit keluar dari latihan!

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

Cobalah online!

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

Pendekatan sederhana. Pisahkan string menjadi dua (kehilangan karakter tengah atau satu setelah karakter tengah jika panjangnya genap), membalikkan bagian kedua kemudian membandingkan keduanya dan membandingkan bagian pertama dengan string 1 hingga 9.

Edit

Mem-posting ulang setelah umpan balik konstruktif dari sesama pegolf dan menyadari dan memperbaiki kesalahan saya.

-1 untuk kehilangan ruang (buang)

-1 untuk membaca pertanyaan lagi dan menyadari bahwa kita tidak perlu memperhitungkan 0. Benar-benar harus berhenti bermain golf setelah seharian bekerja.