Definitionen

Lass mund nsei positive ganze Zahlen. Wir sagen , dass mist ein Divisor Drall von , nwenn es ganze Zahlen existiert , 1 < a ≤ bso dass n = a*bund m = (a - 1)*(b + 1) + 1. Wenn mkann bezogen werden , nindem keine oder mehr Teiler Drehungen , um es, dann mist ein Nachkomme von n. Beachten Sie, dass jede Zahl ein eigener Nachkomme ist.

Zum Beispiel betrachten n = 16. Wir können a = 2und wählen b = 8, da 2*8 = 16. Dann

(a - 1)*(b + 1) + 1 = 1*9 + 1 = 10

was zeigt, dass 10ist ein Teiler Twist von 16. Mit a = 2und sehen b = 5wir dann, dass dies 7eine Divisor-Wendung von ist 10. Also 7ist ein Nachkomme von 16.

Die Aufgabe

nBerechnen Sie bei einer positiven Ganzzahl die Nachkommen von nin aufsteigender Reihenfolge ohne Duplikate.

Regeln

Sie dürfen keine integrierten Operationen verwenden, die die Teiler einer Zahl berechnen.

Es werden sowohl vollständige Programme als auch Funktionen akzeptiert, und die Rückgabe eines Sammlungsdatentyps (wie einer Reihe von Datensätzen) ist zulässig, sofern er sortiert und duplikationsfrei ist. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Testfälle

1 ->  [1]
2 ->  [2] (any prime number returns just itself)
4 ->  [4]
16 -> [7, 10, 16]
28 -> [7, 10, 16, 25, 28]
51 -> [37, 51]
60 -> [7, 10, 11, 13, 15, 16, 17, 18, 23, 25, 28, 29, 30, 32, 43, 46, 49, 53, 55, 56, 60]

Python 2, 109 98 85 82 Bytes

f=lambda n:sorted(set(sum(map(f,{n-x+n/x for x in range(2,n)if(n<x*x)>n%x}),[n])))

Nachkommen sind seit (a-1)*(b+1)+1 == a*b-(b-a)und b >= aimmer kleiner oder gleich der ursprünglichen Zahl. Wir können also einfach mit der Anfangszahl beginnen und streng kleinere Nachkommen erzeugen, bis keine mehr übrig sind.

Die Bedingung (n<x*x)>n%xprüft zwei Dinge in einem - das n<x*xund n%x == 0.

(Danke an @xnor, dass er 3 Bytes aus dem Basisfall entfernt hat)

Pyth, 32 Bytes

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2b

Direkte Übersetzung des oben Gesagten, mit Ausnahme der Tatsache, dass Pyth zu ersticken scheint, wenn versucht wird, ( s) auf einer leeren Liste zu summieren .

Dies definiert eine Funktion, ydie durch Anhängen y<number>am Ende wie folgt aufgerufen werden kann ( versuchen Sie es online ):

LS{s+]]bmydm+-bk/bkf><b*TT%bTr2by60

CJam, 47 45 Bytes

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}

Mit ein paar Modifikationen auch mit der gleichen Methode. Ich wollte CJam zum Vergleich ausprobieren, aber leider bin ich bei CJam viel schlechter als bei Pyth / Python, daher gibt es wahrscheinlich viel Raum für Verbesserungen.

Das Obige ist ein Block (im Grunde genommen CJams Version von unbenannten Funktionen), der ein int aufnimmt und eine Liste zurückgibt. Sie können es so testen ( online ausprobieren ):

{{:X_,2>{__*X>X@%>},{_X\/\-X+}%{F}%~}:F~]_&$}:G; 60 Gp

Java, 148 146 104 Bytes

Golf Version:

import java.util.*;Set s=new TreeSet();void f(int n){s.add(n);for(int a=1;++a*a<n;)if(n%a<1)f(n+a-n/a);}

Lange Version:

import java.util.*;
Set s = new TreeSet();
void f(int n) {
    s.add(n);
    for (int a = 1; ++a*a < n;)
        if (n%a < 1)
            f(n + a - n/a);
}

Ich mache mein Debüt in PPCG mit diesem Programm, das a TreeSet(das die Zahlen zum Glück automatisch sortiert) und eine Rekursion verwendet, die dem Programm von Geobits ähnelt, aber auf eine andere Art und Weise, indem ich nach Vielfachen von n suche und sie dann in dem Programm verwende nächste Funktion. Ich würde sagen, dies ist eine ziemlich gute Punktzahl für einen Anfänger (insbesondere mit Java, das nicht die ideale Sprache für diese Art von Dingen zu sein scheint, und der Hilfe von Geobits).

Java, 157 121

Hier ist eine rekursive Funktion, die die Nachkommen jedes Nachkommen von abruft n. Es wird ein zurückgegeben TreeSet, das standardmäßig sortiert ist.

import java.util.*;Set t(int n){Set o=new TreeSet();for(int i=1;++i*i<n;)o.addAll(n%i<1?t(n+i-n/i):o);o.add(n);return o;}

Mit einigen Zeilenumbrüchen:

import java.util.*;
Set t(int n){
    Set o=new TreeSet();
    for(int i=1;++i*i<n;)
        o.addAll(n%i<1?t(n+i-n/i):o);
    o.add(n);
    return o;
}

Octave, 107 96

function r=d(n)r=[n];a=find(!mod(n,2:sqrt(n-1)))+1;for(m=(a+n-n./a))r=unique([d(m) r]);end;end

Pretty-Print:

function r=d(n)
  r=[n];                          # include N in our list
  a=find(!mod(n,2:sqrt(n-1)))+1;  # gets a list of factors of a, up to (not including) sqrt(N)
  for(m=(a+n-n./a))               # each element of m is a twist
    r=unique([d(m) r]);           # recurse, sort, and find unique values
  end;
end

Haskell, 102 100 Bytes

import Data.List
d[]=[]
d(h:t)=h:d(t++[a*b-b+a|b<-[2..h],a<-[2..b],a*b==h])
p n=sort$nub$take n$d[n]

Verwendung: p 16welche Ausgänge[7,10,16]

Die Funktion dberechnet rekursiv alle Nachkommen, sucht jedoch nicht nach Duplikaten, sodass viele mehr als einmal vorkommen, z. B. d [4]eine unendliche Liste von 4s zurückgeben. Die Funktionen pnehmen die ersten nElemente aus dieser Liste, entfernen Duplikate und sortieren die Liste. Voilà.

CJam - 36

ri_a\{_{:N,2>{NNImd!\I-z*-}fI}%|}*$p

Probieren Sie es online aus

Oder andere Methode:

ri_a\{_{_,2f#_2$4*f-&:mq:if-~}%|}*$p

Ich schrieb sie vor fast 2 Tagen, blieb mit 36 ​​stecken, wurde frustriert und schlief ein, ohne etwas zu posten.