«Число Гизы», также в разговорной речи известное как номер Тимми, - это любое число, цифры которого представляют пирамиду ( 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,
484746 байтПроверьте это на 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 - палиндром.
источник
Perl,
39374239 + 1 = 40 байтИспользуя новый метод, мне удалось сократить огромное количество байтов. Беги с
-n
флагом. Принимает ввод повторно во время выполнения, печатая 0 или 1 соответственно.Мне пришлось добавить 5 байтов, потому что я понял, что без него код работал для таких входных данных, как 1234567900987654321, который не является числом Гизы. Так как числа Гизы никогда не содержат цифру 0 (и все ложные срабатывания по необходимости будут содержать цифру 0), эти 5 байтов учитывают это.
Объяснение:
Цель регулярного выражения замещения состоит в том, чтобы создать строку из 1 с длиной, равной половине длины ввода, округленной в большую сторону. Таким образом, ввод
12321
будет производить строку111
, которая затем возводится в квадрат (объяснение ниже). Входные данные четной длины будут создавать строки, которые слишком малы, чтобы обеспечить успешное окончательное регулярное выражение.Причина, по которой этот код работает, заключается в следующем:
Мы ясно видим, что число единиц в RHS равно 1/2 больше, чем половина размера LHS. (Еще 1, если мы усекаем). Дополнительно:
567898765 - 123454321 = 444444444, то есть всего 4 повторения. Таким образом, когда мы вычитаем наш квадрат из нашего числа, если мы получаем повторную цифру, наше первоначальное число является числом Гизы.
Старый код и старый метод (58 + 1 = 59 байт)
Сохранено 1 байт благодаря @Dada
Запустить с
-n
флагом, передать текст с помощьюecho
Вычисляет уникальное число Гизы, определяемое длиной и ведущим целым числом, и проверяет, соответствует ли оно вводу.
Run as
echo -n "123454321" | perl -M5.010 -n giza.pl
Возвращает,1
если это число Гизы, иначе ноль.источник
Желе ,
1076 байтГенерирует все 45 чисел Гизы, затем проверяет членство.
Попробуйте онлайн! или посмотрите сгенерированные числа .
Как это работает
источник
JavaScript (ES6),
46454241 байтПринимает входные данные в виде строки и возвращает однозначную строку для истинности,
0
для ложного.Основная идея состоит в том, чтобы проверить несколько вещей:
источник
Java 7,
128 119105 байтНет больше строк! Итак, теперь я начинаю с генерации
111...
числа такой же длины, что и input (a
), и на одну короче квадратной (b
). Затем вы можете вычестьb*b
из ввода и проверить делимость наa
.c
только там, чтобы проверить нечетное / четное, не обращайте внимания> _>Whitespaced:
Старый метод, 119 байт
Просматривает массив, проверяя разницу в 1 (или -1, в зависимости от того, какая половина) между каждой цифрой. Затем просто проверяет, является ли длина нечетной.
Whitespaced:
источник
char[]
учитываются как строка , поэтому я бы сказал, что это правильно.05AB1E ,
98 байтИстина 1 , ложь 0 .
Использует кодировку CP-1252 . Попробуйте онлайн!
источник
2ä¬û¹Q
это сработало бы и сэкономило два байта.Python 2,
77, 76, 64, 63 байтаПростое рекурсивное решение. Проверяет, равны ли первая и последняя цифры друг другу, а вторая - минус один. Затем проверяет, является ли середина также числом Гизы. Возвращает истину, как только становится одной цифрой.
Один байт сохранен благодаря @Rod, тонна байтов сохранена благодаря DLosc и ETHProductions!
источник
len(s)==1
с ,1==len(s)
чтобы сохранить 1 байт на пространстве, а также, чтоand
ей можно было бы заменить ,*
чтобы сохранить 3 байта1or
работает тоже. (Пока это не0
предшествует - тогдаo
Python думает, что это восьмеричное число.)and
с ,*
когда поведение требуется короткое замыкание, так как она находится в рекурсивной функции. Первыйand
должен быть заменяемым, но он требует двух скобок, что сводит на нет любые сбережения. (cc: @Rod)int()
вокругs[0]
или 2) использоватьs[0]==`int(s[1])-1`
?s[-1]==s[0]==`int(s[1])-1`
(требуется Python 2 специально).PowerShell v3 +,
14710867 байтРадикально изменился подход. Генерирует все возможные числа Гизы, а затем проверяет,
$args[0]
является ли ввод-in
этой коллекцией. Ниже показано, как формируется коллекция чисел Гизы:Пример работы:
источник
Python 3, 65 байт
Я не совсем уверен, но я думаю, что это работает.
источник
0
, вы можете удалить это :) Также не будет никаких чисел длиннее 17, которые удовлетворяют этому условию, поэтому вам это тоже не нужно. По сути, это то же решение, что и у Денниса :)Python 2,
687366 байтзлоупотребляя тот факт , что
11^2=121
,111^2=12321
и так далее, я вычислить это и добавить1111..
достаточное количество раз , как смещение.Примеры:
23432=111^2+11111*1
676=11^2+111*5
источник
f
, вам не нужно его называть. Вы можете сохранить два байта, удаливf=
1234567900987654321
возвращает истину, когда он должен быть ложным.Perl, 41 байт
40 байтов кода +
-p
флаги.Выходы 1, если вход представляет собой число Гизы, иначе ничего. Введите ввод без заключительного перевода строки для его запуска:
Пояснения : сначала
s/(.)(?=(.))/$1-$2/ge
замените каждую цифру$1
(затем$2
) на$1-$2
. Если это число Гизы, то каждая цифра на одну единицу меньше следующей в начале и еще на одну в конце, тогда строка должна содержаться только-1
в первой части и1
во второй (кроме последней, оставленной без изменений) , Это то, что/^(-1(?1)1|).$/
проверяет вторая часть : ищет-1
последующую рекурсию с последующим1
.-1 байт благодаря Мартину Эндеру.
Моя предыдущая версия на 15 байт длиннее (совсем по-другому, поэтому я позволю это здесь):
источник
|
второго регулярного выражения.> <> РЫБА
57524948 байтEdit 1: = возвращает 0 или 1, если true, поэтому удалил проверку и использовал это значение для приращения, затем он проверяет равенство после в любом случае. (сохранено 6 байт, потеряно 1 для новой строки).
Редактировать 2: убраны 3 указателя направления и 11 помещены в зазор, чтобы сместить стопку до четной длины, чтобы форсировать ложь (сохранено 3 байта).,
Редактировать 3: Дублируйте длину стека для проверки MOD на 2 и len (1), это было сделано путем помещения длины в два раза раньше, но теперь это заняло пустое место в строке 2 (1 байт сохранен).
источник
C #,
1208610810292 байтаПолная программа с некоторыми тестами:
Ура для однострочных условных выражений, теперь победив Java-ответ :)! Также надо написать мои первые поясняющие комментарии, хотя, вероятно, это говорит само за себя. Спасибо @Dada за нахождение проблемы с моим алгоритмом (было верно для чисел, которые были отражены как 13631). Теперь подпункт 100, так как, очевидно, проверка длины% 2 является излишней.
источник
true
для чисел, как13631
? Кроме того, поскольку вы делаете рекурсивный вызовx
, я думаю, вам нужно включитьx=
в ваш счетчик байтов.Баш, 111 байт
ОБНОВИТЬ
Обратите внимание, что нормализацию входного номера, вероятно, можно полностью пропустить, если вы просто добавите первую цифру обратно к сгенерированному номеру GIZA , например:
а затем просто сравните его с входными данными напрямую.
Отказ от ответственности: этот не очень оптимизирован, так что это скорее доказательство концепции, чем реальный соперник
Golfed
Алгоритм
Любой номер GIZA можно нормализовать до его канонической формы, вычтя его первую цифру из остальных:
и существует только один канонический номер GIZA определенной длины.
Зная это, мы можем легко сгенерировать канонический номер GIZA на основе длины входного номера:
затем нормализуйте введенный номер:
и сравнить
Тест
источник
На самом деле , 22 байта
Попробуйте онлайн!
Принимает ввод в виде строки в кавычках (например,
"12321"
). Вывод является положительным целым числом для истины и0
ложь.Объяснение:
источник
Haskell, 62 байта
Ввод принимается как строка.
Создает список всех номеров Гизы и проверяет, есть ли номер в нем. Список создается с помощью цикла
i
через ,'1'..'9'
а затемj
через'1'..i
и создания элементовj .. i-1 , i , i-1 .. j
.источник
> <> , 62 байта
Попробуйте онлайн!
Выходы 1 для номера Гизы; 0 иначе Работает, помещая входные данные в очередь (нормально, технически обратимый стек) и неоднократно проверяя оба конца на равенство, а также удостоверяясь, что они точно на один больше, чем предыдущее значение.
источник
CJam ,
2019 байтовТестирование.
объяснение
Основная идея состоит в том, чтобы найти минимальную и максимальную цифру, затем создать число Гизы из них и затем проверить, что это эквивалентно вводу.
Вместо минимального символа мы также можем использовать первый символ для того же количества байтов:
источник
Mathematica,
626160 байтСохранено 2 байта благодаря @MartinEnder .
Композиция функций. Принимает число как ввод и возвращает
True
илиFalse
как вывод.источник
Сетчатка,
555436 байтЧисло байтов предполагает кодировку ISO 8859-1.
Попробуйте онлайн
Перевести все цифры в одинарные, разделенные двоеточиями. Цикл, удаляя соответствующие внешние цифры, если следующая цифра - еще одна. Совпадение с одной оставшейся цифрой.
источник
12312
PHP, 71 байт
извлекает наибольшую цифру из ввода и ведет обратный отсчет, добавляя новую цифру в строку сравнения до тех пор, пока строка ввода и строка сравнения не станут равными или не
$i
станет0
.печатает самую младшую цифру для номера Тимми,
0
иначе.источник
Напористый ,
3015 байтЯ проснулся этим утром и понял, что мог бы на половину длины моего ответа ...
(неконкурентоспособен как вызов языковых постдатов)
Ввод задается в командной строке:
$ pushy gizas.pshy 3456543
. Выходы1
для правдивых и0
ложных. Вот разбивка:Алгоритм был основан на ответе bash: сначала нормализуйте число (
45654 -> 01210
), затем сгенерируйте нормализованное число Гизы той же длины (есть только один) и сравните.Старое решение
источник
Ракетка 292 байта
Ungolfed:
Тестирование:
Выход:
источник
Java 8, 162 + 19 байт
19 для
import java.util.*;
Другой подход к другому ответу на Java, я хотел попробовать использовать метод создания всех возможных чисел Тимми и проверить, не содержится ли в них наша строка.
источник
Октава, 56 байт
Проверьте все контрольные примеры здесь .
Это было бы на два байта меньше в MATLAB, так как
diff(n)
работает для строк. В Октаве вам нужноdiff(+n)
.Объяснение:
источник
Mathematica, 56 байт
Это немного короче:
источник
Java 7,
129 119109 байтСтарый рекурсивный метод, 119
-10 байтов благодаря Geobits. Мы
вбыли связаны ...Попробуйте онлайн!
источник
and
, я думаю, что вы использовали его один раз, но не в другой раз? Или я читаю это неправильно.java.util.Arrays.copyOfRange(...)
пропустив строку импорта.Perl 6 ,
4334 байтаСпасибо Джо Кингу за -9 байт.
Порт решения Perl Габриэля Бенами .
Попробуйте онлайн!
источник
Cjam, 35 байт
Наверное, очень неоптимальный ... Я немного не на практике!
Попробуйте онлайн!
источник
Python 2,
50828180 байтПростой подход Просто разбивает строку пополам (пропуская средний символ или один после среднего символа, если он имеет четную длину), переворачивает вторую половину, затем сравнивает два и сравнивает первую половину со строкой от 1 до 9.
редактировать
Перемещено после конструктивной обратной связи с другими игроками в гольф и осознания и исправления моих ошибок.
-1 за потерю пространства
-1 за повторное чтение вопроса и понимание того, что нам не нужно принимать во внимание 0. Действительно должен прекратить играть в гольф после долгого рабочего дня.
источник
13531
и6543456
оба неверно возвращают True.'0'
и'1'
оба правдивы.