100 altını gruplara bölmek istiyorsunuz. Herhangi iki grup arasındaki altın farkının en fazla 2 olması koşuluyla bu işlem kaç farklı biçimde yapılabilir?
Not: Permütasyonlar farklı sayılmıyor.
Örnek : Eğer soru 6 altın için sorulsaydı cevap 9 olacaktı:
(1,1,1,1,1,1), (1,1,1,1,2), (1,1,2,2), (1,1,1,3), (1,2,3), (2,2,2), (2,4), (3,3), (6).
İlgilenenleri beklerim 
Eğer bunda bir örüntü-kural-kısayol bulamaz isek yine tek tek denememiz gerekecek. Bunun için de önce toplamı n eden bütün sayı gruplarını bulup daha sonra “herhangi iki sayının farkının en fazla 2 olması koşulu” na göre eleyeceğiz. Toplamı n eden sayı kümelerini bulmak için şu kodu buldum:
def findCombinationsUtil(arr, index, num, reducedNum, return_list):
if (reducedNum < 0):
return
if (reducedNum == 0):
r = arr[:index]
if max(r) - min(r) <= 2:
return_list.append(r)
return
prev = 1 if(index == 0) else arr[index - 1]
for k in range(prev, num + 1):
arr[index] = k
findCombinationsUtil(arr, index + 1, num, reducedNum - k, return_list)
def findCombinations(n):
arr = [0] * n
l = []
findCombinationsUtil(arr, 0, n, n, l)
return l
n = 6
olasılıklar = findCombinations(n)
print("Olasılıkların sayısı:", len(olasılıklar))
buda benden olsun
def altınbul(toplam):
liste=[]
for i in range(1,toplam-1):
for j in range(1,toplam+1) :
a=itertools.combinations_with_replacement([i,i+1,i+2],j)
for k in a:
if sum(k)==toplam:
liste.append(k)
print(len(set(liste)))
altınbul(100)import Data.List
step :: [[Int]] -> [[Int]]
step gs = nub $ concatMap addOne gs
where
addOne es = nub $ filter (not.hasBigDiff) $ (1:es) : (map (addOneToElem es) [0..length es-1])
addOneToElem es n = sort $ (take n es) ++ [(es !! n) + 1] ++ (drop (n+1) es)
hasBigDiff es = (maximum es) - (minimum es) > 2
main = do
print $ length $ (iterate step [[]]) !! 100
Bu tam olarak hangi dil oluyor?