Лестничные номера

29

Лестничный номер представляет собой положительное целое число x, такое, что его n- тая цифра (одна индексированная, начиная с наименьшей значащей цифры) равна x% (n + 1) . Это немного глоток, поэтому давайте посмотрим на пример. Возьмем 7211311 , если мы возьмем модульные остатки 7211311 в диапазоне 2-8, мы получим следующее:

7211311 % 2 = 1
7211311 % 3 = 1
7211311 % 4 = 3
7211311 % 5 = 1
7211311 % 6 = 1
7211311 % 7 = 2
7211311 % 8 = 7

Это цифры 7211311 ! Таким образом, 7211311 - это номер лестницы.

задача

Записать код, который принимает, когда в качестве входных данных задано положительное число, будут выводиться два различных значения: одно, если число является числом лестницы, и другое, если это не так.

Это соревнование по коду-гольфу, поэтому ваша цель должна заключаться в том, чтобы минимизировать количество байтов в исходном коде.

Тестовые случаи

Вот первые 13 номеров лестниц:

1, 10, 20, 1101, 1121, 11311, 31101, 40210, 340210, 4620020, 5431101, 7211311, 12040210
code-golf  number  decision-problem 
— Мастер пшеницы
источник
Не 0лестница номер? Многие ответы так считают.
— Okx
3
@ Хорошо, задача состоит в том, чтобы просто отличить положительные числа лестниц от положительных не лестничных чисел, поэтому поведение не определено для 0 и отрицательных чисел.
— Пауло Эберманн

Ответы:

10

Хаскелл, 55 57 байт

f m|let n#x=n==0||n`mod`10==m`mod`x&&div n 10#(x+1)=m#2

Другой подход, чем другое решение Haskell.

Спасибо xnor за сохранение 2 байта.

— Сильвио Майоло
источник
4
Вы можете использовать этот совет, чтобы сократить letвыражение.
— xnor
Другой, более короткий подход. Отлично сработано! +1
— qfwfq
7

Javascript, 42 41 39 38 байт

-4 байта благодаря @Shaggy и @ETHProductions

s=>[...s].some(d=>s%i++^d,i=~s.length)

Это берет число как строку и возвращает, falseесли число является числом лестницы и trueиначе.

Пример кода:

f=
s=>[...s].some(d=>s%i++^d,i=~s.length)

function update() {
  o.innerText = f(document.getElementById("i").value)
}
<input id="i" type="number">
<button onclick="update()">Test</button>
<p id="o">
Развернуть фрагмент

— Герман Л
источник
2
Вы должны быть в состоянии отбросить, !поскольку в задаче явно не указано, что вы должны возвращать значения truetrue и falsefalse, просто вы должны вернуть 2 разных значения.
— Лохматый
2
Это очень хорошо, хорошо сделано. Я думаю, что вы сможете выжать еще два байта, если подсчитаете iсами:s=>[...s].some(d=>s%i--^d,i=s.length+1)
— ETHproductions
2
На самом деле, используя тот факт, что ~x == -(x+1)на целых числах и x%-y == x%y, я думаю, вы можете получить еще один:s=>[...s].some(d=>s%i++^d,i=~s.length)
— ETHproductions
6

05AB1E , 6 байтов

Код:

ā>%JRQ

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

Объяснение:

ā        # Get the range [1 .. len(input)]
 >       # Increment by 1
  %      # Vectorized modulo
   J     # Join the array into a single number
    RQ   # Reverse that number and check if it's equal to the original input
— Аднан
источник
6

Haskell, 60 байт

Принимает число как int

x n|s<-show n=reverse s==(rem n.(+1)<$>[1..length s]>>=show)
— qfwfq
источник
5

Mathematica, 60 байт

FromDigits@Reverse@Mod[#,Range@Length@IntegerDigits@#+1]==#&

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

@alephalpha сыграл в гольф до 48

Mathematica, 48 байтов

FromDigits@Reverse@Mod[#,Range[2,Log10@#+2]]==#&

следующий 24120020

— J42161217
источник
5

Джапт , 9 7 байт

Принимает ввод в виде строки.

¥£%´JÃw

Попробуй это

  • 2 байта сохранены с помощью ETHproductions.

объяснение

Мы неявно принимаем строку в качестве входных данных.

£   Ã

Карта каждого символа в строке.

´J

Jявляется константой Japt -1и ´уменьшает ее на 1 при каждом проходе ( --в JavaScript). Итак, на первом проходе это дает нам -2.

%

Мы используем это значение для выполнения операции по модулю над входной строкой, которая автоматически преобразуется в процесс в целое число. В JavaScript x%-yдает тот же результат, что и x%y.

w

Переверните полученную строку.

¥

Проверьте, совпадает ли новая строка с исходным вводом и неявно выведите результат как логическое значение.

— мохнатый
источник
Черт возьми (Y+2, я чувствую, что это может быть как минимум на 1 байт короче ...
— ETHproductions
1
... и это может: ¥£%´JÃw:-) (потому что работает x%y == x%-yв JS)
— ETHproductions
Ага, да, пытался несколько разных вещей, чтобы уменьшить этот расчет до 2 байтов.
— Лохматый
4

Нейм , 6 байт

𝐧ᛖ𝕄𝐫𝐣𝔼

Объяснение:

𝐧         Get the length of the input, then create an exclusive range
 ᛖ        Add 2 to each element
  𝕄       Modulus
    𝐫      Reverse
     𝐣     Join
      𝔼   Check for equality

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

— Okx
источник
@Thehx Что касается вашего редактирования, Neim использует пользовательскую кодировку: вот эта
— Okx
2

Perl 6 , 32 байта

{$_ eq[~] $_ «%«(1+.comb...2)}

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

  • .combэто количество символов в строковом представлении входного аргумента $_(то есть количество цифр).
  • 1 + .comb ... 2 последовательность чисел от одного больше, чем количество цифр до 2.
  • «%«представляет собой модуль hyperoperator , что дает остаток , когда $_, входной аргумент на его слева, делится на каждый из элементов последовательности на своем праве: $_ % 2, $_ % 3, ....
  • [~]объединяет эти цифры в новое число, которое сравнивается с входным аргументом с помощью оператора равенства строк eq.
— Шон
источник
2

Pyth , 13 байт

-1 байт благодаря Okx .

qsjk_m%QhdSl`

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

объяснение

             QQ    # Implicit input
          Sl`Q     # Generate [1, len(str(Q))]
     m%Qhd         # For digit d in above range, perform Q % (d + 1)
 sjk_              # Reverse, then convert to number
q             Q    # Test equality with input

Альтернативное решение , все еще 13 байт (благодаря карлкастору )

qi_.e%Q+2k`QT

Попробуйте онлайн! По сути, это то же самое, что и первое решение, за исключением того, что оно используется iдля преобразования массива чисел в число, а диапазон генерируется по-разному.

— Джим
источник
1
Вы можете заменить ss`M_на, jk_чтобы сохранить 2 байта.
— Okx
@Okx Мне это нужно, потому что jвыводит строку, а мне нужно число для сравнения с входом (это число).
— Джим
1
Другим 13-байтовым решением было бы qi_.e%Q+2k`QTиспользование перечислимой map ( .e) вместо map. И преобразование остатков в базу 10 int из списка вместо использования соединения.
— КарлКастор
2

C ++, 104 байта

1) оригинальная версия:

int main(){int N,T,R=1;cin>>N;T=N;for(int i=1;i<=log10(N)+1;i++){if(N%(i+1)!=T%10){R=0;}T/=10;}cout<<R;}

2) в читаемой форме:

int main()
{
    int N, T, R = 1;

    cin >> N;
    T = N;

    for (int i = 1; i <= log10(N) + 1; i++)
    {
        if (N % (i + 1) != T % 10)
        {
            R = 0;
        }

        T /= 10;
    }

    cout << R;
}

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

— koita_pisw_sou
источник
1

Python 2 , 66 60 58 57 байт

  • Благодаря @Leaky монахине за 6 байтов: удалите ненужные x and(не должны проверять на 0)
  • Спасибо @Einkorn Enchanter за 1 байт: использование enumerate
lambda x:all(a==`x%(i+2)`for i,a in enumerate(`x`[::-1]))

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

— officialaimm
источник
1
— Волшебник пшеницы
Спасибо. И, эй, я только что понял, что ты волшебник пшеницы ..: D
— officialaimm
1

Python 3: 63 байта

lambda m:all(int(x)==m%(n+2)for n,x in enumerate(str(m)[::-1]))

Если бы я мог посчитать, сколько раз я хотел, чтобы «перечисление» было короче ...

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

— Bendl
источник
Да, и я только что понял, что это точно так же, как ответ @officialaimm ... Должен ли я удалить?
— Бендл
Они в Python 2, и вы придумали его самостоятельно, поэтому я бы оставил его.
— Пшеничный волшебник
Можно сохранить два байта, начав перечисление с 2 и переставив логическое: lambda m:all(m%n==int(x)for n,x in enumerate(str(m)[::-1],2))
— nocturama
1

Java 8, 156 149 байт

interface B{static void main(String[]s){String f="";for(int i=1;i<=s[0].length();)f=new Long(s[0])%++i+f;System.out.print(f.equals(s[0]));}}

Ungolfed:

interface B {
    static void main(String[] s) {
        String f = "";
        for (int i = 1; i <= s[0].length();)
            f = new Long(s[0]) % ++i + f;
        System.out.print(f.equals(s[0]));
    }
}

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

ОБНОВЛЕНИЕ:
-7 байт : удалено бесполезно {}и заменено Integer.parseInt(...)на new Integer(...)
-9 байт : благодаря Кевину Круйссену удалено множество бесполезных (), используемых Longвместо Integerи printвместо println. Спасибо, Кевин!

— Алекс Ферретти
источник
1
Хороший ответ, +1 от меня. Кстати, некоторые мелочи в гольф: new Integerможет быть new Long(-3 байта); printlnможет быть print(-2 байта); и вы можете удалить круглые скобки new Long(s[0])%i+f;(-4 байта).
— Кевин Круйссен
Действительно мило ! Спасибо, я обновлю это!
— Алекс Ферретти
0

q / kdb +, 34 байта

Решение:

{s~raze($)x mod'2+(|)(!)(#)s:($)x}

Пример:

q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211311 / this is a staircase number (true)
1b
q){s~raze($)x mod'2+(|)(!)(#)s:($)x}7211312 / this is not (false)
0b
q)t(&){s~raze($)x mod'2+(|)(!)(#)s:($)x}each t:1 + til 1000000 / up to a million
1 10 20 1101 1121 11311 31101 40210 340210

Объяснение:

Приведите входной номер к строке, отсчитайте от 0 до длины строки, добавьте 2 ко всем, переверните ее и введите каждое число modвместе с исходным вводом. Приведите результат мода к строке и уменьшите список, проверьте, равен ли он строке входного числа:

{s~raze string x mod'2 + reverse til count s:string x} / ungolfed solution
{                                                    } / lambda function
                                           s:string x  / convert input to string, save as s
                                     count             / return length of this string
                                 til                   / like python's range() function
                         reverse                       / reverses the list
                     2 +                               / adds two to each element in the list
               x mod'                                  / ' is each both, so feeds x, and each element of the list to modulo function
        string                                         / converts output list to string list ("7";"2";"1"..etc)
   raze                                                / reduce list ("721...")
 s~                                                    / is s equal to this reduced list, returns boolean

Заметки:

Большая часть решения для генерации 2,3,4..списка, у меня есть другое решение, которое делает меньше вещей, но в итоге получается 37 байт после игры в гольф:

{s~x mod'reverse 2 + til count s:("J"$) each string x} / ungolfed
{s~x mod'(|)2+til(#)s:("J"$)each($)x}                  / golfed
— streetster
источник
0

Clojure, 75 байтов

#(=(sort %)(sort(map(fn[i c](char(+(mod(Integer. %)(+ i 2))48)))(range)%)))

Ввод - это строка, использующая mapи трейлинг %оказался короче, чем for[i(range(count %))]подход.

— NikoNyrh
источник
0

Haskell, 62 байта

f x=and$zipWith(==)(reverse$show x)$map(head.show.mod x)[2..]

Вместо того, чтобы обратить (бесконечный) список модулей в обратный, он обрезает список, сжав его с помощью перевернутой строки-представления интеграла x, который он затем обеспечивает равным для каждого элемента.

— archaephyrryx
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.