Боже, Гиза Гольф!

41

«Число Гизы», также в разговорной речи известное как номер Тимми, - это любое число, цифры которого представляют пирамиду ( 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

Любой другой вход должен давать ложное значение. Конечно, вам не нужно обрабатывать недействительные входные данные, такие как неположительные числа, нецелые числа или не числа.

Как обычно, это , поэтому стандартные лазейки запрещены, и выигрывает самый короткий ответ в байтах!

DJMcMayhem
источник
как насчет 0? это правда?
Tuskiomi
@tuskiomi Технически, нет, но это не имеет значения, потому что вам не нужно обрабатывать неположительные числа.
DJMcMayhem
1
Причина , почему я спрашиваю, потому что если он это число Гиза, то число , как 1210, 123210 и т.д. также будет truthy.
Tuskiomi
5
@tuskiomi Ни один из них не является палиндромным или нечетным числом цифр. Если вы не считаете ведущий 0, но это все усложняет.
DJMcMayhem
1
@ nedla2004 Я думаю, что начальные 0 усложняют форматы ввода. Чтобы все было просто и понятно, мы скажем, что вы можете предположить, что входные данные не будут содержать начальные 0.
DJMcMayhem

Ответы:

30

Python 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 = - (п + 1) , так что s[~len(s)/2:]дает крайний правый п + 1 символов с .

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

    Сравнение возвращает True тогда и только тогда, когда самые правые n + 1 символов образуют подстроку 987654321.

    Обратите внимание, что если они имеют и s имеет 2n символов, s не может быть палиндромом; п - й и (п + 1) й персонажи справа будет различен, а последний является п - й символом слева.

  • '987654321'>s

    Это сравнивает строки лексикографически. Поскольку 9 - единственное число Гизы, которое начинается с 9 , все числа Гизы удовлетворяют этому сравнению.

    Обратите внимание, что сравнение этих строк не является частью нашей проблемы решения; >sпросто три символа короче and s.

  • s==s[::-1]

    Возвращает True тогда и только тогда, когда s - палиндром.

Деннис
источник
8
Этот ответ - безумное волшебство. Я понимаю, как все это работает, но даже не могу понять, как ты это сделал. И на мгновение я гордился своими 64. +1
DJMcMayhem
2
я люблю гарантированное сравнение, чтобы сохранить эти 3 байта
greyShift
22

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/2 больше, чем половина размера LHS. (Еще 1, если мы усекаем). Дополнительно:

567898765 - 123454321 = 444444444, то есть всего 4 повторения. Таким образом, когда мы вычитаем наш квадрат из нашего числа, если мы получаем повторную цифру, наше первоначальное число является числом Гизы.

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

Сохранено 1 байт благодаря @Dada

Запустить с -nфлагом, передать текст с помощьюecho

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

Вычисляет уникальное число Гизы, определяемое длиной и ведущим целым числом, и проверяет, соответствует ли оно вводу.

Run as echo -n "123454321" | perl -M5.010 -n giza.pl Возвращает, 1если это число Гизы, иначе ноль.

Габриэль Бенами
источник
2
Это прекрасное наблюдение для второго метода.
трихоплакс
15

Желе , 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.
Деннис
источник
10

JavaScript (ES6), 46 45 42 41 байт

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

Принимает входные данные в виде строки и возвращает однозначную строку для истинности, 0для ложного.

Основная идея состоит в том, чтобы проверить несколько вещей:

  • Если строка длиной в один символ, ИЛИ
  • первый символ совпадает с последним символом, и
  • средняя часть также является числом Гизы, и
  • второй символ здесь на один больше, чем первый.
ETHproductions
источник
Извините, я неправильно понял вопрос.
Нил
10

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...числа такой же длины, что и input ( a), и на одну короче квадратной ( b). Затем вы можете вычесть b*bиз ввода и проверить делимость на a. cтолько там, чтобы проверить нечетное / четное, не обращайте внимания> _>

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;
}
Geobits
источник
Зачем вам нужно проверять, совпадает ли первое с последним?
Натан Меррилл
3
Понятия
Это правильный ответ, учитывая, что проблема указывает, что функция должна принимать положительное целое число? Конечно, массив символов может представлять собой положительное целое число, но я думаю, что это важное различие.
Hypino
1
@ Hypino Проблема в том, что входные данные могут быть приняты как строка или целое число, и здесь они char[] учитываются как строка , поэтому я бы сказал, что это правильно.
Geobits
@Geobits Ах, я пропустил ту часть, в которой говорилось, что это можно воспринимать как String.
Hypino
6

05AB1E , 9 8 байт

Истина 1 , ложь 0 .

9LŒ€ûJ¹å

Использует кодировку CP-1252 . Попробуйте онлайн!

Аднан
источник
Я думаю, что 2ä¬û¹Qэто сработало бы и сэкономило два байта.
Osable
@Osable 12521 не является числом Гизы, это не подходит для среднего элемента.
Волшебная Осьминог Урна
Теперь я понимаю, что пропустил третий пункт (последовательные цифры). Не берите в голову!
Osable
Ааааа ... Я использовал префиксы, я буду помнить подстроки для будущих усилий, аккуратный небольшой взлом.
Волшебная Урна Осьминога
6

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!

DJMcMayhem
источник
вы можете поменять местами len(s)==1с , 1==len(s)чтобы сохранить 1 байт на пространстве, а также, что andей можно было бы заменить , *чтобы сохранить 3 байта
Rod
Просто чтобы добавить к комментарию Род: 1orработает тоже. (Пока это не 0предшествует - тогда oPython думает, что это восьмеричное число.)
DLosc
1
Как правило , вы не можете заменить andс , *когда поведение требуется короткое замыкание, так как она находится в рекурсивной функции. Первый andдолжен быть заменяемым, но он требует двух скобок, что сводит на нет любые сбережения. (cc: @Rod)
DLosc
1
Я не знаю много Python, но вы могли бы 1) удалить int()вокруг s[0]или 2) использовать s[0]==`int(s[1])-1` ?
ETHproductions
1
Основываясь на предложении @ETHproductions: s[-1]==s[0]==`int(s[1])-1`(требуется Python 2 специально).
DLosc
6

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
AdmBorkBork
источник
108 -> 67 ... похоже, что вы выиграли в этот раз (и, вероятно, большую часть времени): P
Йодль
5

Python 3, 65 байт

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

Я не совсем уверен, но я думаю, что это работает.

0WJYxW9FMN
источник
1
Там нет номеров Гизы, которые начинаются с 0, вы можете удалить это :) Также не будет никаких чисел длиннее 17, которые удовлетворяют этому условию, поэтому вам это тоже не нужно. По сути, это то же решение, что и у Денниса :)
Kade
@Shebang, но этот был опубликован первым ...
Род
@ Род Я не утверждал, что он скопировал или что-нибудь :)
Kade
@Shebang Я тоже с:
Род
5

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

прут
источник
Поскольку вы не звоните f, вам не нужно его называть. Вы можете сохранить два байта, удаливf=
DJMcMayhem
Вы должны установить ограничение на это. Ввод 1234567900987654321возвращает истину, когда он должен быть ложным.
Geobits
@ Geobits ooops, исправлено (наверное?)
Род
4

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последующую рекурсию с последующим1 .

-1 байт благодаря Мартину Эндеру.


Моя предыдущая версия на 15 байт длиннее (совсем по-другому, поэтому я позволю это здесь):

echo -n '123456787654321' | perl -F -pe '$\=$_ eq reverse;$\&=$F[$_-1]+1==$F[$_]for 1..@F/2}{'
папа
источник
Единственная часть этого я не понимаю, это цель |второго регулярного выражения.
Габриэль Бенами
@GabrielBenamy Это базовый случай рекурсивного блока (т. Е. Он ничего не соответствует и останавливает рекурсию).
Дада
3

> <> РЫБА 57 52 49 48 байт

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

Edit 1: = возвращает 0 или 1, если true, поэтому удалил проверку и использовал это значение для приращения, затем он проверяет равенство после в любом случае. (сохранено 6 байт, потеряно 1 для новой строки).

Редактировать 2: убраны 3 указателя направления и 11 помещены в зазор, чтобы сместить стопку до четной длины, чтобы форсировать ложь (сохранено 3 байта).,

Редактировать 3: Дублируйте длину стека для проверки MOD на 2 и len (1), это было сделано путем помещения длины в два раза раньше, но теперь это заняло пустое место в строке 2 (1 байт сохранен).

Чирок пеликан
источник
3

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 является излишней.

Yodle
источник
1
Разве это не вернется trueдля чисел, как 13631? Кроме того, поскольку вы делаете рекурсивный вызов x, я думаю, вам нужно включить x=в ваш счетчик байтов.
Дада
@ Dada Хех, хорошо, знал, что я что-то упустил ... И ладно, я добавлю их в счет.
Йодле
Подожди, ты бьешь что сейчас? ;)
Geobits
@Geobits Dangit! Я посмотрю, что я могу сделать завтра: P
Yodle
3

Баш, 111 байт

ОБНОВИТЬ

Обратите внимание, что нормализацию входного номера, вероятно, можно полностью пропустить, если вы просто добавите первую цифру обратно к сгенерированному номеру GIZA , например:

01210 + 6 => 67876

а затем просто сравните его с входными данными напрямую.

Отказ от ответственности: этот не очень оптимизирован, так что это скорее доказательство концепции, чем реальный соперник

Golfed

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
дирижабль
источник
Надеюсь, вы не возражаете, я реализовал часть этого алгоритма в своем ответе :)
FlipTack
1

На самом деле , 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
Mego
источник
1

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.

Ними
источник
1

> <> , 62 байта

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

Попробуйте онлайн!

Выходы 1 для номера Гизы; 0 иначе Работает, помещая входные данные в очередь (нормально, технически обратимый стек) и неоднократно проверяя оба конца на равенство, а также удостоверяясь, что они точно на один больше, чем предыдущее значение.

Брайан Градин
источник
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%+=
Мартин Эндер
источник
1

Mathematica, 62 61 60 байт

Сохранено 2 байта благодаря @MartinEnder .

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

Композиция функций. Принимает число как ввод и возвращает Trueили Falseкак вывод.

LegionMammal978
источник
1

Сетчатка, 55 54 36 байт

Число байтов предполагает кодировку ISO 8859-1.

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

Попробуйте онлайн

Перевести все цифры в одинарные, разделенные двоеточиями. Цикл, удаляя соответствующие внешние цифры, если следующая цифра - еще одна. Совпадение с одной оставшейся цифрой.

mbomb007
источник
1
Это принимает12312
Мартин Эндер
1

PHP, 71 байт

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

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

печатает самую младшую цифру для номера Тимми, 0иначе.

Titus
источник
1

Напористый , 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#
FlipTack
источник
1

Ракетка 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
rnso
источник
1

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

Xanderhall
источник
1

Октава, 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. 
Стьюи Гриффин
источник
1

Mathematica, 56 байт

Это немного короче:

MatchQ[Differences@IntegerDigits@#,{a:1...,b__}/;b==-a]&
Келли Лоудер
источник
1

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. Мы в были связаны ...

Попробуйте онлайн!

совать
источник
Я думаю, что вы могли бы сэкономить 1 байт поразрядно and, я думаю, что вы использовали его один раз, но не в другой раз? Или я читаю это неправильно.
Йодль
@Yodle Я использовал его только один раз, потому что мне нужно короткое замыкание для первого условия.
Ткните
1
Похоже, что вы используете импорт только один раз, поэтому вы можете сократить его, java.util.Arrays.copyOfRange(...)пропустив строку импорта.
Geobits
@Geobits хороший улов ... Я сумасшедший
Poke
0

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

ElPedro
источник
1
Это не проверяет, строго ли увеличивается число на единицу. Например, 13531и 6543456оба неверно возвращают True.
DJMcMayhem
1
Кроме того, строки '0'и '1'оба правдивы.
Деннис
Совершенно верно. Это был долгий день. Будут удалены как недействительные.
ElPedro
4
Спасибо за комментарии, а не просто за голосование.
ElPedro