Вам будет дано положительное целое число (которое никогда не будет содержать 0) в качестве входных данных. Ваша задача - проверить, является ли это число Линч-Белла или нет.

Число представляет собой число Линча-Белла, если все его цифры уникальны и число делится на каждую из его цифр.

На самом деле существует только 548 чисел Линч-Белла, поэтому жесткое кодирование возможно, но почти наверняка будет длиннее.

126 - это число Линча-Белла, потому что все его цифры уникальны, а 126 делится на 1, 2 и 6.

Вы можете вывести любое истинное и ложное значение.

Примеры:

7 -> truthy
126 -> truthy
54 -> falsy
55 -> falsy
3915 -> truthy

Это OEIS A115569 .

Mathematica, 42 байта

0!=##&@@d&&##&@@((d=IntegerDigits@#)∣#)&

Я думаю, что 0!=##&@@d&&##&@@это новый низкий уровень читаемости для Mathematica ...

объяснение

Некоторые из основных синтаксических сахара, используемых здесь:

• & имеет очень низкий приоритет и превращает все, что от него осталось, в неназванную функцию.
• &&это просто Andоператор.
• # является аргументом ближайшей включающей безымянной функции.
• ##это последовательность всех аргументов функции.
• @является префикс для обозначения вызовов функций, то есть f@x == f[x].
• @@это Apply, который передает элементы списка в виде отдельных аргументов функции, то есть f@@{a,b,c} == f[a,b,c].

С этим из пути ...

(d=IntegerDigits@#)

Это должно быть достаточно понятным: это дает нам список десятичных цифр ввода и сохраняет результат в d.

(...∣#)

Это проверяет входные данные на делимость каждой из его цифр (потому что оператор делимости есть Listable). Это дает нам список Trueс и Falseс.

...&@@...

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

...&@@d

Мы применяем еще одну функцию d, чтобы отдельные цифры задавались как отдельные аргументы. Функция 0!=##&, то есть . Он проверяет, что все цифры различны (и что они отличны от, но это дается заданием, и если это не так, он не будет делителем в любом случае). на самом деле просто 1-байтовая заставка при использовании себя, и это работает, потому что есть 1-байтовый элемент ( ), которого мы знаем, что нет. Итак, это первое, что проверяет, что цифры уникальны. Давайте назовем этот результатUnequal[0, d1, d2, ...]00!=##&Unequal0U

...&&##

Опять же, это действительно просто сокращение And[U, ##]. С ##Будучи последовательности, отдельные булевы от первоначальной проверки делимости подставляются в And, таким образом мы получаем , которая проверяет , что обе цифры являются уникальными , и каждая цифра делит вход.And[U, d1∣n, d2∣n, ...]

Python 3 , 56 байт

lambda n:any(int(n)%int(x)for x in n)or len(n)>len({*n})

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

Выведите, Falseесли это число Линча-Белла, в Trueпротивном случае.

Брахилог , 10 байт

≠g;?z%ᵐ=h0

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

объяснение

≠             All digits are different
 g;?z         Zip the input with each of its digits
     %ᵐ       Map mod
       =      All results are equal
        h0    The first one is 0

C #, 87 83 байта

using System.Linq;s=>s.Distinct().Count()==s.Length&s.All(c=>int.Parse(s)%(c-48)<1)

^{Я написал это в блокноте перед тестированием в Visual Studio, где все работало нормально, так что просто понял, что теперь я такой же ботаник ...}

Полная / Отформатированная версия:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, bool> f = s => s.Distinct().Count() == s.Length
                                  & s.All(c => int.Parse(s) % (c - 48) < 1);

        Console.WriteLine(f("7"));
        Console.WriteLine(f("126"));
        Console.WriteLine(f("54"));
        Console.WriteLine(f("55"));
        Console.WriteLine(f("3915"));

        Console.ReadLine();
    }
}

JavaScript (ES6), 42 41 байт

s=>![...s].some((e,i)=>s%e|s.search(e)<i)

Принимает ввод в виде строки и возвращает trueили falseв зависимости от ситуации. Редактировать: 1 байт сохранен благодаря @RickHitchcock. Другие версии:

Принимает входные данные в виде строки и возвращает 0или 1(т. Е. Логический обратный) для 40 байтов:

s=>/(.).*\1/.test(s)|[...s].some(e=>s%e)

Принимает ввод как число и возвращает 0или 1для 43 байтов:

n=>/(.).*\1/.test(n)|[...''+n].some(e=>n%e)

Принимает ввод как число и возвращает 1или 0для 45 байтов:

n=>!/(.).*\1/.test(n)&![...''+n].some(e=>n%e)

Желе , 6 4 байта

Dg⁼Q

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

Как это работает

Dg⁼Q  Main link. Argument: n

D     Decimal; convert n to base 10.
 g    Take the GCD of each decimal digit k and n.
      For each k, this yields k if and only if k divides n evenly.
   Q  Unique; yield n's decimal digits, deduplicated.
  ⁼   Test the results to both sides for equality.

Python 3 , 54 байта

Возвращает, Falseкогда число является числом Линч-Белла. Принимает строки в качестве входных данных. Придумал сам, но очень похож на род. Я бы прокомментировал его пост, но у меня пока нет репутации.

lambda s:len({*s})<len(s)+any(int(s)%int(c)for c in s)

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

Желе , 8 байт

D⁼QaDḍ$Ạ

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

PHP, 62 48 байт

while($i=$argn[$k++])$r|=$argn%$i|$$i++;echo!$r;

Запустите как трубу с -nRили проверьте это онлайн . Пустой вывод для фальши, 1для правды.

сломать

while($i=$argn[$k++])   # loop through digits
    $r|=                    # set $r to true if
        $argn%$i            # 1. number is not divisible by $i
        |$$i++;             # 2. or digit has been used before
echo!$r;                # print negated $r

Haskell , 61 байт

(#)=<<show
(d:r)#n=notElem d r&&mod n(read[d])<1&&r#n
_#_=0<3

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

Определяет анонимную функцию, (#)=<<showкоторая при заданном числе возвращает Trueили False.

05AB1E , 4 байта

ÑÃÙQ

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

Тот же алгоритм, что и этот ответ на связанный вопрос .

05AB1E , 8 байтов

SÖP¹DÙQ*

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

Mathematica, 57 байт

Tr@Boole[IntegerQ/@Union[s=#/IntegerDigits@#]]==Length@s&

Python 2 , 66 байт

Это решение в Python 2, цель которого - вывод Trueдля правдивых и Falseложных данных:

lambda n:len(set(n))==len(n)and not any((int(n)%int(x)for x in n))

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

Haskell, 260 241 201 162 байта

f([x])=1<2
f(x:xs)=not(x`elem`xs)&&(f xs)
r n i= n`mod`(read[(show n!!i)]::Int)==0
q n 0=r n 0 
q n i=r n i&&q n(i-1)
p n=length(show n)-1
s n=q n(p n)&&f(show n)

объяснение

f ([x]) = True                                           f function checks for                                                       
f (x:xs) = not(x `elem` xs) && (f xs)                    repeated digits              
r n i = n `mod` (read [(show n !! i)] :: Int) == 0       checks whether num is 
                                                         divisible by i digit
q n 0 = r n 0                                            checks wether n divisible
q n i = r n i && q n (i-1)                               by all of its digits                             
p n = length (show n) -                                  gets length of number                             
s n = (q n (p n)) && (f (show n))                        sums it all up!!!

Значительно сократили спасибо Лайкони

Japt , 15 14 11 10 9 байт

ì®yUÃ¥Uìâ

Попытайся

Нейм , 9 байт

𝐮ℚ₁𝐅₁𝕌₁ℚ𝕒

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

-2 спасибо Оккс .

Хм, есть хорошая симметрия ... oO.O.O.Oo

Perl 6 , 27 байт

{$_%%.comb.all&&[!=] .comb}

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

• .combэто метод, который при отсутствии аргументов разбивает строку на отдельные символы. Число неявно преобразуется в строку и .combвозвращает свои цифры.
• .comb.all это соединение всех цифр.
• $_ %% .comb.allявляется и-переходом делимости входного аргумента $_на все его цифры. Например, если $_есть 123, соединение all(True, False, True), которое разрушается доFalse в истинном контексте.
• [!=] .combсокращает цифры входного аргумента с помощью !=оператора, который оценивает, Trueотличаются ли все цифры.

Сетчатка , 37 байт

(.).*\1
0
.
<$&$*1>$_$*
<(1+)>\1+

^$

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Пояснение: На первом этапе любая дублирующаяся цифра заменяется на ноль. На втором этапе каждая цифра заменяется ее унарным представлением, за которым следует унарное представление исходного числа. Затем на третьем этапе вычисляется остаток от деления исходного числа на каждую ненулевую цифру. Если число является числом Линч-Белла, то это удалит все, и это проверено на заключительном этапе.

Ruby 2.4, 42 байта

->x{(r=x.digits)|[]==r&&r.none?{|f|x%f>0}}

(ТИО пока нет, извините)

CJam, 17 байт

CJam - это ява языков игры в гольф. Это даже интерпретируется на Java!

{_Ab__L|=@@f%:+>}

Объяснение:

{   e# Stack:              3915
_   e# Duplicate:          3915 3915
Ab  e# Digits in base 10:  3915 [3 9 1 5]
__  e# Duplicate twice:    3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
L|  e# Remove duplicates:  3915 [3 9 1 5] [3 9 1 5] [3 9 1 5]
=   e# Test equality:      3915 [3 9 1 5] 1
@@  e# Rotate twice:       1 3915 [3 9 1 5]
f%  e# Modulo each:        1 [0 0 0 0]
:+  e# Sum:                1 0
>   e# Greater than:       1
}   e# Output:             1 (truthy)

VBScript, 177 байт

Привет всем, это мой самый первый пост CG и первая попытка, так что надеюсь, что я следовал всем правилам ...

Function L(s)
dim i,j,k,m,n
j = Len(s)
redim a(j)
n = 0
for i = 0 to j-1
   A(i) = Mid(s,i+1,1)   
   m = m + s Mod A(i)   
   if j = 1 then         
   else                             
        for k = 0 to i - 1        
            if A(i)  = A(k) then n = n + 1   
        next
   end if
next
if m + n = 0 then L = "y" else L = "n"
End Function

Это можно запустить из Блокнота, добавив строку в конце

Msgbox L(InputBox(""))

Затем сохраните его как .vbs, затем дважды щелкните.

Объяснение:

Function L(s)                  'creates the function "L" taking test number as input
dim i,j,k,t,m,n                'variables
j = Len(s)                     '"j" gets length of test number
redim a(j)                     'creates array "a", size is length of test number 
n = 0                          'sets repeat character counter "n" to zero
for i = 0 to j-1               'for length of string
   A(i) = Mid(s,i+1,1)         'each array slot gets one test number character
   m = m + s Mod A(i)          '"m" accumulates moduli as we test divisibility of each digit
   if j = 1 then               'if test number is of length 1, it passes (do nothing)
   else                        'otherwise, gotta test for repeats     
        for k = 0 to i - 1     'for each digit already in array, test against current digit   
            if A(i)  = A(k) then n = n + 1  
                               'repeat char counter "n" stores no of repeats  
        next                   'proceed through array looking for repeat  
   end if
next                           'test next digit for divisibility and repeats
if m + n = 0 then L = "y" else L = "n"      
                               'check for any repeats and moduli,
                               'then return yes or no for LynchBelledness
End Function

VBScript - немного тупой инструмент для игры в гольф, но эй, я еще не изучил Ruby ...

PHP , 51 байт

печатает ноль для истинного и один для ложного

for(;$c=$argn[$i++];$$c=1)$t|=$$c||$argn%$c;echo$t;

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

PHP , 62 байта

печатает ноль для истины и один для ложных

for($a=$argn;$c=$a[$i];)$t|=strpos($a,$c)<+$i++||$a%$c;echo$t;

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

Pyth , 10 байт

qiRQKjQT{K

Проверьте все контрольные примеры.

Как?

qiRQKjQT {K ~ Полная программа.

     jQT ~ Список десятичных цифр ввода.
    K ~ назначить переменной K.
 iRQ ~ Для каждой десятичной цифры ...
 я Q ~ ... Получить наибольший общий делитель с самим вводом.
        {K ~ K с удаленными дублирующими элементами.
q ~ Равен? Вывод неявно.

Pyth , 11 байт

&!f%sQsTQ{I

Проверьте все контрольные примеры.

Как?

&! f% sQsTQ {I ~ Полная программа с неявным вводом.

  f Q ~ Фильтр по входной строке.
   % sQsT ~ Вход преобразуется в целое число по модулю текущей цифры.
             ~ Сохраняет его, если он больше 0, и сбрасывает его в противном случае.
 ! ~ Отрицание Если список пуст, возвращает True, иначе False.
& {I ~ И является ли входной инвариант при дедупликации? Вывод неявно.

Perl 5 , 34 байта

33 байта кода + 1 для -pфлага

$n=$_;$\|=$n%$_|$k{$_}++for/./g}{

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

Выходы 0для правды, любой другой номер для фальши

Котлин 1,1, 98 66 59 байт

{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}

украшенный

{i ->
    // None of the digits are not factors
    i.none { i.toInt() % (it-'0') > 0 }
    // AND
    &&
    // None of the digits are repeated
    i.length == i.toSet().size
}

Тест

var L:(String)-> Boolean =
{i->i.none{i.toInt()%(it-'0')>0}&&i.length==i.toSet().size}
data class TestData(val input: String, val output: Boolean)

fun main(args: Array<String>) {
    var inputs = listOf(
        TestData("7", true),
        TestData("126", true),
        TestData("54", false),
        TestData("55", false),
        TestData("3915", true)
    )

    for (test in inputs) {
        if (L(test.input) != test.output) {
            throw AssertionError(test.toString())
        }
    }
    println("Test Passed")
}

APL (Dyalog Unicode) , 24 байта

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵}

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

Простой DFN, возможно, можно играть в гольф немного больше. Выход стандартного APL booleans 1 для правды, 0 для фальши.

Стоит отметить, что функция принимает аргументы как строки, а не как целые числа.

Как:

{((,⍵)≡∪⍵)×∧/0=(⍎¨⍵)|⍎⍵} ⍝ Dfn, argument ⍵.
                      ⍎⍵  ⍝ Convert ⍵ to integer
                     |    ⍝ Modulus
                (⍎¨⍵)     ⍝ Each digit in ⍵
              0=          ⍝ Equals 0? Returns a vector of booleans
            ∧/            ⍝ Logical AND reduction
           ×              ⍝ multiplied by (the result of)
  (     ∪⍵)               ⍝ unique elements of ⍵
       ≡                  ⍝ Match
   (,⍵)                   ⍝ ⍵ as a vector; the Match function then returns 1 iff all digits in ⍵ are unique

Юлия 1,0 39 байт

f(x,d=digits(x))=rem.(x,d)==0*unique(d)

rem.(x,d)вектор, содержащий остатки после деления x на каждую цифру в x. 0*unique(d)вектор с длиной, равной количеству уникальных цифр со всеми нулевыми значениями. Проверьте, равны ли они.

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

ruby -n , 40 байт

p gsub(/./){$'[$&]||$_.to_i%$&.hex}<?0*8

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

Читайте номер как строку. Замените каждый символ (цифру) на последующее вхождение этого символа, если оно присутствует, или целое число по модулю этой цифры. Это приведет к строке только 0s, если и только если это число Линча-Белла. Зачем? Если есть повторяющаяся цифра, каждый экземпляр последней остается неизменным, и, поскольку вход не содержит нулей, это означает ненулевую цифру. В противном случае мы просто проверяем, делит ли каждая цифра число равномерно.

Поскольку нет чисел Линча-Белла, состоящих из 8 и более цифр (формальное доказательство: OEIS так говорит), проверка, является ли результирующая строка лексикографически более ранней, чем строка '00000000', эквивалентна проверке, все ли это нули.

R 86 байт

x=scan(,'');a=as.double;all(table(utf8ToInt(x))==1)&&all(!a(x)%%a(el(strsplit(x,""))))

Принимает ввод в виде строки. Я конечно чувствую, что это пригодно для игры в гольф.

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