Вам буде дано позитивне ціле число (яке ніколи не буде містити 0) в якості введення. Ваше завдання - перевірити, чи це номер Lynch-Bell чи ні.

Число - це число Лінча-Белла, якщо всі його цифри унікальні і число ділиться на кожну його цифру.

Насправді насправді лише 548 номерів Lynch-Bell, тому жорстке кодування - це можливість, але майже напевно буде довше.

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

Ви можете вивести будь-яке значення "химерність" і "хибність"

Приклади:

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

Це OEIS A115569 .

Математика, 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). Це дає нам список Trues і Falses.

...&@@...

Застосовуємо функцію з лівої сторони до списку булевих, так що кожен булевий аргумент є окремим аргументом.

...&@@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або 143 байти:

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

Вводиться як число і повертає 1або 045 байт:

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для фальшивих , для truthy.

зламатися

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 . Спробуйте в Інтернеті!

Математика, 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 завдяки Okx .

Хм, є приємна симетрія ... 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+

^$

Спробуйте в Інтернеті!Посилання включає тестові випадки. Пояснення: Перший етап замінює будь-яку дублюючу цифру нулем. Другий етап замінює кожну цифру її унарним поданням з подальшим одинарним поданням вихідного числа. Потім на третьому етапі обчислюється залишок ділення вихідного числа на кожну ненульову цифру. Якщо число є номером Лінча-Белла, то це видалить усе, і це перевірено на останньому етапі.

Рубін 2,4, 42 байти

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

(Ще немає TIO, вибачте)

CJam, 17 байт

CJam - Java мов для гольфу. Це навіть інтерпретується на 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 - це трохи тупий інструмент для гольфу, але ей, я ще не навчився Рубі ...

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 ~ Для кожної десяткової цифри ...
 i 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-буленів 1 для truthy, 0 для фальшивих.

Варто згадати, що функція бере аргументи як рядки, а не ints.

Як:

{((,⍵)≡∪⍵)×∧/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)- вектор, довжина якого дорівнює кількості унікальних цифр із усіма нульовими значеннями. Перевірте, чи рівні вони.

Спробуйте в Інтернеті!

рубін -n , 40 байт

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

Спробуйте в Інтернеті!

Читайте в числі як рядок. Замініть кожен символ (цифру) з подальшим виникненням цього символу, якщо він присутній, або ціле число за модулем цієї цифри. Це призведе до рядка лише 0s, якщо і тільки якщо це номер Lynch-Bell. Чому? Якщо є повторна цифра, кожен екземпляр останнього залишається однаковим, і оскільки вхідне повідомлення не містить нулів, це означає ненульову цифру. В іншому випадку ми просто перевіряємо, чи кожна цифра рівномірно ділить число.

Оскільки немає 8-чи чисельніших цифр Лінч-Белла (офіційний доказ: OEIS так говорить), перевірка того, чи є отримана рядок лексикографічно раніше, ніж рядок '00000000', еквівалентна перевірці, чи є всі нулі.

R , 86 байт

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

Вводиться як рядок. Я, безумовно, відчуваю, що це гальфа.

Спробуйте в Інтернеті!