Tanımlar

Izin vermek mve npozitif tamsayı olmak. Biz demek mbir olan bölen büküm ait ntamsayılar mevcutsa 1 < a ≤ böyle ki n = a*bve m = (a - 1)*(b + 1) + 1. Eğer melde edilebilir no sıfır ya da daha fazla bölen katlanmış uygulayarak, ardından ma, soyundan arasında n. Her sayının kendi torunu olduğunu unutmayın.

Örneğin, düşünün n = 16. Biz seçebilir a = 2ve b = 8beri 2*8 = 16. Sonra

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

ki 10bunun bölen bir bükülme olduğunu gösterir 16. İle a = 2ve b = 5biz o zaman görürüz 7bir böleni büküm olduğunu 10. Böylece 7bir torunudur 16.

Görev

Pozitif bir tamsayı verildiğinde , artan sırada listelenen ntorunlarını nkopyalar olmadan hesaplayın .

kurallar

Bir sayının bölenlerini hesaplayan yerleşik işlemleri kullanmanıza izin verilmez.

Hem tam programlar hem de işlevler kabul edilir ve bir koleksiyon veri türünün (bir tür küme gibi) döndürülmesine, sıralandığı ve çoğaltılmadığı sürece izin verilir. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez.

Test Durumları

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 bayt

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])))

Yana (a-1)*(b+1)+1 == a*b-(b-a)ve b >= a, torunları hep az olan ya da orijinal sayıya eşittir. Bu yüzden sadece ilk sayı ile başlayabilir ve hiç kalmayıncaya kadar kesinlikle daha küçük torunları üretmeye devam edebiliriz.

Durum (n<x*x)>n%xbirinde iki şeyi kontrol eder - bu n<x*xve n%x == 0.

(@Xnor'a, baz kasadan 3 bayt aldığı için)

Pyth, 32 bayt

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

sBoş bir listede toplamı ( ) toplamaya çalışırken Pyth'in boğulma gibi görünmesi dışında yukarıdakilerin doğrudan çevirisi .

Bu, ysonuna ekleyerek çağrılabilecek bir işlevi tanımlar y<number>, bu şekilde ( çevrimiçi deneyin ):

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

CJam, 47 45 bayt

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

Ayrıca birkaç değişiklikle aynı yöntemi kullanarak. Karşılaştırma için CJam'ı denemek istedim, ama ne yazık ki CJam'da Pyth / Python'da olduğumdan çok daha kötüyüm, bu yüzden muhtemelen iyileştirmek için çok yer var.

Yukarıdaki bir int alır ve bir liste döndüren bir blok (temelde CJam'ın adsız işlevlerin sürümü). Bu şekilde test edebilirsiniz ( çevrimiçi deneyin ):

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

Java, 148 146 104 bayt

Golf versiyonu:

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);}

Uzun versiyon:

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);
}

Bu yüzden ilk kez PPCG'de Geobits programına benzer bir TreeSet(sayıları otomatik olarak sıralar) ve özyineleme kullanan, ancak farklı bir şekilde, n'nin katlarını kontrol edip bunları kullanarak sonraki işlev. Bunun bir ilk zamanlayıcı için oldukça adil bir puan olduğunu söyleyebilirim (özellikle Java ile bu tür şeyler için en ideal dil gibi görünmüyor ve Geobits'in yardımı).

Java, 157 121

İşte her torunun torunlarını alan özyinelemeli bir işlev n. TreeSetVarsayılan olarak sıralanan a değerini döndürür .

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;}

Bazı satır sonları ile:

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;
}

Oktav, 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, 102100 bayt

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]

Kullanım: p 16hangi çıkışlar[7,10,16]

İşlev d, tüm torunları yinelemeli olarak hesaplar, ancak yinelenenleri kontrol etmez, bu nedenle çoğu bir kereden fazla görünür, örneğin d [4]sonsuz bir 4s listesi döndürür . Fonksiyonlar bu listedeki pilk nelemanları alır, kopyaları kaldırır ve listeyi sıralar. Voilà.

CJam - 36

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

Çevrimiçi deneyin

Veya farklı yöntem:

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

Onları neredeyse 2 gün önce yazdım, 36 yaşında kaldım, hayal kırıklığına uğradım ve göndermeden uyumaya gittim.