public void Factor_Input1_Output1()
{
Assert.Equal(Divisors.AllDivisors(1), new HashSet <long>()
{
1
});
}
public void Factor_Input21_Output1_3_7_21()
{
Assert.Equal(Divisors.AllDivisors(21), new HashSet <long>()
{
1, 3, 7, 21
});
}
public void Factor_Input28_Output1_2_4_7_14_28()
{
Assert.Equal(Divisors.AllDivisors(28), new HashSet <long>()
{
1, 2, 4, 7, 14, 28
});
}
public void Factor_Input15_Output1_3_5_15()
{
Assert.Equal(Divisors.AllDivisors(15), new HashSet <long>()
{
1, 3, 5, 15
});
}
public void Factor_Input10_Output1_2_5_10()
{
Assert.Equal(Divisors.AllDivisors(10), new HashSet <long>()
{
1, 2, 5, 10
});
}
public void Factor_Input6_Output1_2_3_6()
{
Assert.Equal(Divisors.AllDivisors(6), new HashSet <long>()
{
1, 2, 3, 6
});
}
internal static string Smallest_multiple()
{
bool number = true;
long val = divis;
while (number)
{
number = false;
for (long i = 1; i <= divis; i++)
{
if (Divisors.IsDivisor(val, i))
{
if (i == divis)
{
number = false;
}
}
else
{
val = val + divis;
number = true;
i = 1;
break;
}
}
}
return(val.ToString());
}
// A number n is called called abundant if sum of its proper divisors exceeds n.
public long GetNonabundantsum(int to)
{
//lag liste av aktuelle AbundantNumber
var abundantNumbersListe = Enumerable.Range(1, to).Where(i => Divisors.IsAbundantNumber(i)).ToList();
//lag hashmap av AbundantNumber listen
var abundantNumbersDictionary = abundantNumbersListe.ToDictionary(e => e);
//finn summen
//er i= a+b hvor a og b er AbundantNumber ? , ellers legg til sum
long nonabundantsum = 0;
for (int i = 1; i <= to; i++)
{
if (
abundantNumbersListe
.Where(e => e < i)
.Where(a => abundantNumbersDictionary.ContainsKey(i - a))
.FirstOrDefault() == 0 //hvis ikke i kan skrives som summen av to tall i abundantNumbersListe
)
{
nonabundantsum += i;
}
}
return(nonabundantsum);
}
private void FindWays()
{
for (int ii = 2; ii <= Value / 2 + 1; ii++)
{
if (Value % ii == 0)
{
Divisors.Add(ii);
}
var fraction = Value / ii;
var smallestStart = Math.Max(1, fraction - ii - 1);
for (var start = smallestStart; start <= ii; start++)
{
if (Ways.Any(existingWay => existingWay.First() == start))
{
continue;
}
var way = new List <int>();
var sum = 0;
var num = start;
while (sum < Value)
{
sum += num;
way.Add(num);
num++;
}
if (sum == Value)
{
Ways.Add(way);
}
}
}
}
public void GetDivisors_InputIsValid_ReturnsDivisors()
{
Divisors.GetDivisors(1).ShouldBeSubsetOf(new List <int> {
1
});
Divisors.GetDivisors(2).ShouldBeSubsetOf(new List <int> {
1, 2
});
Divisors.GetDivisors(3).ShouldBeSubsetOf(new List <int> {
1, 2, 3
});
Divisors.GetDivisors(4).ShouldBeSubsetOf(new List <int> {
1, 2, 4
});
Divisors.GetDivisors(5).ShouldBeSubsetOf(new List <int> {
1, 5
});
Divisors.GetDivisors(9).ShouldBeSubsetOf(new List <int> {
1, 3, 9
});
Divisors.GetDivisors(10).ShouldBeSubsetOf(new List <int> {
1, 2, 5, 10
});
Divisors.GetDivisors(11).ShouldBeSubsetOf(new List <int> {
1, 11
});
Divisors.GetDivisors(13).ShouldBeSubsetOf(new List <int> {
1, 13
});
Divisors.GetDivisors(20).ShouldBeSubsetOf(new List <int> {
1, 2, 4, 5, 10, 20
});
}
public void TestMostDivisibleNumberMin0Max12()
{
var expected = 12;
var output = Divisors.MostDivisibleNumber(0, 12).Result;
Assert.AreEqual(expected, output);
}
public void TestMostDivisibleNumberMin1Max1()
{
var expected = 1;
var output = Divisors.MostDivisibleNumber(1, 1).Result;
Assert.AreEqual(expected, output);
}
public void Factor_Input3_Output1_3()
{
Assert.Equal(Divisors.AllDivisors(3), new HashSet <long>()
{
1, 3
});
}
public void AddDivisor(long number)
{
if (number <= 0)
{
throw new ArgumentOutOfRangeException(nameof(number), $"The number {number} is not a valid Divisor.");
}
Divisors.Add(number);
}
/*
* for every divisor d of n, d+n/d is prime.
*/
public bool IsPrimeGenerating(long number)
{
if (number % 2 == 1)
{
return(false);
}
/*
* for (long divisor1 = 2; divisor1 < number; divisor1++)
* {
* long divisor2 = number / divisor1;
* if (divisor1 > divisor2) return true;
*
* if (number % divisor1 == 0 )
* {
*
*
*
* if (!primeDictionary.ContainsKey(divisor1 + divisor2)) return false;
* }
*
*
* }
*
* return true;
*/
List <long> divisors = Divisors.GetAllUniqueDivisorsIn(number);
int len = divisors.Count();
if (len % 2 == 1)
{
return(false);
}
//if (len == 2)
// return !primeDictionary.ContainsKey(number);
if (number == 442)
{
var aa = 1;
}
// List<long> liste = divisors.Select(d => d + number / d).Distinct().ToList();
List <long> liste = divisors.Take(len).Select(d => d + number / d).Distinct().ToList();
// List<long> liste = divisors.Take(len/2).ToList();
// return liste.All(d => Primes.IsPrime(d, primeliste));
// return liste.All(d => primeDictionary.ContainsKey(d));
return(liste.All(d => primeDictionary.ContainsKey(d)));
}
private bool IsAbundantNumber(int number)
{
int sum = 0;
foreach (int divisor in Divisors.GetDivisors(number))
{
sum += divisor;
}
return(sum > number);
}
public void TestDivisors(uint n, uint[] divisors)
{
int i = 0;
foreach (uint divisor in Divisors.AllDivisors(n))
{
Assert.LessThan(i, divisors.Length, "Expected {0}<{1} for number {2}", i, divisors.Length, n);
Assert.AreEqual(divisors[i++], divisor);
}
}
public void TestPrimeDivisors(uint n, uint[] divisors)
{
int i = 0;
foreach (uint primeDivisor in Divisors.PrimeDivisors(n))
{
Assert.LessThan(i, divisors.Length);
Assert.AreEqual(divisors[i++], primeDivisor);
}
}
public void TestGetListOfDivisors1()
{
var expected = new List <int>
{
1
};
var output = Divisors.GetListOfDivisors(1);
CollectionAssert.AreEqual(expected, output);
}
internal static bool IsAbundant_Digit(int value)
{
if (Divisors.SummDivisor(value) > value)
{
return(true);
}
else
{
return(false);
}
}
public void TestFor284()
{
IList <Int32> divisorsOfNumber = Divisors.DivisorsOfNumber(284);
Int32[] expected = new[] { 1, 2, 4, 71, 142 };
Assert.AreEqual(expected.Length, divisorsOfNumber.Count);
foreach (Int32 i in expected)
{
Assert.Contains(i, (ICollection)divisorsOfNumber);
}
}
public long GetFirstWithNumbersOfDivisors(long above)
{
foreach (var nextTriangularNumber in TriangleNumber.Iterastor())
{
var allUniqueDivisors = Divisors.GetAllUniqueDivisorsIn(nextTriangularNumber);
if (allUniqueDivisors.Count > above)
{
return(nextTriangularNumber);
}
}
return(-1);
}
public void TestFor220()
{
IList <Int32> divisorsOfNumber = Divisors.DivisorsOfNumber(220);
Int32[] expected = new[] { 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110 };
Assert.AreEqual(expected.Length, divisorsOfNumber.Count);
foreach (Int32 i in expected)
{
Assert.Contains(i, (ICollection)divisorsOfNumber);
}
}
internal static string Largest_prime_factor()
{
var primes = Divisors.GetPrimeListOfDivisors(n);
foreach (var prime in primes)
{
MathsProblemsForm.Log(prime.ToString());
}
var maxPrime = primes[primes.Count - 1];
return(maxPrime.ToString());
}
public void TestGetListOfDivisors5040()
{
var expected = new List <int>
{
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 15, 16, 18, 20,
21, 24, 28, 30, 35, 36, 40, 42, 45, 48, 56, 60, 63, 70,
72, 80, 84, 90, 105, 112, 120, 126, 140, 144, 168, 180,
210, 240, 252, 280, 315, 336, 360, 420, 504, 560, 630,
720, 840, 1008, 1260, 1680, 2520, 5040
};
var output = Divisors.GetListOfDivisors(5040);
CollectionAssert.AreEqual(expected, output);
}
public static int DenominatorProductFractions()
{
var(multNumerator, multDenominator) = (1, 1);
for (int numerator = 10; numerator < 100; numerator++)
{
var nLeft = numerator % 10;
var nRight = numerator / 10;
for (int denominator = numerator + 1; denominator < 100; denominator++)
{
if (numerator % 10 == 0 && denominator % 10 == 0)
{
continue;
}
var fraction = numerator / (double)denominator;
var dLeft = denominator % 10;
var dRight = denominator / 10;
int a = -1, b = -1;
if (nLeft == dLeft)
{
(a, b) = (nRight, dRight);
}
else if (nLeft == dRight)
{
(a, b) = (nRight, dLeft);
}
else if (nRight == dLeft)
{
(a, b) = (nLeft, dRight);
}
else if (nRight == dRight)
{
(a, b) = (nLeft, dLeft);
}
if (a < b && fraction == a / (double)b)
{
multNumerator *= a;
multDenominator *= b;
}
}
}
return((int)Divisors.LowestCommonTerms(multNumerator, multDenominator).denominator);
}
private int GetDofN(int number)
{
if (memo.ContainsKey(number))
{
return(memo[number]);
}
int sum = 0;
foreach (int divisor in Divisors.GetDivisors(number))
{
sum += divisor;
}
memo.Add(number, sum);
return(sum);
}
public long Solve()
{
uint count = 1;
while (true)
{
uint triangleNumber = count * (count + 1) / 2;
uint n = Divisors.NumberOfDivisors(triangleNumber);
if (n > 500)
{
return(triangleNumber);
}
count++;
}
}
internal static int Amicable_numbers(int value)
{
int ammDigits = 0;
int temp2 = 0;
ammDigits = Divisors.SummDivisor(value);
temp2 = Divisors.SummDivisor(ammDigits);
if (temp2 == value)
{
return(ammDigits);
}
else
{
return(0);
}
}
internal static string Highly_divisible_triangular_number()
{
long value = 1;
long temp = 2;
var resultList = new List <long>();
while (resultList.Count <= 500)
{
resultList = Divisors.GetList(value);
value = value + temp;
temp++;
}
var result = value - (temp - 1);
return(result.ToString());
}
