"Число Гізи", також розмовно відоме як Тіммі число, - це будь-яке число, де цифри являють собою піраміду ( A134810 ). Наприклад, "12321" - це число гіза, оскільки його можна візуалізувати так:

  3  
 2 2
1   1

Однак щось на кшталт "123321" - це не число Гізи, оскільки на вершині піраміди є дві цифри

  33  
 2  2
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

Будь-який інший вхід повинен дати хибне значення. Звичайно, вам не доведеться обробляти недійсні введення, наприклад, непозитивні числа, не цілі числа чи не числа.

Як завжди, це код-гольф , тому стандартні лазівки заборонені, а найкоротша відповідь у байтах виграє!

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'

  Для рядка їв довжини 2n + 1 , ~len(s)/2повертає ~ (2n + 1) / 2 = - (2n + 2) / 2 = - (п + 1) , так що s[~len(s)/2:]дає крайній правий п + 1 символів з .

  Аналогічним чином , для рядка сек довжини 2n , ~len(s)/2повертає ~ (2n) / 2 = - (2n + 1) / 2 = - (п + 1) (цілочисельне ділення завжди округлює в сторону -∞ , так що s[~len(s)/2:]ще раз дає крайній правий N + 1 символ s

  Порівняння повертає істинні, якщо і лише у тому випадку, якщо крайній правий n + 1 символів утворює підрядку 987654321.

  Зауважте, що якщо у них і s є 2n символів, s не може бути паліндром; п - ^й і (п + 1) ^й персонажі справа буде різний, а останній є п - ^й символом зліва.

• '987654321'>s

  Це порівнює рядки лексикографічно. Оскільки 9 - це єдине число Гізи, яке починається з 9 , усі цифри Гізи задовольняють це порівняння.

  Зауважте, що порівняння цих рядків не є частиною нашої проблеми рішення; >sпросто на три символи коротше, ніж and s.

• s==s[::-1]

  Це повертає значення True і тоді, і лише тоді, коли s є паліндром.

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.

Призначення регексу заміщення - побудувати рядок у 1s, довжина якого половина довжини вводу, округлена вгору. Таким чином, на вході 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

Ми можемо чітко бачити, що число 1 у РЗС дорівнює 1/2 на половину розміру ЛГС. (Ще 1, якщо ми усікаємо). Додатково:

567898765 - 123454321 = 444444444, що лише 4 повторення. Отже, коли ми віднімаємо свою площу від нашого числа, якщо ми отримуємо відмітку, наш оригінальний номер - це число Гізи.

Старий код та старий метод (58 + 1 = 59 байт)

Збережено 1 байт завдяки @Dada

Виконати з -nпрапором, передати текст у використанніecho

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

Обчислює унікальне число гіза, визначене довжиною та головним цілим числом, і бачить, чи відповідає воно вхідному.

Запустити як echo -n "123454321" | perl -M5.010 -n giza.pl Повертається, 1якщо це номер Гізи, нульове інакше.

Желе , 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

Приймає введення як рядок і повертає одноцифровий рядок для truthy, 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 , фальш - 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]))

Просте рекурсивне рішення. Перевіряє, чи відповідають перші та останні цифри один одному, а друга цифра мінус одна. Потім перевіряє, чи є середина також номером Гізи. Повертає істину, як тільки вона опускається до однієї цифри.

Один байт збережено завдяки @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

Я не зовсім впевнений, але думаю, що це працює.

Пітон 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в другій (крім останньої, що залишилася незмінною) . Ось що /^(-1(?1)1|).$/перевіряє друга частина : шукає -1наступну рекурсію з наступною a 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: = повертає 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
    }
}

Ура за умовні умови для одного рядка, тепер обіграв відповідь Java :)! Також я повинен написати свої перші пояснювальні коментарі, хоча це, мабуть, самопояснення. Дякую @Dada, що знайшов проблему з моїм алгоритмом (це стосується чисел, відображених як 13631). Тепер під 100, оскільки, мабуть, перевірка довжини% 2 є зайвою.

Баш, 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"). Вихід - це додатне ціле число для істинного, і 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

Хаскелл, 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%+=

Математика, 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;

отримує найбільшу цифру від введення та відлічує, додаючи нову цифру до рядка порівняння, поки рядок введення та порівняння не дорівнює - або $iє 0.

друкує найменшу цифру для Timmy Number 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), потім генеруйте нормоване число гіза однакової довжини (є лише одне) та порівняйте.

Старе рішення

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, я хотів спробувати використовувати метод створення всіх можливих номерів Тіммі і перевірити, чи міститься в них наш рядок.

Октава, 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. 

Математика, 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 байт

Завдяки Джо Кінгу за -9 байт.

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

Рішення 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. Дійсно треба припинити гольф після довгого робочого дня.