Ворожі числа дільника


31

Деякі подільники натуральних чисел дійсно ненавидять один одного, і вони не люблять ділитися однією або кількома загальними цифрами.

Ці цілі числа називаються числами ворожих дільниць ( HDN )

Приклади

Число 9566має 4дільники: 1, 2, 4783 and 9566
(як бачите, жоден з них не ділиться однаковою цифрою ).
Таким чином, 9566 являє собою Н ostile D ivisor N умбри

Номер 9567є НЕ ГБН , тому що його подільники ( 1, 3, 9, 1063, 3189, 9567) мають деякі загальні цифри.

Ось перші кілька HDN

1,2,3,4,5,6,7,8,9,23,27,29,37,43,47,49,53,59,67,73,79,83,86,87,89,97,223,227,229,233,239,257,263,267,269,277,283,293,307,337...       


Завдання

Наведений вище список продовжується, і ваше завдання - знайти n-й HDN

Вхідні дані

Позитивне ціле число nвід 1до4000

Вихід

nth ГБН

Випробування

Ось кілька тестових випадків, які індексуються 1 .
Будь ласка, вкажіть, яку систему індексації ви використовуєте у своїй відповіді, щоб уникнути плутанини.

input -> output     
 1        1     
 10       23       
 101      853     
 1012     26053     
 3098     66686      
 4000     85009      

Це , тому виграє найнижчий бал у байтах.

EDIT

Гарні новини! Я подав свою послідовність в OEIS і ...
Номери ворожих дільниць тепер OEIS A307636


1
Я думаю, що квадратні числа були б найменш ворожими числами.
Фрамбот

3
@JoeFrambach Що я не розумію. Є ідеальні квадратні HDN. Для дещо великого прикладу, 94699599289квадрат 307733, має дільники, [1, 307733, 94699599289]що показує, що це HDN. Здається мені вороже.
Джеппе Стіг Нільсен

@JeppeStigNielsen Для набагато меншого прикладу, чому б не просто 49? Фактори [1, 7, 49]кваліфікуються як ворожі ... Або ж добре 4: [1, 2, 4]...
Даррель Гофман

@DarrelHoffman Не кажучи вже про квадратне число 1зі списком дільника [1]. (Можливо, великі HDN цікавіші?)
Jeppe Stig Nielsen

Я інтерпретував 49як дільники [7, 7] , які не тільки ділять цифри, але є однаковими цифрами. 49має фактори [1, 7, 49]
Frambot

Відповіді:


9

05AB1E , 12 10 байт

µNNÑ€ÙSDÙQ

-2 байти завдяки @Emigna .

1-індексований

Спробуйте в Інтернеті або перевірте більшість тестових випадків (останні два тестові випадки опущені, оскільки вони закінчуються).

Пояснення:

µ           # Loop while the counter_variable is not equal to the (implicit) input yet:
 N          #  Push the 0-based index of the loop to the stack
  NÑ        #  Get the divisors of the 0-based index as well
            #   i.e. N=9566 → [1,2,4783,9566]
            #   i.e. N=9567 → [1,3,9,1063,3189,9567]
    €Ù      #  Uniquify the digits of each divisor
            #   → ["1","2","4783","956"]
            #   → ["1","3","9","1063","3189","9567"]
      S     #  Convert it to a flattened list of digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","1","0","6","3","3","1","8","9","9","5","6","7"]
       D    #  Duplicate this list
        Ù   #  Unique the digits
            #   → ["1","2","4","7","8","3","9","5","6"]
            #   → ["1","3","9","0","6","8","5","7"]
         Q  #  And check if it is still equal to the duplicated list
            #   → 1 (truthy)
            #   → 0 (falsey)
            #  And if it's truthy: implicitly increase the counter_variable by 1
            # (After the loop: implicitly output the top of the stack,
            #  which is the pushed index)

2
Цього разу ти побив мене. У мене було µNNÑ€ÙSDÙQза 10.
Емінья

2
@Emigna Ага, я просто працював над альтернативою µ, тому ти врятуєш мені неприємності. ;)
Кевін Круїссен

це поетично красномовно
нехай яскраво


6

JavaScript (ES6), 78 байт

1-індексований.

n=>eval("for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););k")

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

Швидша версія, 79 байт

n=>{for(k=0;n;n-=!d)for(s=d=++k+'';k%--d||d*!s.match(`[${s+=d,d}]`););return k}

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

Як?

Давши ціле число k>0 , ми будуємо рядок s як конкатенацію всіх дільників k .

Оскільки k завжди є дільником самого себе, s ініціалізується на k (примусово до рядка), і перший дільник, який ми намагаємося, d=k1 .

Для кожного дільника d на k ми перевіряємо, чи можна знайти будь-яку цифру d у s , повернувши d у набір символів у регулярному виразі.

Приклади

  • s="956647832" ,d=1"956647832".match(/[1]/)- хибний
  • s="9567" ,d=3189"9567".match(/[3189]/)є правдою

Прокоментував

Це версія без eval(), для читабельності

n => {                   // n = input
  for(                   // for() loop:
    k = 0;               //   start with k = 0
    n;                   //   go on until n = 0
    n -= !d              //   decrement n if the last iteration resulted in d = 0
  )                      //
    for(                 //   for() loop:
      s =                //     start by incrementing k and
      d = ++k + '';      //     setting both s and d to k, coerced to a string
      k % --d ||         //     decrement d; always go on if d is not a divisor of k
      d *                //     stop if d = 0
      !s.match(          //     stop if any digit of d can be found in s
        `[${s += d, d}]` //     append d to s
      );                 //
    );                   //   implicit end of inner for() loop
                         // implicit end of outer for() loop
  return k               // return k
}                        //

6

Желе , 10 байт

ÆDQ€FQƑµ#Ṫ

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

-1 байт завдяки ErikTheOutgolfer

Бере вхід від STDIN, що незвично для Jelly, але нормально, де nfindвикористовується.

ÆDQ€FQƑµ#Ṫ  Main link
         Ṫ  Get the last element of
        #   The first <input> elements that pass the filter:
ÆD          Get the divisors
  Q€        Uniquify each (implicitly converts a number to its digits)
    F       Flatten the list
     QƑ     Does that list equal itself when deduplicated?

2-індексований


це 2-індексований? Зі мною це нормально, але будь ласка,
заявіть про

Все, що було у ваших тестових випадках, тому 1
HyperNeutrino

3
Ні, це не так. 101 повертає 839. і 102 -> 853. Це добре, але це 2-індексується
J42161217

1
@ J42161217 чекати що? Я здогадуюсь, коли я перемістив nfindйого, змінив індексацію лол
HyperNeutrino

1
⁼Q$те саме, що .
Ерік Аутгольфер

4

Perl 6 , 53 байти

{(grep {/(.).*$0/R!~~[~] grep $_%%*,1..$_},^∞)[$_]}

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

1-індексований.

/(.).*$0/ відповідає будь-якому номеру з повторною цифрою.

grep $_ %% *, 1 .. $_повертає список усіх дільників кількості, яка $_зараз перевіряється на приналежність до списку.

[~]об'єднує всі ці цифри разом, а потім R!~~порівнює рядок праворуч проти шаблону зліва. ( ~~є звичайним оператором відповідності, !~~є запереченням цього оператора і Rє метаоператором, який міняється аргументами !~~.)




3

Мова Вольфрама 103 байти

Використовує 1-індексацію. Я здивований, що потрібно так багато коду.

(k=1;u=Union;n=2;l=Length;While[k<#,If[l[a=Join@@u/@IntegerDigits@Divisors@#]==l@u@a&@n,k++];n++];n-1)&

Чи можете ви, будь ласка, додати посилання TIO, щоб усі могли перевірити вашу відповідь?
J42161217

95 байт: (n=t=1;While[t<=#,If[!Or@@IntersectingQ@@@Subsets[IntegerDigits@Divisors@n,{2}],t++];n++];n-1)&Я не збираюся публікувати відповідь, тому я залишу це тут
J42161217

@ J42161217, я намагався без проблем дозволити коду працювати в TIO. Має бути якийсь трюк, якого я сумую.
DavidC

@ J42161217, ваш код, здається, працює, але триває тривалість виконання. Ви можете подати його як власний. (Можливо, я навчусь реалізовувати TIO з вашого прикладу.)
DavidC

Дуже швидко! ось ваше посилання Спробуйте в Інтернеті!
J42161217

3

PowerShell , 112 байт

for($a=$args[0];$a-gt0){$z=,0*10;1..++$n|?{!($n%$_)}|%{"$_"|% t*y|sort -u|%{$z[+"$_"]++}};$a-=!($z|?{$_-ge2})}$n

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

Бере 1-індексований вхід $args[0], зберігає його в $a, циклічне, поки це не потрапить 0. Кожну ітерацію ми знімаємо нульовий масив з десятьма елементами $z(використовується для обчислення цифр). Тоді ми будуємо наш список дільників за допомогою 1..++$n|?{!($n%$_)}. Для кожного дільника ми кидаємо його на рядок "$_", кидаємо на toCharArra yі sortці цифри з -uпрапором nique (тому що нам не байдуже, чи є у дільника сам подвійні цифри). Потім збільшуємо відповідний підрахунок цифр у $z. Потім ми декрементуємо $aлише у тому випадку, якщо вони $zмістять 0s і 1s (тобто ми знайшли HDN). Якщо ми закінчили forцикл, це означає, що ми знайшли відповідну кількість HDN, тож ми залишаємо $nна конвеєрі і вихід неявний.


ви можете зберегти кілька байт: $a-=!($z-ge2)замість цього$a-=!($z|?{$_-ge2})
mazzy


3

Python 3 , 115 байт

1-індексований

f=lambda n,x=1,s="",l="",d=1:n and(d>x+1and f(n-1,x+1)or{*s}&{*l}and f(n,x+1)or f(n,x,s+l,(1-x%d)*str(d),d+1))or~-x

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

Для цього використовується багато рекурсії; навіть при підвищеному обмеженні рекурсії це не може зробити f(30). Я думаю, що це може бути ігорним, і я спробував знайти щось на заміну (1-x%d), але не зміг нічого придумати ( -~-x%dмає неправильний пріоритет). Будь-які байти, які можна поголити, дуже вдячні.

Як це працює

# n: HDNs to go
# x: Currently tested number
# s: String of currently seen divisor digits
# l: String of digits of last tried divisor if it was a divisor, empty string otherwise
# d: Currently tested divisor

f=lambda n,x=1,s="",l="",d=1:n and(                    # If there are still numbers to go
                             d>x+1and f(n-1,x+1)or     # If the divisors have been
                                                       #  exhausted, a HDN has been found
                             {*s}&{*l}and f(n,x+1)or   # If there were illegal digits in
                                                       #  the last divisor, x isn't a HDN
                             f(n,x,s+l,(1-x%d)*str(d),d+1)
                                                       # Else, try the next divisor, and
                                                       #  check this divisor's digits (if
                                                       #  if is one) in the next call
                             )or~-x                    # Else, return the answer

2

Брахілог (v2), 14 байт

;A{ℕfdᵐc≠&}ᶠ⁽t

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

Подання функції; вхід зліва, вихід праворуч. (Посилання TIO містить аргумент командного рядка для запуску функції як би повноцінною програмою.)

Пояснення

"Це ворожий дільник?" код :

ℕfdᵐc≠
ℕ       number is ≥0 (required to match the question's definition of "nth solution")
 f      list of all factors of the number
   ᵐ    for each factor
  d       deduplicate its digits
    c   concatenate all the deduplications with each other
     ≠  the resulting number has no repeated digits

Це в основному те саме, що і @ UnrelatedString's, хоча я писав це самостійно.

Обгортка "n-го вирішення ":

;A{…&}ᶠ⁽t
    &      output the successful input to
  {  }ᶠ    the first n solutions of the problem
       ⁽   taking <n, input> as a pair
;A         form a pair of user input and a "no constraints" value
        t  take the last solution (of those first n)

Це один з тих випадків, коли обгортка, необхідна для отримання n-го виводу, значно довша, ніж код, необхідний для тестування кожного виходу по черзі :-)

Я придумав цю обгортку незалежно від @ UnrelatedString's. Це однакова довжина і працює за тим же принципом, але якось інакше пишеться зовсім інакше. Він має більше потенційних можливостей для вдосконалення, оскільки ми могли б додавати обмеження щодо того, які значення ми шукали безкоштовно, замінивши Aякусь змінну обмеження, але жодна з можливих змінних обмежень не зберігає байти. (Якщо існувала змінна обмеження "невід'ємне ціле", ви можете замінити Aїї, а потім зберегти байт, зробивши непотрібне.)


Це 2-індексований?
FrownyFrog

2

Java 10, 149 139 138 126 125 120 119 байт

n->{int r=0,i,d;for(;n>0;n-=d){var s="1";for(r+=d=i=1;i++<r;)if(r%i<1){d=s.matches(".*["+i+"].*")?0:d;s+=i;}}return r;}

-10 байт, використовуючи .matchesзамість .containsцифри, натхненну відповіддю @Arnauld JavaScript .
-5 байт завдяки @ValueInk
-1 байт завдяки @ceilingcat

1-індексований

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

Пояснення:

n->{                 // Method with integer as both parameter and return-type
  int r=0,           //  Result-integer, starting at 0
      i,             //  Index integer
      d;             //  Decrement integer
  for(;n>0;          //  Loop until the input `n` is 0:
      n-=d){         //    After every iteration: decrease `n` by the decrement integer `d`
    var s="1";       //   Create a String `s`, starting at "1"
    for(r+=d=i=1;    //   (Re)set the decrement and index integers to 1,
                     //   and increase the result by 1 as well
        i++<r;)      //   Inner loop `i` in the range [2, r]:
      if(r%i<1){     //    If `r` is divisible by `i`:
        d=s.matches(".*["+i+"].*")?
                     //     If string `s` contains any digits also found in integer `i`:
           0         //      Set the decrement integer `d` to 0
          :d;        //     Else: leave `d` unchanged
        s+=i;}}      //     And then append `i` to the String `s`
  return r;}         //  After the loops, return the result `r`


@ValueInk Дякую! :)
Кевін Круїссен

1

Брахілог , 16 байт

g{∧0<.fdᵐc≠∧}ᵘ⁾t

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

Дуже повільно і вдвічі довше, ніж це було б, якби це було . 1-індексований.

                    The output
               t    is the last
             ᵘ⁾     of a number of unique outputs,
g                   where that number is the input,
 {          }       from the predicate declaring that:
     .              the output
    <               which is greater than
   0                zero
  ∧                 (which is not the empty list)
      f             factorized
        ᵐ           with each factor individually
       d            having duplicate digits removed
          ≠         has no duplicate digits in
         c          the concatenation of the factors
           ∧        (which is not the output).

1
Якщо ви просто прочитали це пояснення як вирок ...
FireCubez

Я намагаюся писати свої пояснення, як звичайна англійська, яка, як правило, закінчується просто важкою для читання
Непов’язана струна


1

Japt v2.0a0, 17 байт

_=â ®sâìUµZ¶â}f1

Спробуй це

Порт цієї Брахілогічної відповіді .

Кредит: загальна економія 4 байтів завдяки Шаггі, який також припустив, що існує краще рішення, що призводить до набагато більше байтів :)


Оригінальна відповідь: 28 байт:

Èâ¬rÈ«è"[{Y}]" ©X+Y}Xs)«U´Ãa

Спробуй це

Порт цієї відповіді на JavaScript .



Приємно - я раніше не користувався «ярликом :) Я вважаю, що Shaggy покращується на моєму рахунку лише жменю байтів, я мушу бути дещо пристойним у цьому?
дата

Це можна зробити в 20 (можливо менше) b7, використовуючи дещо інший метод.
Кудлатий

Так, я думаю, що я говорив занадто рано :) Так, деякі інші гравці з гольфу мають набагато коротші рішення.
дата






0

J, 87 59 bytes

-28 bytes thanks to FrownFrog

0{(+1,1(-:~.)@;@(~.@":&.>@,i.#~0=i.|])@+{.)@]^:(>{:)^:_&0 0

Try it online!

original

J, 87 bytes

[:{:({.@](>:@[,],([:(-:~.)[:-.&' '@,/~.@":"0)@((]#~0=|~)1+i.)@[#[)}.@])^:(#@]<1+[)^:_&1

Try it online!

Yikes.

This is atrociously long for J, but I'm not seeing great ways to bring it down.

explanation

It helps to introduce a couple helper verbs to see what's happening:

d=.(]#~0=|~)1+i.
h=. [: (-:~.) [: -.&' '@,/ ~.@":"0
  • d returns a list of all divisors of its argument
  • h tells you such a list is hostile. It stringifies and deduplicates each number ~.@":"0, which returns a square matrix where shorter numbers are padded with spaces. -.&' '@,/ flattens the matrix and removes spaces, and finally (-:~.) tells you if that number has repeats or not.

With those two helpers our overall, ungolfed verb becomes:

[: {: ({.@] (>:@[ , ] , h@d@[ # [) }.@])^:(#@] < 1 + [)^:_&1

Here we maintain a list whose head is our "current candidate" (which starts at 1), and whose tail is all hostile numbers found so far.

We increment the head of the list >:@[ on each iteration, and only append the "current candidate" if it is hostile h@d@[ # [. We keep doing this until our list length reaches 1 + n: ^:(#@] < 1 + [)^:_.

Finally, when we're done, we return the last number of this list [: {: which is the nth hostile number.




This is great, many thanks. Will go over it and update tonight
Jonah

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.