Являюсь ли я «повторяющимся» номером?

26

Редивозит - это слово портманто, придуманное для единственной цели этого вызова. Это смесь сокращения, деления и составного.

Определение

Дано целое число N> 6 :

  • Если N простое, N не является перенаправляющим числом.
  • Если N является составным:
    • многократно вычислять N '= N / d + d + 1 до тех пор, пока N не станет простым, где d - наименьший делитель N, больший 1
    • N - это противоположное число, если и только если конечное значение N ' является делителем N

Ниже приведены 100 первых номеров повторяющихся номеров (нет записи OEIS на момент публикации):

14,42,44,49,66,70,143,153,168,169,176,195,204,260,287,294,322,350,414,462,518,553,572,575,592,629,651,702,726,735,775,806,850,869,889,891,913,950,1014,1023,1027,1071,1118,1173,1177,1197,1221,1235,1254,1260,1302,1364,1403,1430,1441,1554,1598,1610,1615,1628,1650,1673,1683,1687,1690,1703,1710,1736,1771,1840,1957,1974,2046,2067,2139,2196,2231,2254,2257,2288,2310,2318,2353,2392,2409,2432,2480,2522,2544,2635,2640,2650,2652,2684,2717,2758,2760,2784,2822,2835

Примеры

  • N = 13 : 13 простое число, поэтому 13 не является повторяющимся числом
  • N = 32 : 32/2 + 3 = 19; 19 не является делителем или 32, поэтому 32 не является перенаправляющим числом
  • N = 260 : 260/2 + 3 = 133, 133/7 + 8 = 27, 27/3 + 4 = 13; 13 - это делитель или 260, поэтому 260 - это число с повторным значением

Твое задание

  • Если задано целое число N , вернуть истинное значение, если это число с повторным значением или ложное значение в противном случае. (Вы также можете вывести любые два различных значения, если они согласованы.)
  • Вход гарантированно будет больше 6 .
  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах!
code-golf  decision-problem  integer  division 
— Arnauld
источник
13
Я действительно хотел бы, чтобы все эти проблемы «числовых последовательностей», которые являются просто последовательностями чисел с определенным свойством, просто задавались как проблемы решения. Я очень сомневаюсь, что есть какой-либо способ генерировать их напрямую, поэтому единственно возможное решение - это решить проблему решения и затем обернуть ее в цикл, который находит N-е или первое N или все целые числа, которые удовлетворяют этому свойству.
— Мартин Эндер
3
Мне нравятся проблемы последовательности , которые не являются проблемой решения вообще, но для этой я думаю, что проблема решения была бы более подходящей. Я не вижу никакой связи между терминами, так что вы печатаете n- й или первый n умным способом, поэтому, возможно, разрешите принять n в качестве входных данных и проверить, если это переделан ?
— г-н Xcoder
1
@MartinEnder & Mr.Xcoder Это было мое первоначальное намерение (отсюда и оригинальное название, к которому я только что откатился), и я передумал. Я думаю, это не должно разрушить любое решение WIP (по причинам, которые вы говорите), поэтому я отредактировал его.
— Арно
5
@ Mr.Xcoder Да, именно это я и имел в виду. Я не против последовательности задач, которые на самом деле имеют смысл как последовательность (либо потому, что вы можете вычислитьa(n) напрямую, либо потому, что вы можете вычислить термин из предыдущих). Спасибо, Арно, за изменение задачи. :)
— Мартин Эндер

Ответы:

9

Хаскелл, 91 85 83 80 75 74 байта

n#m=([n#(div m d+d+1)|d<-[2..m-1],mod m d<1]++[mod n m<1&&m<n])!!0
f x=x#x

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

f x=x#x                           -- call # with x for both parameters
n#m               
         |d<-[2..m-1],mod m d<1   -- for all divisors d of m
    [n#(div m d+d+1)           ]  -- make a list of recursive calls to #,
                                  -- but with m set to m/d+d+1
   ++ [mod n m<1&&m<n]            -- append the Redivosite-ness of n (m divides n,
                                  -- but is not equal to n)
                           !!0    -- pick the last element of the list
                                  -- -> if there's no d, i.e. m is prime, the
                                  --    Redivosite value is picked, else the
                                  --    result of the call to # with the smallest d

Изменить: -2 байта благодаря @BMO, -3 байта благодаря @ H.PWiz и -5 -6 байтов благодаря @ Ørjan Johansen

— Ними
источник
2
— Орджан Йохансен
На самом деле, сделать это 74
— Орджан Йохансен
@ ØrjanJohansen: Еще раз спасибо.
— Ними
6

Шелуха , 14 байт

?¬Ṡ¦ΩṗoΓ~+→Πpṗ

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

-3 спасибо H.PWiz .

— Эрик Outgolfer
источник
14 байтов с функцией очистки внутриΩ
— H.PWiz
@ H.PWiz просто не может понять Γ...
— Эрик Outgolfer
Здесь Γ, учитывая список [a, b, c ...] будет применяться ~+→Πк aи [b,c...]. ~+→Πдобавляет a+1к product[b,c...]. aэто наименьший делитель, product[b,c...]этоN/d
— H.PWiz
@ H.PWiz И я подумал об использовании основных факторов ...
— Эрик Outgolfer
6

C (gcc) , 94 89 байт

m,n;o(k){for(m=1;m++<k;)if(k%m<1)return m;}
F(N){for(n=N;m=o(n),m-n;n=n/m-~m);N=m<N>N%n;}

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

объяснение

m,n;                  // two global integers
o(k){                 // determine k's smallest divisor
 for(m=1;m++<k;)      // loop through integers 2 to n (inclusive)
  if(k%m<1)return m;} // return found divisor
F(N){                 // determine N's redivosity
 for(n=N;             // save N's initial value
  m=o(n),             // calculate n's smallest divisor (no name clash regarding m)
  m-n;                // loop while o(n)!=n, meaning n is not prime
                      //  (if N was prime, the loop will never be entered)
  n=n/m-~m);          // redivosite procedure, empty loop body
 N=m<N>N%n;}          // m<N evaluates to 0 or 1 depending on N being prime,
                      //  N%n==0 determines whether or not N is divisible by n,
                      //  meaning N could be redivosite => m<N&&N%n==0
                      //  <=> m<N&&N%n<1 <=> m<N&&1>N%n <=> (m<N)>N%n <=> m<N>N%n
— Джонатан Фрех
источник
4

Желе , 14 байт

ÆḌḊ
Ç.ịS‘µÇ¿eÇ

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

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

ÆḌḊ         Helper link. Argument: k

ÆḌ          Yield k's proper (including 1, but not k) divisors.
  Ḋ         Dequeue; remove the first element (1).


Ç.ịS‘µÇ¿eÇ  Main link. Argument: n

     µ      Combine the links to the left into a chain.
      Ç¿    While the helper link, called with argument n, returns a truthy result,
            i.e., while n is composite, call the chain to the left and update n.
Ç             Call the helper link.
 .ị           At-index 0.5; return the elements at indices 0 (last) and 1 (first).
              This yields [n/d, d].
   S          Take the sum.
    ‘         Increment.
        Ç   Call the helper link on the original value of n.
       e    Test if the result of the while loop belongs to the proper divisors.
— Деннис
источник
4

Python 2 , 97 91 байт

r=0;e=d=i=input()
while r-e:e=i;r=[j for j in range(2,i+1)if i%j<1][0];i=i/r-~r
d%e<1<d/e<q

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

Выходы через код выхода.

Ungolfed:

r = 0                             # r is the lowest divisor of the current number,
                                  # initialized to 0 for the while loop condition.
e = d = i = input()               # d remains unchanged, e is the current number
                                  # and i is the next number.
while r != e:                     # If the number is equal to its lowest divisor,
                                  # it is prime and we need to end the loop.
    e = i                         # current number := next number
    r = [j for j in range(2, i+1) # List all divisors of the number in the range [2; number + 1)
         if i%j < 1][0]           # and take the first (lowest) one.
    i = i/r+r+1                   # Calculate the next number.
                                  # We now arrived at a prime number.
print d%e == 0 and d != e         # Print True if our current number divides the input
                                  # and is distinct from the input.
                                  # If our current number is equal to the input,
                                  # the input is prime.

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

— овс
источник
3

05AB1E , 17 16 байт

[Dp#Òć©sP+>]Ö®p*

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

объяснение

[                  # start loop
 Dp#               # break if current value is prime
    Ò              # get prime factors of current value
     ć©            # extract the smallest (d) and store a copy in register
       sP          # take the product of the rest of the factors
         +>        # add the smallest (d) and increment
           ]       # end loop
            Ö      # check if the input is divisible by the resulting prime
             ®p    # check if the last (d) is prime (true for all composite input)
               *   # multiply
— Emigna
источник
2

Pyth , 20 байтов

<P_QiI.WtPHh+/ZKhPZK

Попробуй это здесь!

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

iI.WtPHh + / ZKhPZK || Полная программа.

  .W || Функциональное время. Он принимает две функции в качестве аргументов, A и B.
                 || В то время как A (значение) истинно, превратите значение в B (значение). 
                 || начальное значение является входным.
    т / ч || Первая функция, А. Принимает единственный аргумент, H.
     PH || .. Основные факторы факторы H.
    т || .. Хвост (убрать первый элемент). В то время как истина (H составная):
       ч + / зхпзк || Вторая функция, B. Принимает один аргумент, Z:
         / Z || .. Разделить Z на:
           ХП || .. Его самый низкий главный фактор, и назначьте это K.   
       ч || .. Приращение.
        + K || И добавить К.
я || Проверьте, делит ли результат (последнее значение) входные данные.

И первые 4 байта ( <P_Q) просто проверяют, не является ли ввод простым.

С помощью Emigna мне удалось сэкономить 3 байта.

— Мистер Xcoder
источник
Можете ли вы использовать что-то вроде head(P)вместо fiITZ2детали, так как наименьший делитель больше 1 всегда будет простым?
— Emigna
@ Emigna Ninja'd, исправлено и спасибо!
— г-н Xcoder
2

Python 3 , 149 байт

def f(N):
	n=N;s=[0]*-~N
	for p in range(2,N):
		if s[p]<1:
			for q in range(p*p,N+1,p):s[q]=s[q]or p
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

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

Использование ситового подхода. Должно быть быстрым ( O(N log log N)= временная сложность сита Эратосфена) даже при большом N(но сохраняет O(N)целые числа в памяти)

Заметка:

  • Можно доказать, что все промежуточные значения nне превышают N, и N > 7 pмогут быть использованы range(2,N)вместо range(2,N+1)просеивания.
  • /не работает, //должен использоваться из-за индекса списка.
  • К rangeсожалению, сохранение в другую переменную не помогает.

Объяснение:

  • -~N== N+1.
  • Сначала массив sинициализируется N+1нулями (Python 0-индексация, поэтому индексы 0..N)
  • s[n]Ожидается, что после инициализации будет, 0если nпростое число, и pдля pминимального простого числа, которое делит, nесли nявляется составным. s[0]и s[1]ценности не важны.

  • Для каждого pв диапазоне [2 .. N-1]:

    • Если s[p] < 1(то есть s[p] == 0), то pэто простое число, и для каждого q, кратного pи s[q] == 0, присваивать s[q] = p.

  • Последние 2 строки просты, за исключением того, что n//s[n]-~s[n]== (n // s[n]) + s[n] + 1.

Python 3 , 118 байт

def f(N):
	n=N;s=[0]*-~N
	for p in range(N,1,-1):s[2*p::p]=(N-p)//p*[p]
	while s[n]:n=n//s[n]-~s[n]
	return s[N]>1>N%n

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

За счет чуть худшей производительности. (Это работает во O(N log N)временной сложности, при условии разумной реализации фрагментов Python)

Эквивалентная полная программа составляет 117 байт .

— user202729
источник
Вы можете использовать n//s[n]-~s[n]вместо n//s[n]+s[n]+1149 байтов.
— г-н Xcoder
@ Mr.Xcoder Спасибо!
— user202729
Кроме того, я думаю, что or pможет быть|p
— г-н Xcoder
@ Mr.Xcoder Нет, or pвыполняет логическое или, в то время как |pвыполняет побитовое или. То есть a or bесть b if a == 0 else a.
— user202729
Вы можете изменить внешний вид, forчтобы использовать срез вместо другогоfor . Это rangeобратное, поэтому более низкие индексы будут перезаписывать более крупные, и запуск слайса у 2*pвас не заменит s[0]или s[p].
— Род
1

Japt, 25 24 байта

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

Выходы 0для ложного или 1истинного.

j ?V©vU :ßU/(U=k g)+°UNg

Попытайся

— мохнатый
источник
0

Perl 5 , 291 + 1 (-a) = 292 байта

Черт, Perl за то, что у него нет нативного главного контролера. 

use POSIX;&r($_,$_);
sub p{$n=shift;if($n<=1){return;}if($n==2||$n==3){return 1;}if($n%2==0||$n%3==0){return;}for(5..ceil($n/2)){if($n%$_==0){return;}}return 1;}
sub r{$n=shift;$o=shift;if(&p($n)){print $o%$n==0&&$n!=$o?1:0;last;}for(2..ceil($n/2)){if($n%$_==0){&r(($n/$_)+$_+1, $o);last;}}}

Неуправляемая версия,

use POSIX;
&r($_,$_);
sub p{
    my $n=shift;
    if($n<=1){
        return;
    }
    if($n==2||$n==3){
        return 1;
    }
    if($n%2==0||$n%3==0){
        return;
    }
    for(5..ceil($n/2)){
        if($n%$_==0){
            return;
        }
    }
    return 1;
}
sub r{
    my $n=shift;
    my $o=shift;
    if(&p($n)){
        print $o%$n==0&&$n!=$o ? 1 : 0;
        last;
    }
    for(2..ceil($n/2)){
        if($n%$_==0){
            &r(($n/$_)+$_+1, $o);
            last;
        }
    }
}

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

— Джеффри Х.
источник
0

J 35 байт

(~:*0=|~)(1+d+]%d=.0{q:)^:(0&p:)^:_

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

Минимальный делитель, являющийся первым простым фактором, был украден из решения Jelly @ Dennis (ранее я использовал <./@q: ).

Должен быть лучший способ выполнить итерацию, но я не могу его найти. Я думал о том, чтобы не делать тест на первичность (^:(0&p:) ) и вместо этого использовать неблагоприятный, но кажется, что это будет немного дольше, так как вам понадобится_2{ некоторые изменения, которые могут не дать чистого сокращения.

Я действительно чувствую, что должен быть способ избежать прощения с проверкой первичности.

Пояснение (расширенное)

(~: * 0 = |~)(1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Input: N
             (1 + d + ] % d =. 0 { q:) ^: (0&p:) ^:_ Find the final N'
                                       ^:        ^:_  Do while
                                           0&p:       N is not prime
                                   q:                 Get prime factors (in order)
                               0 {                    Take first (smallest divisor)
                          d =.                        Assign this value to d
             1 + d + ] %  d                           Compute (N/d) + 1 + d
(~: * 0 = |~)                                        Is it redivosite?
      0 = |~                                          N = 0 (mod N'), i.e. N'|N
    *                                                 And
 ~:                                                   N =/= N', i.e. N is not prime
— капуста
источник
0

APL NARS, 43 символа, 85 байтов

{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}

(надеясь, что оно сойдет для всего числа> 6) test:

h←{(⍵≤6)∨0π⍵:0⋄⍵{1=⍴t←π⍵:0=⍵|⍺⋄⍺∇1+↑t+⍵÷↑t}⍵}
v←⍳100     
v,¨h¨v
   1 0  2 0  3 0  4 0  5 0  6 0  7 0  8 0  9 0  10 0  11 0
   12 0  13 0  14 1  15 0  16 0  17 0  18 0  19 0  20 0  
   21 0  22 0  23 0  24 0  25 0  26 0  27 0  28 0  29 0  
   30 0  31 0  32 0  33 0  34 0  35 0  36 0  37 0  38 0  
   39 0  40 0  41 0  42 1  43 0  44 1  45 0  46 0  47 0  
   48 0  49 1  50 0  51 0  52 0  53 0  54 0  55 0  56 0  
   57 0  58 0  59 0  60 0  61 0  62 0  63 0  64 0  65 0  
   66 1  67 0  68 0  69 0  70 1  71 0  72 0  73 0  74 0  
   75 0  76 0  77 0  78 0  79 0  80 0  81 0  82 0  83 0  
   84 0  85 0  86 0  87 0  88 0  89 0  90 0  91 0  92 0  
   93 0  94 0  95 0  96 0  97 0  98 0  99 0  100 0

Идея использования 2 анонимных функций я получаю к другому решению Apl.

 {(⍵≤60)∨π⍵:0⋄ -- if arg ⍵ is prime or <=6 return 0
  ⍵{1=⍴t←π⍵:0=⍵|⍺⋄ -- if list of factors ⍵ has length 1 (it is prime)
                    -- then return ⍺mod⍵==0
  ⍺∇1+↑t+⍵÷↑t}⍵}   -- else recall this function with args ⍺ and 1+↑t+⍵÷↑t
— RosLuP
источник
0

Пыть , 44 байта

←⁻0`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹ṗ⇹3Ș⊽

См. Приведенный ниже код для объяснения - единственные различия состоят в том, что (1) N уменьшается до того, чтобы учесть приращение в начале цикла, и (2) он использует NOR вместо OR.

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


Я сделал это, прежде чем перечитать вопрос и заметил, что он хотел только истинного / ложного.

Пыть, 52 байта

60`ŕ⁺ĐĐϼ↓Đ3Ș⇹÷+⁺Đṗ¬⇹⁻⇹łŕáĐ0⦋Đ↔ĐŁ⁻⦋⁺|¬⇹Đṗ⇹3Ș∨ł⇹Đƥ⇹ŕ1ł

Печатает бесконечный список повторяющихся чисел.

Объяснение:

6                                                            Push 6
 0                                                           Push unused character
  `                   ł                     ł      ł         Return point for all three loops
   ŕ                                                         Remove top of stack
    ⁺                                                        Increment top of stack (n)
     ĐĐ                                                      Triplicate top of stack (n)
       ϼ↓                                                    Get smallest prime factor of n (returns 1 if n is prime) 
         Đ                                                   Duplicate top of stack
          3Ș⇹                                                Manipulate stack so that the top is (in descending order): [d,(N,N'),d]
             ÷+⁺                                             Calculates N'=(N,N')/d+d+1
                Đṗ¬                                          Is N' not prime?
                   ⇹⁻⇹                                       Decrement N' (so the increment at the beginning doesn't change the value), and keep the boolean on top - end of innermost loop (it loops if top of stack is true)
                       ŕ                                     Remove top of stack
                        á                                    Convert stack to array
                         Đ                                   Duplicate array
                          0⦋Đ                                Get the first element (N)
                             ↔ĐŁ⁻⦋                           Get the last element ((final N')-1)
                                  ⁺                          Increment to get (final N')
                                   |¬                        Does N' not divide N?
                                     ⇹Đṗ                     Is N prime?
                                        ⇹3Ș∨                 Is N prime or does N' not divide N? - end of second loop (loops if top of stack is true)
                                             ⇹Đƥ⇹ŕ           Print N, and reduce stack to [N]
                                                  1          Push garbage (pushes 1 so that the outermost loop does not terminate)


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

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