Генерация номеров понедельника


35

Числа понедельника , определенные Гамовым в этом вопросе над «Загадкой», представляют собой положительные целые числа N со следующими тремя свойствами:

  • Десятичное представление N не содержит цифру 0
  • Десятичное представление N не содержит ни одной цифры дважды
  • N делится на каждую цифру D в десятичном представлении

Обратите внимание, что они альтернативно известны в OEIS как числа Линча-Белла .

Примеры:

  • 15это число понедельника, так как это делится на так 1и 5и удовлетворяет другие два условия
  • 16нет, потому что это не делится на 6.
  • Число 22не, потому что, хотя оно удовлетворяет условиям 1 и 3, оно не соответствует условию 2.

Вот список первых 25 номеров понедельника, чтобы вы начали (всего 548):

1 2 3 4 5 6 7 8 9 12 15 24 36 48 124 126 128 132 135 162 168 175 184 216 248

Задача здесь состоит в том, чтобы написать кратчайший код, который генерирует полную последовательность чисел понедельника, от 1 до 9867312 (доказано, что в этом вопросе он является наибольшим из возможных).

Ваш код не должен вводить, а вывод должен быть STDOUT или эквивалентным, с вашим выбором разделителя. Применяются все обычные правила игры в гольф, а стандартные лазейки запрещены.

Leaderboard



1
Также известный как числа Линча-Белла .
Геобитс

@Geobits Спасибо - я не смог найти его в OEIS по какой-то причине.
AdmBorkBork

8
Вы должны были опубликовать этот вызов вчера ...
mbomb007

2
@ mbomb007 Я бы ... не видел вопрос Гамова до сегодняшнего утра!
AdmBorkBork

Ответы:


1

Желе , 8 байт

ȷ7Dg⁼QƲƇ

Работает на месте менее чем за восемь минут.

Попробуйте онлайн! (изменено, чтобы найти числа с шестью цифрами или меньше)

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

ȷ7Dg⁼QƲƇ  Main link. No arguments.

ȷ7        Set the return value to 10**7.
       Ƈ  Comb; promote 10**7 to [1, ..., 10**7], then keep only those n in the range
          for which the link to the left returns a truthy value.
      Ʋ     Combine the four links to the left into a monadic chain.
  D           Decimal; yield n's digit array in base 10.
   g          Take the GCD of each digit and n.
     Q        Yield the unique digits of n.
    ⁼         Test both results for equality.

16

Python 2, 85 байт

print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]

Распечатывает список.

Я в основном комбинирую два моих ответа на предыдущие вызовы:

Спасибо xsot за 1 байт, сэкономленный путем лучшего сочетания условий.


Вы можете сохранить байт:print[n for n in range(1,9**9)if(n<10**len(set(`n`)))>any(n%(int(d)or.3)for d in`n`)]
xsot

11

Perl, 61 47 байт

Код 46 байтов + параметр командной строки 1 байт.

/(.).*\1|0/||1*s/./$_%$&/rge||print for 1..1e7

Использование:

perl -l entry.pl

объяснение

/(.).*\1|0/ возвращает 1, если проверяемое число содержит повторяющийся символ или 0

s/./$_%$&/rgeзаменяет каждую цифру значением проверяемого числа% цифрой. Например, 15 -> 00, 16 -> 04 (потому что 16% 6 = 4). Это означает, что любой ввод, который делится на все его цифры, будет состоять из всех 0, в противном случае он будет содержать цифру> 0. Чтобы обработать это как число, мы * 1, что означает, что любой тестируемый номер вернет 0 для этого блока, если он делится на все его цифры, в противном случае> 0.

Разделив эти два оператора и напечатав 'или', если одно из первых двух условий вернет> 0, условие совпадет, и последующие части выражения не будут оцениваться. Если и только если оба предыдущих условия равны 0, печать будет выполнена. -lФлаг обеспечивает , чтобы добавить новую строку после каждой печати.


Очень хорошо. Вы можете сэкономить несколько байтов, сделав это Perl 5.10 и используя sayвместо print+ -l:-)
xebtl

Спасибо за предложение! Я думал, что say требуется явное объявление в первую очередь ?
Jarmex

@Jarmex Я, возможно, начал традицию здесь брать use feature 'say'или use 5.012бесплатно - я всегда упоминаю, когда делаю это, и никто никогда не оспаривал это. Я видел, как несколько других делали то же самое :)
Хоббс

2
@hobbs В этом ответе на мета сказано: «До сих пор был достигнут консенсус по SO, и здесь было« -M5.010, когда необходимо, бесплатно »».
xebtl

2
Использование mapи sayдо 43: попробуйте онлайн!
Xcali

10

Пиф, 22 21

f&.{`T!f%T|vY.3`TS^T7

Спасибо Jakube за удаление 1 байта ненужного форматирования.

Сильно вдохновлен этим CW ответом на соответствующий вопрос.

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

Я бы порекомендовал не пробовать это онлайн, если вы не используете число меньше 7 ... Я установил его на 2 в этой ссылке.

Фильтры из 1к 10^7-1которой охватывает все необходимые значения. Эта версия может вызвать ошибку памяти, если она не может составить список S^T7, который похож наlist(range(1,10**7)) Python 3 (однако, он прекрасно работает для меня). Если это так, вы можете попробовать:

.f&.{`Z.x!s%LZjZT0548

Который находит первые 548 числа понедельника. Это также демонстрирует другой способ проверки числа 0s в номере, вместо замены на него .3используется блок try-catch. Кредит на эту версию целиком и полностью принадлежит Якубе. (Обратите внимание, что для онлайн-переводчика это все еще очень медленно)


1
Вот другое решение: .f&.{`Z.x!s%LZjZT0548 оно в несколько раз быстрее (4x-5x), чем ваш подход while-loop, и имеет длину всего 21 байт.
Якуб

1
@ Jakube Обратные пометки - боль в комментариях, не так ли? : P Большое спасибо, хотя!
FryAmTheEggman,

Хм .. ваше решение, похоже, не работает .. В вашей ссылке TIO в диапазоне до 100, он показывает 55, 66, 77, 88, 99, все числа с дублированными цифрами ..
Кевин Круйссен

1
@KevinCruijssen К сожалению, Pyth обновлялся так много раз с тех пор, как я сделал этот пост, я не могу найти то, что изменилось. Вы можете увидеть в пасте, что это работало раньше. Я думаю, что это могло быть .{изменено, так как замена его, {Iкажется, работает.
FryAmTheEggman

@FryAmTheEggman Ах, я не видел пасту. Прошло уже почти три года, поэтому неудивительно, что все могло измениться. +1 в этом случае, потому что паста доказывает, что это сработало. :)
Кевин Круйссен

9

GS2 , 20 19 байт

gs2 использует широкий диапазон байтов, а не только печатные символы ascii. Я представлю свое решение в шестнадцатеричном виде.

17 7d 2f 24 65 f1 c8 24 d8 62 e9 65 f4 24 40 90 71 f3 54

Вот некоторые объяснения. gs2 - это язык, основанный на стеке, поэтому здесь нет переменных. (кроме 4 регистров, один из которых я использую здесь)

17         # push constant 7
7d         # 10 raised to the power
2f         # create an array of numbers from 1 to n

    24     # get digits of number into array
    65     # calculate product of array
f1         # filter array by previous block of 2 instructions

    c8     # save top of stack to register a
    24     # get digits of number into array
        d8 # tuck register a under top of stack
        62 # boolean divisibility test 
    e9     # map array using previous block of 2 instructions
    65     # calculate product of array
f4         # filter array by previous block of 5 instructions 

    24     # get digits of number into array
    40     # duplicate top of stack
    90     # remove duplicates from array
    71     # test equality
f3         # filter array by previous block of 4 instructions
54         # show contents of array separated by line breaks

8

Python 3, 132 128 114 111 104 байта

i=0
while i<1e8:
 j=str(i)
 if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j):print(i)
 i+=1

Есть 548 номеров понедельника.


1
Не могли бы вы использовать 1e8вместо даже 9**9?
Дом Гастингс

Удалить пробел в '0' not. Кроме того, i%int(k)==0возможно , может быть i%int(k)<1?
mbomb007

Спасибо. Я не хотел добавлять это обратно. @ Mbomb007
Зак Гейтс,

Вы можете использовать j=`i`.
mbomb007

Для другого использования -6if len(set(j))+2==len(j)+('0'in j)+all(i%int(k)<1 for k in j)
lirtosiast

7

APL, 44 39 37 байт

{0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)⍎¨⍕⍵:⍵⋄⍬}¨⍳1e7

Ungolfed:

{
 x ← ⍎¨⍕⍵⋄                    ⍝ Define x to be a vector of the digits of ⍵
 0=+/(⊢|∘⍵,0∘∊,⍴∘⊢≠⍴∘∪)x:   ⍝ No zeros, all digits divide ⍵, all unique?
 ⍵⋄⍬                          ⍝ If so, return the input, otherwise null
}¨⍳1e7                        ⍝ Apply to the integers 1..1E7

Благодаря Moris Zucca сэкономлено 7 байт!


Я люблю APL. Вот почему.
Конор О'Брайен

Я думаю, что вы можете играть в гольф, используя функциональные поезда, экономя 5 байтов: {0 = + / (⊢ | ∘⍵, 0∘∊, ⍴∘⊢ ≠ ⍴∘∪) x ← ⍎¨⍕⍵: ⍵⋄⍬} ¨⍳ 1e7
Морис Зукка

@ MorisZucca Отлично, спасибо за предложение!
Алекс А.

Я только что увидел, что в этом виде x ← больше не нужен, поэтому еще 2 байта сохранены! :-)
Морис Зукка

@MorisZucca Вы игра в гольф APL! Еще раз спасибо!
Алекс А.

6

TI-BASIC, 60 59 байт

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(1,1+int(log(X->D
SortA(∟D
If X>9
If not(max(remainder(X,Ans+2Xnot(Ansmin(ΔList(∟D
Disp X
End

∟Dэто список цифр, который генерируется с использованием математики и randIntNoRep(команды (случайная перестановка всех целых чисел между1 и 1+int(log(Xвключительно). Я использую несколько сложную цепочку утверждений, чтобы проверить, выполнены ли все условия:

   min(ΔList(∟D        ;Zero if repeated digit, since ∟D was sorted ascending
Ans                    ;Multiplies the unsorted copy of ∟D by the minimum from above
                       ;(Lists are different dimensions; we can't elementwise AND)
                       ;Will contain a 0 if there's a 0 digit or a repeated digit
      not(             ;If there's a zero,
Ans+2X                 ;Add 2X to that pos. in the list, failing the test:

    max(remainder(X,   ;Zero iff all digits divide X and 2X wasn't added
not(

Чтобы пропустить числа с повторяющимися или нулевыми цифрами, я заменяю нули на 2X , потому что Xникогда не делится на 2X.

Для особого случая 1 ~ 9 (потому что ΔList( в списке ошибок одного элемента) я использую Ifоператор в четвертой строке, чтобы пропустить проверку в пятой строке, автоматически отображая всеX ≤9.

Выходные числа разделены новыми строками.


5

Mathematica 105

l=Length;Cases[Range@9867312,n_ /;(FreeQ[i=IntegerDigits@n,0]&&l@i== l@Union@i&&And@@(Divisible[n,#]&/@i))]
  • IntegerDigits ломает до n на список его цифр i.
  • FreeQ[i,0] проверяет, нет ли нулей в списке.
  • Length[i]==Length[Union[i]] проверяет, что нет повторяющихся цифр.
  • And@@(Divisible[n,#]&/@i)проверяет, что каждая цифра является делителем n.

{1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 15, 24, 36, 48, 124, 126, 128, 132, 135, 162, 168, 175, 184, 216, 248 264, 312, 315, 324, 384, 396, 412, 432, 612, 624, 648, 672, 728, 735, 784, 816, 824, 864, 936, 1236, 1248, 1296, 1326, 1362, 1368 1395, 1632, 1692, 1764, 1824, 1926, 1935, 1962, 2136, 2184, 2196, 2316, 2364, 2436, 2916, 3126, 3162, 3168, 3195, 3216, 3264, 3276, 3492, 3612, 3624 3648, 3816, 3864, 3915, 3924, 4128, 4172, 4236, 4368, 4392, 4632, 4872, 4896, 4932, 4968, 6132, 6192, 6312, 6324, 6384, 6432, 6912, 6984, 8136, 8496 , 8736, 9126, 9135, 9162, 9216, 9315, 9324, 9432, 9612, 9648, 9864, 12384, 12648, 12768, 12864, 13248, 13824, 13896, 13968, 14328, 14728, 14832, 16248, 16824, 17248 18264, 18432, 18624, 18936, 19368, 21384, 21648, 21784, 21864, 23184, 24168, 24816, 26184, 27384, 28416, 29736, 31248, 31824, 31896, 31968, 32184, 34128, 36792,37128, 37296, 37926, 38472, 39168, 39816, 41328, 41832, 42168, 42816, 43128, 43176, 46128, 46872, 48216, 48312, 61248, 61824, 62184, 64128, 68712, 72184, 73164, 73248 73962, 78624, 79128, 79632, 81264, 81432, 81624, 81936, 82416, 84216, 84312, 84672, 87192, 89136, 89712, 91368, 91476, 91728, 92736, 93168, 93816, 98136, 12363984, 123864 124368, 126384, 129384, 132648, 132864, 132984, 134928, 136248, 136824, 138264, 138624, 139248, 139824, 142368, 143928, 146328, 146832, 148392, 148632, 149328, 149832, 1648384, 169832, 169832, 169832, 169832, 169832 164832, 167328, 167832, 168432, 172368, 183264, 183624, 184392, 184632, 186432, 189432, 192384, 193248, 193824, 194328, 194832, 198432, 213648, 213864, 213984, 214368, 2163843887, 2163843887 231864, 231984, 234168, 234816, 236184, 238416, 239184, 241368, 243168, 243768, 243816, 247968, 248136,248976, 261384, 263184, 273168, 281736, 283416, 284136, 291384, 293184, 297864, 312648, 312864, 312984, 314928, 316248, 316824, 318264, 318624, 319248, 319824, 321648, 321864, 321984, 321864, 321984 326184, 328416, 329184, 341928, 342168, 342816, 346128, 348192, 348216, 348912, 349128, 361248, 361824, 361872, 362184, 364128, 364728, 367248, 376824, 381264, 381624, 382416, 381624, 382416, 38164, 382416, 38164, 382416, 38164, 382416, 38164, 382416, 38164, 382416, 38164, 382416, 38164 391248, 391824, 392184, 394128, 412368, 413928, 416328, 416832, 418392, 418632, 419328, 419832, 421368, 423168, 423816, 427896, 428136, 428736, 431928, 432168, 432768, 43328168, 8328162, 8328, 168, 8328, 431, 8328, 431, 8328, 4316, 832816, 8328, 8328, 431, 8328, 431, 832816, 431, 8328, 431, 8328, 431, 832816, 83282 438912, 439128, 461328, 461832, 463128, 468312, 469728, 478296, 478632, 481392, 481632, 482136, 483192, 483216, 483672, 483912, 486312, 489312, 491328, 491832, 493128, 49831232, 63838383838, 3838, 4838 613872, 614328, 614832, 618432, 621384, 623184, 623784,627984, 631248, 631824, 632184, 634128, 634872, 641328, 641832, 643128, 648312, 671328, 671832, 681432, 684312, 689472, 732648, 732816, 742896, 746928, 746928, 7623832, 7686432, 7686432, 7686432 813624, 814392, 814632, 816432, 819432, 823416, 824136, 824376, восемьсот тридцать один тысяча двести шестьдесят четыре, восемьсот тридцать одна тысяча шестьсот двадцать четыре, 832416, 834192, 834216, 834912, 836472, восемьсот сорок один тысяча триста девяносто два, восемьсот сороки одна тысяча шестьсот тридцать два, 842136, 843192, 843216, 843912, 846312, 849312, восемьсот шестьдесят один тысяча четыреста тридцать два, 864312, 873264, восемьсот девяносто одна тысяча четыреста тридцать два, 894312, 897624, 912384, 913248, 913824, 914328, 914832, 918432, девятьсот двадцать одна тысяча триста восемьдесят четыре, 923184, 927864, девятьсот тридцать один тысячу двести сорок восемь, девятьсот тридцать одна тысяча восемьсот двадцать четыре, 932184, 934128, девятьсот сорок одна тысяча триста двадцать-восемь, 941832, 943128, 948312, 976248, 978264, девятьсот восемьдесят один тысяча четыреста тридцать две, 984312, 1289736, 1293768, 1369872, 1372896, 1376928, 1382976, 1679328, 1679832, 1687392, 1738296, 1823976, 1863792, 1876392, 1923768, 1936872, 1982736, 2137968, 2138976, 2189376, 23178, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2819, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, 2889, кп 2937816, 2978136, 2983176,3186792, 3187296, 3196872, 3271968, 3297168, 3298176, 3619728, 3678192, 3712968, 3768912, 3796128, 3816792, 3817296, 3867192, 3869712, 3927168, 3928176, 6139728, 6379128, 6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 78392, 7936, 7936, 79368, 739288, 7916, 79328, 739288, 7932, 839, 832, 79168, 7393232, 7398832, 7398832, 7392888 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392, 7863912, 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9163728, 9176328, 9231, 9376328, 9686328, 9686328, 9686328, 9686328, 9686328, 96863732, 9686328, 96863232, 96863232, 9686328, 9686832, 9686832, 9686832, 9686832, 9686832, 968, 968, 9686832, 968, 968, 968, 968, 968, 868, 868, и всего за 7891632, 7892136, 7916328, 7916832. 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}6387192, 6389712, 6391728, 6719328, 6719832, 6731928, 6893712, 6913872, 6971328, 6971832, 7168392, 7198632, 7231896, 7291368, 7329168, 7361928, 7392168, 7398216, 7613928, 7639128, 7829136, 7836192, 7839216, 7861392, 7863912, 7891632, 7892136, 7916328, 7916832, 7921368, 8123976, 8163792, 8176392, 8219736, 8312976, 8367912, 8617392, 8731296, 8796312, 8912736, 8973216, 9163728, 9163728, 9176328, 9231, 9376328, 9686328, 9686328, 9686328, 9686328, 9686328, 96863732, 9686328, 96863232, 96863232, 9686328, 9686832, 9686832, 9686832, 9686832, 9686832, 968, 968, 9686832, 968, 968, 968, 968, 968, 868, 868, и всего за 7891632, 7892136, 7916328, 7916832. 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376, 9867312}8796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 98123768796312, 8912736, 8973216, 9163728, 9176328, 9176832, 9182376, 9231768, 9237816, 9278136, 9283176, 9617328, 9617832, 9678312, 9718632, 9723168, 9781632, 9782136, 9812376

Length[%]

548


Я ожидаю, что в Mathematica есть способ получить большие числа в меньшем количестве байтов, например, 9^9или1e8 или что - то
FryAmTheEggman

Я удивлен, что Mathematica не имеет встроенного для этого ;-). Хороший трюк сUnion проверкой на наличие дубликатов.
AdmBorkBork

@FryAmTheEggman, Вы правы в том, что Mathematica допускает 9 ^ 9. Но разве это не вернет больше, чем 548 номеров в понедельник?
DavidC

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

5

Haskell, 77 байт

[x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

Пример использования (первые 20 цифр):

take 20 $ [x|x<-[1..9^9],all(\a->a>'0'&&mod x(read[a])+sum[1|y<-show x,y==a]<2)$show x]

[1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162]

Как это работает: переберите все числа от 1 до 9 ^ 9 и проверьте условия. Текущее число xпревращается в его строковое представление ( show x) для работы с ним как список символов.


5

R, 99 байт

for(n in 1:1e8){i=1:nchar(n);if(all(table(d<-(n%%10^i)%/%10^(i-1))<2)&!0%in%d&all(!n%%d))cat(n,"")}

Немного меньше в гольф:

for(n in 1:1e8){
    i = 1:nchar(n)
    d = (n%%10^i)%/%10^(i-1) # Digits of n
    if(all(table(d)<2) # No digits is present more than once 
      & !0%in%d        # 0 is not one of the digits
      & all(!n%%d))    # All digits are divisors of n
    cat(n,"")
    }

5

Perl, 90 75 70 байт

print+($_,$/)x(grep(!/(\d).*\1|0/,$_)&s/./!$&||$_%$&/ger<1)for 1..1e7

1
Аааа, я пропустил трюк \ 1 для проверки на обман, хорошо. Можете ли вы сэкономить больше с помощью модификатора оператора while и троичной печати?
Дом Гастингс

@DomHastings спасибо, теперь больше играю в гольф, используя ваше предложение
Стив

Хороший, я думаю , вы можете сэкономить несколько больше, а, как вам не нужно , ^а $вокруг 0в вашем grep, вы можете заменить , &&прежде чем s/./с одним , &и я думаю , что последний |0является ненужным (хотя только испытано к 1e3. ..). Ну и по-настоящему избили мой счет! :)
Дом Гастингс

1
Спасибо @DomHastings, до 70 с вашими советами по игре в гольф.
Стив

Отыграйте его немного больше, избавившись от grep (ненужно - комбинация шаблонов позаботится об этом без grep) и переставив все остальное в карту: попробуйте онлайн!
Xcali

4

CJam, 25 байтов

1e7{_Ab__&0-_@=@@f%1b>},`

Попробуйте онлайн . Обратите внимание, что онлайн-ссылка работает только до 10000. Я не уверен, закончится ли он онлайн, если вы достаточно терпеливы. Он не тестировал его с автономной версией CJam, но я ожидаю, что он прекратит работу.

Объяснение:

1e7     Upper limit.
{       Start filter loop.
  _Ab     Copy and convert to list of decimal digits.
  __&     Intersect list with itself to remove duplicates.
  0-      Remove zero.
  _       Make a copy of unique non-zero digits. Will use these as divisors.
  @=      Compare unique non-zero digits to all digits. Must be true for Monday numbers.
  @@      Rotate original number and list of non-zero digits to top.
  f%      Remainders of original number with all non-zero digits.
  1b      Sum up the remainders. Since they all must be zero for Monday numbers,
          their sum must be zero.
  >       Check that first part of condition was 1, and sum of remainders 0.
},      End filter loop.
`       Convert resulting list to string.

4

C #, 230 227

Прошло довольно много времени с тех пор, как я вырос, поэтому я, вероятно, забыл несколько хитростей, чтобы сломать счет. Будет лучше, когда я думаю о них ... А пока

using System.Linq;class P{static void Main(){System.Console.Write(string.Join(",",Enumerable.Range(0,1<<24).Where(i=>{var s=i.ToString();return!s.Contains('0')&&s.Length==s.Distinct().Count()&&s.All(x=>i%(48-(int)x)==0);})));}}

Ungolfed:

using System.Linq;
class P
{
    static void Main()
    {
        System.Console.Write(                                       //Output...
            string.Join(                                            //...all results...
                ",",                                                //...comma separated...
                Enumerable.Range(0, 1<<24)                          //...from 0 to 16777216...
                    .Where(i => {                                   //...where...
                        var s = i.ToString();                       //...the digits as char array (what we usually call a string)...
                        return !s.Contains('0')                     //...for which none of the digits is 0...
                            && s.Length == s.Distinct().Count()     //...and the number of distinct digits equals the total number of digits (e.g. all unique)...
                            && s.All(x => i % (48 - (int)x) == 0);  //...and the number is divisible by each of the digits (after 'ASCII-correction')
                    })
            )
        );
    }
}

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824, 1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924, 4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216, 9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368, 21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328, 41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984, 124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328, 164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648, 231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864, 312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248, 361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368, 423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192, 483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872, 641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416, 824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872, 1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176, 3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928, 6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976, 8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312


может (int) 1e7 быть 1 << 24?
Lirtosiast

@ThomasKwa Да, это может быть. Верно. Благодарность!
RobIII

4

TI-BASIC, 55 53 байта

Это сравнительно небольшая правка ответа Томаса Ква , но я представляю его как новый ответ, потому что я слышал, что он щедро заплатил за игру в гольф своими ответами TI-BASIC.

For(X,1,ᴇ7
int(10fPart(X10^(-randIntNoRep(0,1+int(log(X->D
SortA(∟D
If not(sum(remainder(X,Ans+Xnot(Ansmin(ΔList(∟D
Disp X
End

Мое основное изменение заключается randIntNoRep(1,в randIntNoRep(0,том, что теперь в каждом сгенерированном списке цифр будет ноль.

number  |  randIntNoRep  |  digits  |  sorted
9       |  1,0           |  9,0     |  0,9
102     |  3,1,0,2       |  1,2,0,0 |  0,0,1,2

Поскольку теперь в каждом наборе цифр есть ноль, это влияет на сумму остатков. Обычно сумма остатков равна 0, но теперь наличие дополнительного нуля приводит к одному провалу нашего теста делимости.
Чтобы противодействовать этому, я изменился 2Xnot(на Xnot(. Изначально 2 был там, чтобы сделать тест неудачным при 0, но теперь он проходит в нуле. Числа, которые содержат ноль в своих цифрах, однако, теперь имеютmin(ΔList(∟D равно ноль (так как в их списках 2 или более нулей), поэтому это изменение не приводит к тому, что какие-либо дополнительные числа проходят тест.

Преимущество этого метода заключается в том, что, поскольку теперь число «две цифры» производится из числа 1–9, ΔList( функция не выдает ошибку, что позволяет нам избавиться от специального условия для однозначных чисел.


4

05AB1E , 30 22 21 18 14 13 12 9 байт

-9 байт благодаря помощи и поддержке @Enigma и @ Mr.Xcoder . Спасибо, что позволили мне самому разобраться в этом, даже если вы уже имели в виду 12-байтовое решение, когда мне было еще 30. Узнал много о 05AB1E из этого испытания!
-3 байта благодаря @Grimy

7°LʒÐÑÃÙQ

Попробуйте онлайн (выводятся только цифры ниже 10 3 вместо 10 7 чтобы предотвратить тайм-аут через 60 секунд).

Объяснение:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (truthy) remain:
    Ð      #  Triplicate the current number
     Ñ     #  Get the divisors of this number
           #   i.e. 128 → [1,2,4,8,16,32,64,128]
           #   i.e. 1210 → [1,2,5,10,11,22,55,110,121,242,605,1210]
      Ã    #  Only keep those digits/numbers in the original number (which is checked in
           #  order, so it will only keep the digits and ignores the later numbers)
           #   i.e. 128 → 128
           #   i.e. 1210 → 121
       Ù   #  Uniquify the number, removing any duplicated digits
           #   i.e. 128 → 128
           #   i.e. 121 → 12
        Q  #  Check if the number is unchanged after this
           #   i.e. 128 and 128 → 1 (truthy)
           #   i.e. 1210 and 12 → 0 (falsey)

Предыдущая 12-байтовая версия (один из моих самых первых ответов 05AB1E):
ПРИМЕЧАНИЕ. Работает только в устаревшей версии 05AB1E.

7°LʒÐSÖPsDÙQ*

Попробуйте онлайн (выводятся только числа ниже 10 3 вместо 10 7, чтобы предотвратить тайм-аут через 60 секунд).

Объяснение:

7°L        # Generate a list in the range [1, 10^7]
   ʒ       # Filter, so only the numbers that evaluated to 1 (true) remain:
    Ð      #  Triplicate the current number N
     Ù     #  Remove all duplicated digits of the second N
           #   i.e. 1210 → 120
      Q    #  Check if the last two numbers are still the same (1 or 0 as result)
    *      #  Multiply this result with remaining third number from the triplication
     D     #  Duplicate this number, so we have two again
      S    #  Separate all the digits of the second one
           #   i.e. 128 → ['1', '2', '8']
       Ö   #  Check if (the second) N is divisible by each of its digits
           #   i.e. 128 and ['1', '2', '8'] → [1, 1, 1]
           #   (NOTE: If the number contains a '0', it won't error on division by 0,
           #          but instead return the number N itself in the list)
           #   i.e. 105 and ['1', '0', '5'] → [1, 105, 1]
        P  #  Take the product of this list (if the divisible test for one
           #  of the digits was 0, this will be 0 as well)
           #   i.e. [1, 1, 1] → 1
           #   i.e. [1, 105, 1] → 105 (only 1 is truthy in 05AB1E)

Распечатывается ваш ответ 297, которого нет в последовательности чисел Линч-Белла.
Мистер Xcoder

@ Mr.Xcoder Вздох. Сначала нужно было что-то более длинное, чтобы проверить, делится ли число на все его цифры, но решил, что такая проблема существует. Похоже, этот ответ также недействителен. А здесь вы и Enigma говорите о 12-15-байтовых ответах, в то время как мой 30-байтовый ответ даже не работает, смеется. Есть ли где-нибудь учебник? ;п
Кевин Круйссен

1
9 байт: 7°LʒÐÑÃÙQ
Grimmy

@Grimy Один из моих самых первых ответов 05AB1E. :) Хороший подход!
Кевин Круйссен

3

Юлия, 88 байт

print(join(filter(i->(d=digits(i);0d&&d==unique(d)&&all(j->i%j<1,d)),1:9867312)," "))

Это просто берет все числа от 1 до самого большого числа Линч-Белла и фильтрует их до только чисел Линч-Белла.

Ungolfed:

lynch = filter(i -> (d = digits(i);
                     0  d &&
                     d == unique(d) &&
                     all(j -> i % j == 0, d)),
               1:9867312)

print(join(lynch, " "))

3

Python 2, 101 байт

print[i for i in range(6**9)if'0'not in`i`and len(set(`i`))==len(`i`)and all(i%int(k)==0for k in`i`)]

Вы можете опустить print в интерпретаторе значение до 96. Используется, 6**9так как это 8 цифр, а наибольшее число в понедельник - всего 7 цифр, что-то вроде 9**9бы, вероятно, займет много времени, 6 ** 9 - всего около 10 секунд.


Как указано на пару вопросов, 1e7 короче, чем оба
Holloway

@Trengot 1e7- это число с плавающей точкой, диапазон принимает целые числа.
Рохкана

Очень верно. Я не думал об этом
Holloway

3

Perl, 97 байт

print+($n=$_,$/)x(!/0/&(y///c==grep{2>eval"$n=~y/$_//"}/./g)&&y///c==grep!($n%$_),/./g)for 1..1e7

Требуется некоторое время для запуска, но выдает требуемый результат, перейдите к 1e3более быстрому примеру!


Я не в состоянии попробовать это в данный момент, но вместо того y///c==grep{2>eval"$n=~y/$_//"}/./g, чтобы вы могли использовать что-то вроде !/(.).*\1/?
msh210

@ msh210 Почти наверняка! Я думаю, что это было бы моим заданием по умолчанию сейчас, но изменение этого только закончило бы тем, что приблизило бы это к ответам Стива или Ярмекса , которые намного превосходят! Спасибо, что посмотрели, хотя!
Дом Гастингс

3

MATLAB, 100

o=49;for n=2:1e7 a=num2str(n);if all([diff(sort(a)) a~=48 ~mod(n,a-48)]) o=[o ',' a];end;end;disp(o)

И в более читаемом формате:

o=49;  %1 is always in there, so add the ASCII value. This prevents there being a ',' prefixed.
for n=2:1e7 
    a=num2str(n);
    if (all([diff(sort(a)) a~=48 ~mod(n,a-48)]))
        o=[o ',' a];
    end
end
disp(o)

В основном это считается через каждое число между 1 а также 1×107и проверяет, являются ли они номером понедельника. Каждое число преобразуется в строку, так что цифры могут быть обработаны индивидуально.

Проверки заключаются в следующем:

  1. Сначала проверьте, есть ли дубликаты. Сортировка массива, если разница между любыми последовательными цифрами равна нулю, то есть дубликаты

    diff(sort(a))
    
  2. Проверьте, есть ли нули. ASCII для 0 - 48, поэтому мы проверяем, что все цифры не равны этому.

    a~=48
    
  3. Проверьте, делится ли он на все его цифры. Мы проверяем, что остаток при делении на каждую цифру (преобразованный из ASCII в десятичную, следовательно, -48) равен нулю.

    ~mod(n,a-48)
    

Наконец, мы all()проверяем , что проверки верны, и если это так, мы добавляем его к выходной строке через запятую.

У MATLAB нет STDOUT, поэтому вместо этого я печатаю строку результата в конце, используя disp()


Этот код медленный! Я все еще запускаю его, чтобы убедиться, что он правильно находит все числа понедельника, но пока выглядит хорошо.

Обновить:

Код закончил работу. Он печатает следующее:

1,2,3,4,5,6,7,8,9,12,15,24,36,48,124,126,128,132,135,162,168,175,184,216,248,264,312,315,324,384,396,412,432,612,624,648,672,728,735,784,816,824,864,936,1236,1248,1296,1326,1362,1368,1395,1632,1692,1764,1824,1926,1935,1962,2136,2184,2196,2316,2364,2436,2916,3126,3162,3168,3195,3216,3264,3276,3492,3612,3624,3648,3816,3864,3915,3924,4128,4172,4236,4368,4392,4632,4872,4896,4932,4968,6132,6192,6312,6324,6384,6432,6912,6984,8136,8496,8736,9126,9135,9162,9216,9315,9324,9432,9612,9648,9864,12384,12648,12768,12864,13248,13824,13896,13968,14328,14728,14832,16248,16824,17248,18264,18432,18624,18936,19368,21384,21648,21784,21864,23184,24168,24816,26184,27384,28416,29736,31248,31824,31896,31968,32184,34128,36792,37128,37296,37926,38472,39168,39816,41328,41832,42168,42816,43128,43176,46128,46872,48216,48312,61248,61824,62184,64128,68712,72184,73164,73248,73416,73962,78624,79128,79632,81264,81432,81624,81936,82416,84216,84312,84672,87192,89136,89712,91368,91476,91728,92736,93168,93816,98136,123648,123864,123984,124368,126384,129384,132648,132864,132984,134928,136248,136824,138264,138624,139248,139824,142368,143928,146328,146832,148392,148632,149328,149832,162384,163248,163824,164328,164832,167328,167832,168432,172368,183264,183624,184392,184632,186432,189432,192384,193248,193824,194328,194832,198432,213648,213864,213984,214368,216384,218736,219384,231648,231864,231984,234168,234816,236184,238416,239184,241368,243168,243768,243816,247968,248136,248976,261384,263184,273168,281736,283416,284136,291384,293184,297864,312648,312864,312984,314928,316248,316824,318264,318624,319248,319824,321648,321864,321984,324168,324816,326184,328416,329184,341928,342168,342816,346128,348192,348216,348912,349128,361248,361824,361872,362184,364128,364728,367248,376824,381264,381624,382416,384192,384216,384912,391248,391824,392184,394128,412368,413928,416328,416832,418392,418632,419328,419832,421368,423168,423816,427896,428136,428736,431928,432168,432768,432816,436128,438192,438216,438912,439128,461328,461832,463128,468312,469728,478296,478632,481392,481632,482136,483192,483216,483672,483912,486312,489312,491328,491832,493128,498312,612384,613248,613824,613872,614328,614832,618432,621384,623184,623784,627984,631248,631824,632184,634128,634872,641328,641832,643128,648312,671328,671832,681432,684312,689472,732648,732816,742896,746928,762384,768432,783216,789264,796824,813264,813624,814392,814632,816432,819432,823416,824136,824376,831264,831624,832416,834192,834216,834912,836472,841392,841632,842136,843192,843216,843912,846312,849312,861432,864312,873264,891432,894312,897624,912384,913248,913824,914328,914832,918432,921384,923184,927864,931248,931824,932184,934128,941328,941832,943128,948312,976248,978264,981432,984312,1289736,1293768,1369872,1372896,1376928,1382976,1679328,1679832,1687392,1738296,1823976,1863792,1876392,1923768,1936872,1982736,2137968,2138976,2189376,2317896,2789136,2793168,2819376,2831976,2931768,2937816,2978136,2983176,3186792,3187296,3196872,3271968,3297168,3298176,3619728,3678192,3712968,3768912,3796128,3816792,3817296,3867192,3869712,3927168,3928176,6139728,6379128,6387192,6389712,6391728,6719328,6719832,6731928,6893712,6913872,6971328,6971832,7168392,7198632,7231896,7291368,7329168,7361928,7392168,7398216,7613928,7639128,7829136,7836192,7839216,7861392,7863912,7891632,7892136,7916328,7916832,7921368,8123976,8163792,8176392,8219736,8312976,8367912,8617392,8731296,8796312,8912736,8973216,9163728,9176328,9176832,9182376,9231768,9237816,9278136,9283176,9617328,9617832,9678312,9718632,9723168,9781632,9782136,9812376,9867312

Который, если вы запустите этот код с этим в качестве ввода:

nums = length(strsplit(stdout,','))

Yeilds 548.


3

Руби, 79

?1.upto(?9*7){|s|a=s.chars;a.uniq!||a.any?{|x|x<?1||0<eval([s,x]*?%)}||puts(s)}

Более интересное, но немного более длинное решение с регулярным выражением:

?1.upto(?9*7){|s|s[/(.).*\1|[0#{(1..9).map{|*x|x*eval([s,x]*?%)}*''}]/]||puts(s)}

В каждом случае мы используем возможность Руби перебирать строки, как если бы они были десятичными целыми числами: ?1.upto(?9*7)эквивалентно 1.upto(9999999).map(&:to_s).each. Мы соединяем строку с каждой ненулевой цифрой, используя оператор по модулю, и оцениваем результат, чтобы проверить делимость.

Решение Bonus Ruby 1.8 ( -lдля правильного вывода требуется флаг):

'1'.upto('9'*7){|$_|~/(.).*\1|[0#{(1..9).map{|*x|x*eval("#$_%#{x}")}}]/||print}

1.8 позволил итератору блока быть глобальной переменной. Назначение $_делает его неявным получателем для строковых операций. Мы также упрощаем интерполяцию массивов в регулярное выражение: в 1.8 /[#{[1,2]}]/оценивается как /[12]/.


Теперь, когда в Ruby 2.4 есть digitsфункция для целых чисел , вы можете сохранить байты от взлома eval, поскольку вы больше не работаете со строками!63 байта.
Value Ink

3

Пип , 25 байт

Fa,t**7Ia#=UQa&0=$+a%^aPa

Выводит каждый номер в отдельной строке. Это продолжалось около 10 минут и до сих пор доходило до 984312, но я уверен, что это правильно. (Изменить: пару часов спустя ... код закончен, сгенерировано все 548 из них.)

Вот представление псевдокода Python-esque:

for a in range(10**7):
  if lengthEqual(a, set(a)) and 0 == sum(a%d for d in digits(a)):
    print(a)

#=Оператор сравнивает два итерируемых по длине. Если число UNi QUe символов в aодно и то же , как число символов a, нет повторов.

Проверка, делимая на каждую цифру, производится в одной из моих примеров программ Pip. Я написал это после просмотра предыдущий вызов , но не разместил его там, потому что язык был новее, чем вопрос. В противном случае, при 8 байтах, это был бы победный ответ на этот вопрос. Вот пошаговое объяснение:

      ^a   Split num into an array of its digits
    a%     Take num mod each of those digits; if a digit is zero, the result will be nil
  $+       Sum the resulting list (note: summing a list containing nil results in nil!)
0=         Iff the sum equals 0, return 1 (true); otherwise (>0 or nil), return 0 (false)

Это довольно аккуратный язык! Приятно видеть что-то еще, кроме игры в стек.
AdmBorkBork

1
@TimmyD Если вы хотите увидеть не основанный на стеке гольф, то, как правило, вокруг немало Pyth.
Рето Коради

@RetoKoradi Но если вы хотите увидеть не-стек игры в гольф с инфиксными операторами , Pip для вас. ; ^)
DLosc

Couple hours laterХорошо, что производительность не учитывается.
Holloway

3

Javascript (ES6), 106 90 83 байта

Дети, не пытайтесь делать это дома; JS не будет доволен возможностью перебирать каждую цифру каждого целого числа от одного до десяти миллионов с помощью регулярного выражения.

for(i=0;i<1e7;i++)/(.).*\1|0/.test(i)||+`${i}`.replace(/./g,j=>i%j)||console.log(i)

Первое регулярное выражение (относится к @Jarmex) возвращается, trueесли число содержит повторяющиеся цифры или нули. Если это получается false, программа переходит ко второму, который заменяет каждую цифруj на i%j. Результатом являются все нули, если он делится на все его цифры, и в этом случае он переходит кconsole.log(i) .

Предложения приветствуются!


3

JavaScript (ES6), 76

/* Answer below. For testing purpose, redirect consoloe.log */ console.log=x=>document.write(x+' ')

for(i=0;i++<1e7;)/0|(.).*\1/.test(i)||[...i+''].some(d=>i%d)||console.log(i)

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

вот объяснение семизначного макс.


3

Рубин, 130 байт

... не считая пробелов

Новичок в программировании, просто хотел участвовать

c=0
(0..10**7).each do |x| 
  a=x.to_s.split('')
  c+=1 if !a.include?('0')&& a.uniq!.eql?(nil)&&a.all?{|y| x.modulo(y.to_i).zero?} 
end
p c

2
Добро пожаловать в PPCG! Ознакомьтесь с некоторыми дополнительными советами для Ruby, которые помогут уменьшить длину кода.
AdmBorkBork

3

C 122 байта

i,j,m,a;void f(){for(i=1;i<1e8;++i){for(m=0,j=i;j;j/=10){a=j%10;if(!a||m&(1<<a)||i%a)goto n;m|=1<<a;}printf("%d ",i);n:;}}

Красивее:

i,j,m,a;
void f()
{
    for (i=1; i<1e8; ++i){
        for (m=0, j=i;  j;  j/=10) {
            a = j%10;
            if (!a || m&(1<<a) || i%a)
                goto n;
            m|=1<<a;
        }
        printf("%d ",i);
    n:;
    }
}

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


Хорошо, что gotoкоманда используется.
Шон Бебберс


2

Луа, 129 байт

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

for i=1,1e7 do t={[0]=1}j=i while j>0 do c=j%10 if t[c]or i%c>0 then break end t[c]=1 j=(j-c)/10 if j==0 then print(i)end end end

2

gawk, 99 байт

BEGIN{for(;8>(l=split(++i,a,_));printf f?f=_:i RS)for(j in a)f=i~0||i%(d=a[j])||i-d*10^(l-j)~d?1:f}

Я мог бы уменьшить это до 97, если бы использовал ENDвместо BEGIN, но тогда вам нужно было бы нажать Ctrl-D, чтобы начать фактический вывод, сигнализируя, что не будет никакого ввода.

Я мог бы уменьшить его до 94, если бы ничего не писал вместо BEGINили END, но тогда вам нужно было бы нажать клавишу возврата один раз, чтобы запустить его, что можно было бы считать вводом.

Он просто просматривает цифры каждого номера и проверяет, удовлетворены ли критерии.

я ~ 0: число содержит `0`? -> мусор
i% (d = a [j]): число, не делимое на текущую цифру? -> мусор
id * 10 ^ (lj) ~ d: я удалил текущую цифру из номера, но это
                  : все еще содержит это? -> мусор

Требуется 140 секунд, чтобы завершиться на моем Core 2 Duo.


2

Желе , 11 байт

9œ!ṖẎgḌ$ƑƇḌ

Это использует двухнедельный œ!атом. На самом деле достаточно быстро, чтобы работать на TIO.

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

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

9œ!ṖẎgḌ$ƑƇḌ  Main link. No arguments.

9            Set the return value to 9.
   R         Pop; yield [1, ..., 8].
 œ!          Promote 9 to [1, ..., 9] and generate all permutations of length k,
             each k in the right argument [1, ..., 8].
    Ẏ        Tighten; dump all digit lists in a single array.
         Ƈ   Comb; keep only digit lists for which the link to the left returns 1.
        Ƒ      Fixed; return 1 iff calling the link to the left returns its argument.
       $         Combine the two links to the left into a monadic chain.
      Ḍ            Undecimal; convert the digit list into an integer.
     g             Take the GCD of each digit and the integer.
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.