Получите все факторы числа (откровенный обмен мнениями итераторов :)
Можно использовать OLEDB, чтобы создать и управлять файлами Excel. Проверьте это: Reading и Writing Excel с помощью OLEDB.
Типичный пример:
using (OleDbConnection conn = new OleDbConnection("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\\temp\\test.xls;Extended Properties='Excel 8.0;HDR=Yes'"))
{
conn.Open();
OleDbCommand cmd = new OleDbCommand("CREATE TABLE [Sheet1] ([Column1] string, [Column2] string)", conn);
cmd.ExecuteNonQuery();
}
РЕДАКТИРОВАНИЕ - еще Некоторые ссылки:
4 ответа
Рассмотрим все возможные комбинации полномочий. Для каждой комбинации возведите простые числа в соответствующую степень и умножьте результат.
>>> from functools import reduce
>>> from itertools import product, starmap
>>> from operator import mul
>>>
>>> def factors(prime_factors):
... primes, powers = zip(*prime_factors)
... power_combos = product(*(range(p + 1) for p in powers))
... prime_combos = (zip(primes, c) for c in power_combos)
... return (reduce(mul, starmap(pow, c)) for c in prime_combos)
...
>>> sorted(factors([(2, 3), (3, 1)]))
[1, 2, 3, 4, 6, 8, 12, 24]
Этот код использует Python 3.0. Помимо вызова sorted , он использует исключительно итераторы.
Дополнительное замечание : жаль, что этот вопрос кажется довольно непопулярным. Хотелось бы, например, увидеть, как публикуются некоторые функциональные решения. (Я могу попытаться написать решение для Haskell позже.)
Если вас интересуют не единичные делители, а сумма всех делителей n, вы можете захотеть чтобы посмотреть на функцию делителя :
Таким образом, сумма делителей
равна
cartesianWith f xs = concatMap $ \y -> map (`f` y) xs
factorsOfPrimeFactorization =
foldl (cartesianWith (*)) [1] . map (\(p, e) -> map (p^) [0..e])
> factorsOfPrimeFactorization [(2, 3), (3, 1)] [1,2,4,8,3,6,12,24]
To sort the result,
import Data.List
cartesianWith f xs = concatMap $ \y -> map (`f` y) xs
factorsOfPrimeFactorization =
sort . foldl (cartesianWith (*)) [1] . map (\(p, e) -> map (p^) [0..e])
Perl.
sub factors {
my %factorization = @_;
my @results = (1);
while (my ($p, $e) = each %factorization) {
@results = map {my $i = $_; map $i*$_, @results} map $p**$_, 0..$e;
}
sort {$a <=> $b} @results;
}
print join($,, factors(2, 3, 3, 1)), $/; # => 1 2 3 4 6 8 12 24
J.
/:~~.,*/"1/{:@({.^i.@{:@>:)"1 ] 2 3 ,: 3 1
1 2 3 4 6 8 12 24
These all implement the same algorithm, which is to generate the list p0,p1,…,pe for each pair (p,e) in the factorization, and take the product of each set in the Cartesian product across all those lists.
Я сначала снимаю без IDE под рукой, поэтому там могут быть некоторые ошибки.
struct PrimePower
{
public PrimePower(Int32 prime, Int32 power) : this()
{
this.Prime = prime;
this.Power = power;
}
public Int32 Prime { get; private set; }
public Int32 Power { get; private set; }
}
И только эта рекурсивная функция.
public IEnumerable<Int32> GetFactors(IList<PrimePowers> primePowers, Int32 index)
{
if (index < primePowers.Length() - 1)
{
Int32 factor = 1;
for (Int32 p = 0; p <= primePowers[index].Power; p++)
{
yield return factor * GetFactors(primePowers, index + 1);
factor *= primePowers[index].Prime;
}
}
else if (index = primePowers.Length() - 1)
{
Int32 factor = 1;
for (Int32 p = 0; p <= primePowers[index].Power; p++)
{
yield return factor * GetFactors(primePowers, index + 1);
factor *= primePowers[index].Prime;
}
}
else
{
throw new ArgumentOutOfRangeException("index");
}
}
Это также может быть метод расширения и IList , вероятно, может быть ослаблен до IEnumerable с несколькими вызовами Skip () и Take () . Я тоже не люблю передавать индекс, но альтернативой было бы копирование основного списка мощности для каждого вызова. Как следствие, я думаю, что итеративное решение было бы предпочтительнее - добавлю одно, если у меня снова будет IDE.