We Keep Coding

How to write recursive function for nested loops in C#

How can I write recursive function for this for loops I am making sum of this array elements.
int[,,,] exampleArray = new int[1,2,3,4];
int sum = 0;
for (int i = 0; i < 1; i++)
{
for (int j = 0; j < 2; j++)
{
for (int k = 0; k < 3; k++)
{
for (int l = 0; l < 4; l++)
{
sum += exampleArray[i, j, k, l];
}
}
}
}
Console.WriteLine(sum);

it is actually quite simple, just need a way to represent all 4 indexes as single variable:
static int recursiveSum(int[,,,] a, int index = 0)
{
int ti = index;
int l = ti % a.GetLength(3); ti /= a.GetLength(3);
int k = ti % a.GetLength(2); ti /= a.GetLength(2);
int j = ti % a.GetLength(1); ti /= a.GetLength(1);
int i = ti % a.GetLength(0); ti /= a.GetLength(0);
if (ti > 0) {
return 0;
}
return a[i, j, k, l] + recursiveSum(a, index + 1);
}
static void Main(string[] args)
{
int[,,,] exampleArray = new int[1, 2, 3, 4];
int sum = recursiveSum(exampleArray);
Console.WriteLine(sum);
}

The sum of the divisors of an N number

Find then sum all the divisors from 1 to N.
The main problem is, that this code runs really poor with high numbers.
The following code was taken from: https://www.geeksforgeeks.org/sum-divisors-1-n
static int divisorSum(int n)
{
int sum = 0;
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j * j <= i; ++j)
{
if (i % j == 0)
{
if (i / j == j)
sum += j;
else
sum += j + i / j;
}
}
}
return sum;
}

Based on #Joel solution, I just improved it:
static long divisorSum(int n)
{
long sum = 0;
for (long i = 1; i <= n/2; ++i)
sum += i * (n / i);
sum += (n/2+1+n)*(n-n/2)/2; // It's a sum of an arithmetic progression‏‏‏‏
return sum;
}
For i > n/2 the expression i * (n / i) is simply i (because n/i = 1), so we can get the sum of all the numbers between n/2 + 1 to n by computing a sum of an arithmetic progression‏‏‏‏. It will run faster, although it is O(n) too.

You could do something like this O(n):
static long divisorSum(int n)
{
long sum = 0;
for (long i = 1; i <= n; ++i)
sum += i * (n / i);
return sum;
}
static void Main(string[] args)
{
int val = 129999;
Console.WriteLine(divisorSum(val));
Console.ReadLine();
}
Tests:
12999 => 8ms
129999 => 25ms
2147483647 => 18770ms (Max Int32 value)
int val = 129999;
int maxInt = int.MaxValue;
//val (129999)
var watch = System.Diagnostics.Stopwatch.StartNew();
Console.WriteLine(divisorSum(val));
watch.Stop();
var elapsedMs = watch.ElapsedMilliseconds;
Console.WriteLine(elapsedMs); //25ms
//MaxInt (2147483647)
watch = System.Diagnostics.Stopwatch.StartNew();
Console.WriteLine(divisorSum(maxInt));
watch.Stop();
elapsedMs = watch.ElapsedMilliseconds; //18770ms
Console.WriteLine(elapsedMs);
Console.ReadLine();

There is no need to use a collection of sorts, since you sum everything up and don't need to think about duplicates. I don't think there is a way to get a solution for this which is a perfect O(n), but this is the closest I can think of:
int sum = 0;
for (int i = 1; i <= n; i++)
{
double sqrt = Math.Sqrt (i);
for (int j = 1; j <= sqrt; j++)
{
if (i % j == 0)
{
sum += j;
if (j != sqrt)
sum += i / j;
}
}
}
Divisors are pairs, so there isn't a need to go all the way to i every time (e.g 1 * 10, 10 * 1 are the same). You can go till the square-root of i (the 'mid-point'), and save time, hence it's not O(n^2), but not perfectly O(n).

Magic Square Code Single Even number in C#

can you help me to create a logic for magic square metric. In given example, I have created a code for generate Magic Square for odd numbers like 3x3, 5x5, 7x7 metric and double even numbers like 4×4 , 8×8 but unable to found a proper solution for create single even value magic square metric like 6x6, 10x10 etc.
In current implementation anyone can enter a number (n) in input and it will create a nxn magic square metric. But not working fine with single even numbers
class Program
{
public static void Main(string [] args )
{
Console.WriteLine("Please enter a number:");
int n1 = int.Parse(Console.ReadLine());
// int[,] matrix = new int[n1, n1];
if (n1 <= 0)
{
Negativ();
}
else if (n1 == 2)
{
Zwei();
}
else if ((n1 != 2) && !(n1 < 0) && (n1 % 2 != 0))
{
Odd (n1 );
}
else if ((n1 != 2) && !(n1 < 0) && ((n1 - 2) % 4 == 0))
{//singl Even
SingleEven(n1);
}
else if ((n1 != 2) && !(n1 < 0) && (n1 % 4 == 0))
{
DoubleEven (n1);
}
}
private static void Negativ(){
Console.WriteLine("Sorry, the number must be positive and greater than 3 ");
Console.ReadLine();
}
public static void Zwei(){
Console.WriteLine("Sorry,there is no magic square of 2x2 and the number must be and greater than 3 ");
Console.ReadLine();
}
public static void Odd ( int n)// odd method
{
int[,] magicSquareOdd = new int[n, n];
int i;
int j;
// Initialize position for 1
i = n / 2;
j = n - 1;
// One by one put all values in magic square
for (int num = 1; num <= n * n; )
{
if (i == -1 && j == n) //3rd condition
{
j = n - 2;
i = 0;
}
else
{
//1st condition helper if next number
// goes to out of square's right side
if (j == n)
j = 0;
//1st condition helper if next number is
// goes to out of square's upper side
if (i < 0)
i = n - 1;
}
//2nd condition
if (magicSquareOdd[i, j] != 0)
{
j -= 2;
i++;
continue;
}
else
{
//set number
magicSquareOdd[i, j] = num++;
//1st condition
j++; i--;
}
}
// print magic square
Console.WriteLine("The Magic Square for " + n + " is : ");
Console.ReadLine();
for ( i = 0; i < n; i++)
{
for ( j = 0; j < n; j++)
Console.Write(" " + magicSquareOdd[i, j] + " ");
Console.WriteLine();
Console.ReadLine();
}
Console.WriteLine(" The sum of each row or column is : " + n * (n * n + 1) / 2 + "");
Console.ReadLine();
}
public static void SingleEven(int n )
{
// int n = magic .Length ;
int[,] magicSquareSingleEven = new int[n, n];
int halfN = n / 2;
int k = (n - 2) / 4;
int temp;
int[] swapcol = new int[n];
int index = 0;
int[,] minimagic = new int[halfN, halfN];
*Odd(minimagic) ;* // here is the problem
for (int i = 0; i < halfN; i++)
for (int j = 0; j < halfN; j++)
{
magicSquareSingleEven[i, j] = minimagic[i, j];
magicSquareSingleEven[i+ halfN , j+halfN ] = minimagic[i, j]+ halfN *halfN ;
magicSquareSingleEven[i, j + halfN] = minimagic[i, j] +2* halfN * halfN;
magicSquareSingleEven[i + halfN, j] = minimagic[i, j] +3* halfN * halfN;
}
for (int i =1; i< k ;i ++)
swapcol [index ++]=i ;
for (int i = n-k+2; i <= n ; i++)
swapcol[index++] = i;
for (int i =1; i<=halfN ;i ++)
for (int j = 1; j<= index ; j ++)
{
temp = magicSquareSingleEven[i - 1, swapcol[j - 1] - 1];
magicSquareSingleEven[i-1,swapcol[j-1]-1]=magicSquareSingleEven[i +halfN-1,swapcol[j-1]-1];
magicSquareSingleEven[i+halfN-1,swapcol[j-1]-1]=temp;
}
//swaping noses
temp=magicSquareSingleEven[k,0];
magicSquareSingleEven[k,0]=magicSquareSingleEven[k+halfN,0];
magicSquareSingleEven[k+halfN,0]=temp;
temp=magicSquareSingleEven[k+halfN,k];
magicSquareSingleEven[k+halfN,k]=magicSquareSingleEven[k,k];
magicSquareSingleEven[k,k]=temp;}
//end of swaping
// print magic square
Console.WriteLine("The Magic Square for " + n + " is : ");
Console.ReadLine();
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
Console.Write(" " + magicSquareSingleEven[i, j] + " ");
Console.WriteLine();
Console.ReadLine();
}
Console.WriteLine(" The sum of each row or column is : " + n * (n * n + 1) / 2 + "");
Console.ReadLine();
}

Rounding amount with available set of denominations

This isn't regular rounding thing which rounds up or down based of a single value.
I would want to have a function where I pass the amount as integer and denominations as array of integer.
What that function should return to me is a nearest possible integer value achievable with passed array of denominations.
Whether to round up or down will again be sent as a parameter.
Code:
var amount = 61; // for. e.g.
int[] denoms = [20, 50]; // for. e.g.
bool roundUp = true;
amount = RoundAmount(amount, denoms, roundUp);
Expected result :
RoundAmount function should return me the nearest possible amount achievable with denoms that I have passed.
If roundUp = true, The return value should be 70, because 70 = 20+50
and amount 70 can be achieved by one note of 20s and one note of 50s.
If roundUp = false, It should have returned 60, because 60 =
20+20+20 and amount 60 can be achieved by 3 notes of 20s
What I got so far :
I was only reached to the point where I can manage to round the amount up or down based on a single integer (and not the array of integers)
public int RoundAmount(int amount, int value, bool roundUp)
{
if (roundUp)
amount = amount - (amount % value) + value;
else
amount = amount - (amount % value)
return amount;
}
Edit:
I have another recursive function which checks if amount is achievable or not,
Only if amount isn't achievable, RoundAmount function is called.
So in my example, amount = 70 will never be the input because 70 is achievable with available denoms and I won't call the RoundAmount in that case.
Solution: (Thanks to maraca and Koray)
I'm glad its working with long numbers though it wasn't original requirement.
private static long RoundAmount_maraca(long a, long[] d, bool up)
{
d = d.ToArray();
Array.Sort(d);
if (a < d[0])
return up ? d[0] : 0;
long count = 0;
for (long i = 0; i < d.Length; i++)
{
if (d[i] == 0)
continue;
for (long j = i + 1; j < d.Length; j++)
if (d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
long gcd = euclid(d[1], d[0]);
for (long i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (long i = 0; i < count; i++)
{
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
var set = new HashSet<long>();
set.Add(0);
long last = 0;
for (long n = d[0]; ; n++)
{
if (!up && n > a)
return last * gcd;
for (long i = 0; i < count && n - d[i] >= 0; i++)
{
if (set.Contains(n - d[i]))
{
if (n >= a)
return n * gcd;
if ((a - n) % d[0] == 0)
return a * gcd;
set.Add(n);
last = n;
break;
}
}
}
}
private static long euclid(long a, long b)
{
while (b != 0)
{
long h = a % b;
a = b;
b = h;
}
return a;
}

I am assuming that you are looking for a performant solution with a relatively small amount of denominations b (e.g. less than 100 denominations). While the amount a and the denominations d[i] can be quite large (e.g. less than 10^6).
Sort d ascending and remove duplicates. When rounding down only keep the values smaller or equal than a and when rounding up keep only the smallest value greater or equal than a and discard the greater ones.
(Optional) remove all numbers which are a multiple of some other number O(b^2).
Calculate the greatest common divisor gcd of the denominations. You can use the Euclidean algorithm starting with the first two numbers then calculate the greatest common divisor of the result and the third number and so on. Of course you can stop as soon as you reach one.
Divide a by gcd, round like you want to round the result (using integer division, rounding down: a /= gcd, rounding up: a = (a + gcd - 1) / gcd).
Divide all denominations by gcd (d[i] /= gcd). Now the greatest common divisor of all denominations is one and therefore it is guaranteed that a Frobenius number exists (all amounts greater than that number can be built and require no rounding). While doing so you can also check if the new value leads to a % d[i] == 0 and immediately return a * gcd if so.
Create a hash set for the values which can be built. It is better than an array because the array is potentially wasting a lot of space (remember the Frobenius number). Add zero to the set.
Create a variable n for the current number, initialize with smallest denomination: n = d[0].
If n can be built with any of the available denominations, in other words the set contains any of n - d[i] then proceed with the next step. Otherwise increase n by one and repeat this step unless n == a and you are rounding down, then you can return the last number that could be built multiplied by gcd immediately. You could also remove n - d[b - 1] from the set each time because this value will not be requested any more.
If n >= a return n * gcd (can only be true when rounding up, rounding down would have returned the result in step 8. already). Else if (a - n) % d[0] == 0 return a * gcd. This check is even better than looking for the Frobenius number (the number after which d[0] - 1 consecutive values can be built), it is more or less the equivalent (d[0] - 1 consecutive values means the difference between one of them and a modulo d[0] has to be zero) but could return much faster. Else increase n by one and continue with step 8.
An example with d = {4, 6} and a = 9999 (or any other big odd number) shows the advantages of this algorithm. It is easy to see that odd numbers can never be built and we would fill up the whole set with all even numbers except 2. But if we divide by gcd we get d = {2, 3} and aUp = 5000 and aDown = 4999. The Frobenius number for {2, 3} is 1 (the only number which cannot be built), so after at most 3 (first number where all modulos are covered) steps (instead of 10000) the modulo would be zero and we would return a * gcd which gives 9998 or 10000 depending on rounding direction, which is the correct result.
Here is the code with test included. I did six runs on my crappy notebook and it took 90, 92, 108, 94, 96 and 101 seconds (edit: early loop escape if current denomination greater than current number && n - d[i] >= 0 halves the times and gives an average of about 45s) for 7200 random roundings (3600 in each direction) with combinations of different amounts of denominations (range 2 to 100), dMax (range 100 to 10^6) and aMax (range 10^4 to 10^6), (see the code at the bottom for the exact values). I think the time for the random number generation and output can be neglected, so with this input and the given ranges the algorithm rounds about 160 numbers per second on average (edit: see thirty times faster version below).
public static final int round(int a, int[] d, boolean up) {
d = d.clone(); // otherwise input gets changed
Arrays.sort(d);
if (a < d[0])
return up ? d[0] : 0;
int count = 0;
for (int i = 0; i < d.length; i++) {
if (d[i] == 0)
continue;
for (int j = i + 1; j < d.length; j++)
if (d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
int gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++) {
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
Set<Integer> set = new HashSet<>();
set.add(0);
int last = 0;
for (int n = d[0];; n++) {
if (!up && n > a)
return last * gcd;
for (int i = 0; i < count && n - d[i] >= 0; i++) {
if (set.contains(n - d[i])) {
if (n >= a)
return n * gcd;
if ((a - n) % d[0] == 0)
return a * gcd;
set.add(n);
last = n;
break;
}
}
}
}
public static final int euclid(int a, int b) {
while (b != 0) {
int h = a % b;
a = b;
b = h;
}
return a;
}
public static final int REPEAT = 100;
public static final int[] D_COUNT = {2, 5, 10, 20, 50, 100};
public static final int[] D_MAX = {100, 10000, 1000000};
public static final int[] A_MAX = {10000, 1000000};
public static void main(String[] args) {
long start = System.currentTimeMillis();
Random r = new Random();
for (int i = 0; i < REPEAT; i++) {
for (int j = 0; j < D_COUNT.length; j++) {
for (int k = 0; k < D_MAX.length; k++) {
for (int l = 0; l < A_MAX.length; l++) {
int[] d = new int[D_COUNT[j]];
for (int m = 0; m < d.length; m++)
d[m] = r.nextInt(D_MAX[k]);
int a = r.nextInt(A_MAX[l]);
System.out.println(round(a, d, false));
System.out.println(round(a, d, true));
}
}
}
}
System.out.println((System.currentTimeMillis() - start) / 1000 + " seconds");
}
As it turns out #Koray's edit 7 is about three times faster for the given input (only for very large gcds my algorithm above is faster). So to get the ultimate algorithm I replaced the dynamic programming part of my algorithm by that of #Koray (with some improvements). It worked, it is roughly ten times faster than edit 7 and thirty times faster than the algorithm above. Which would give about 5000 roundings per second (very rough estimation) on average.
private static int round(int a, int[] d, boolean up) {
d = d.clone();
Arrays.sort(d);
if (a < d[0])
return up ? d[0] : 0;
int count = 0;
for (int i = 0; i < d.length; i++) {
if (d[i] == 0)
continue;
if (a % d[i] == 0)
return a;
for (int j = i + 1; j < d.length; j++)
if (d[j] > 0 && d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
int gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (gcd > 1) {
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++) {
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
}
int best = !up ? d[count - 1] : ((a + d[0] - 1) / d[0] * d[0]);
if (d[count - 1] > a) {
if (d[count - 1] < best)
best = d[count - 1];
count--;
}
Stack<Integer> st = new Stack<Integer>();
BitSet ba = new BitSet(a + 1);
for (int i = 0; i < count; i++) {
ba.set(d[i]);
st.push(d[i]);
}
while (st.size() > 0) {
int v1 = st.pop();
for (int i = 0; i < count; i++) {
int val = v1 + d[i];
if (val <= a && !ba.get(val)) {
if ((a - val) % d[0] == 0)
return a * gcd;
ba.set(val, true);
st.push(val);
if (!up && val > best)
best = val;
} else if (val > a) {
if (up && val < best)
best = val;
break;
}
}
}
return best * gcd;
}

private static void test()
{
var amount = 61;
int[] denoms = new int[] { 20, 50 };
int up = RoundAmount(amount, denoms, true);//->70
int down = RoundAmount(amount, denoms, false);//->60
}
private static int RoundAmount(int amount, int[] denoms, bool roundUp)
{
HashSet<int> hs = new HashSet<int>(denoms);
bool added = true;
while (added)
{
added = false;
var arr = hs.ToArray();
foreach (int v1 in arr)
foreach (int v2 in arr)
if ((v1 < amount) && (v2 < amount) && (hs.Add(v1 + v2)))
added = true;
}
int retval = roundUp ? int.MaxValue : int.MinValue;
foreach (int v in hs)
{
if (roundUp)
{
if ((v < retval) && (v >= amount))
retval = v;
}
else
{
if ((v > retval) && (v <= amount))
retval = v;
}
}
return retval;
}
Edit 7
Edit 6 had a bug if a "0" denom exists. I examined #maraca's code in detail (its just great I think) and inspired on that, I've tried some optimizations on my code. Here are the performance comparisons. (I've tried to convert maraca's code to c#, I hope I ve done it right.)
private static int REPEAT = 100;
private static int[] D_COUNT = { 2, 5, 10, 20, 50, 100 };
private static int[] D_MAX = { 100, 10000, 1000000 };
private static int[] A_MAX = { 10000, 1000000 };
private static void testR()
{
Random r = new Random();
long wMaraca = 0;
long wKoray = 0;
for (int i = 0; i < REPEAT; i++)
{
for (int j = 0; j < D_COUNT.Length; j++)
{
for (int k = 0; k < D_MAX.Length; k++)
{
for (int l = 0; l < A_MAX.Length; l++)
{
int[] d = new int[D_COUNT[j]];
for (int m = 0; m < d.Length; m++)
d[m] = r.Next(D_MAX[k]);
int a = r.Next(A_MAX[l]);
Stopwatch maraca = Stopwatch.StartNew();
int m1 = RoundAmount_maraca(a, d, false);
int m2 = RoundAmount_maraca(a, d, true);
maraca.Stop();
wMaraca += maraca.ElapsedMilliseconds;
Stopwatch koray = Stopwatch.StartNew();
int k1 = RoundAmount_koray(a, d, false);
int k2 = RoundAmount_koray(a, d, true);
koray.Stop();
wKoray += koray.ElapsedMilliseconds;
if ((m1 != k1) || (m2 != k2))
{
throw new Exception("something is wrong!");
}
}
}
}
}
//some results with debug compile
//try1
//maraca: 50757 msec
//koray: 19188 msec
//try2
//maraca: 52623 msec
//koray: 19102 msec
//try3
//maraca: 57139 msec
//koray: 18952 msec
//try4
//maraca: 64911 msec
//koray: 21070 msec
}
private static int RoundAmount_koray(int amount, int[] denoms, bool roundUp)
{
List<int> lst = denoms.ToList();
lst.Sort();
if (amount < lst[0])
return roundUp ? lst[0] : 0;
HashSet<int> hs = new HashSet<int>();
for (int i = 0, count = lst.Count; i < count; i++)
{
int v = lst[i];
if (v != 0)
{
if (v > amount && !roundUp)
break;
if (hs.Add(v))
{
if (amount % v == 0)
return amount;
else
for (int j = i + 1; j < count; j++)
if (lst[j] != 0)
if (v % lst[j] == 0)
lst[j] = 0;
else if (amount % (v + lst[j]) == 0)
return amount;
}
}
}
denoms = hs.ToArray();
HashSet<int> hsOK = new HashSet<int>(denoms);
Stack<int> st = new Stack<int>(denoms);
BitArray ba = new BitArray(amount + denoms.Max() * 2 + 1);
int minOK = amount - denoms.Min();
while (st.Count > 0)
{
int v1 = st.Pop();
foreach (int v2 in denoms)
{
int val = v1 + v2;
if (!ba.Get(val))
{
if (amount % val == 0)
return amount;
ba.Set(val, true);
if (val < amount)
st.Push(val);
if (val >= minOK)
hsOK.Add(val);
}
}
}
if (!roundUp)
{
int retval = 0;
foreach (int v in hsOK)
if (v > retval && v <= amount)
retval = v;
return retval;
}
else
{
int retval = int.MaxValue;
foreach (int v in hsOK)
if (v < retval && v >= amount)
retval = v;
return retval;
}
}
private static int RoundAmount_maraca(int a, int[] d, bool up)
{
d = d.ToArray();
Array.Sort(d);
if (a < d[0])
return up ? d[0] : 0;
int count = 0;
for (int i = 0; i < d.Length; i++)
{
if (d[i] == 0)
continue;
for (int j = i + 1; j < d.Length; j++)
if (d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
int gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++)
{
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
var set = new HashSet<int>();
set.Add(0);
int last = 0;
for (int n = d[0]; ; n++)
{
if (!up && n > a)
return last * gcd;
for (int i = 0; i < count && n - d[i] >= 0; i++)
{
if (set.Contains(n - d[i]))
{
if (n >= a)
return n * gcd;
if ((a - n) % d[0] == 0)
return a * gcd;
set.Add(n);
last = n;
break;
}
}
}
}
private static int euclid(int a, int b)
{
while (b != 0)
{
int h = a % b;
a = b;
b = h;
}
return a;
}
Edit - Maraca in c#
Maraca's last edit clearly outperforms all! I have tried to prepare a better c# conversion of his code + added a ulong version. (int version is ~1.6 times faster than the ulong version)
#region maraca int
private static int RoundAmount_maraca(int a, int[] d0, bool up)
{
int[] d = new int[d0.Length];
Buffer.BlockCopy(d0, 0, d, 0, d.Length * sizeof(int));
Array.Sort(d);
if (a < d[0])
return up ? d[0] : 0;
int count = 0;
for (int i = 0; i < d.Length; i++)
{
if (d[i] == 0)
continue;
for (int j = i + 1; j < d.Length; j++)
if (d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
int gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++)
{
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
int best = !up ? d[count - 1] : ((a + d[0] - 1) / d[0] * d[0]);
if (d[count - 1] > a)
{
if (d[count - 1] < best)
best = d[count - 1];
count--;
}
var st = new Stack<int>();
BitArray ba = new BitArray(a+1);
for (int i = 0; i < count; i++)
{
ba.Set(d[i], true);
st.Push(d[i]);
}
while (st.Count > 0)
{
int v1 = st.Pop();
for (int i = 0; i < count; i++)
{
int val = v1 + d[i];
if (val <= a && !ba.Get(val))
{
if ((a - val) % d[0] == 0)
return a * gcd;
ba.Set(val, true);
st.Push(val);
if (!up && val > best)
best = val;
}
else if (up && val > a && val < best)
best = val;
}
}
return best * gcd;
}
private static int euclid(int a, int b)
{
while (b != 0)
{
int h = a % b;
a = b;
b = h;
}
return a;
}
#endregion
#region maraca ulong
private static ulong RoundAmount_maraca_ulong(ulong a, ulong[] d0, bool up)
{
ulong[] d = new ulong[d0.Length];
Buffer.BlockCopy(d0, 0, d, 0, d.Length * sizeof(ulong));
Array.Sort(d);
if (a < d[0])
return up ? d[0] : 0ul;
int count = 0;
for (int i = 0; i < d.Length; i++)
{
if (d[i] == 0ul)
continue;
for (int j = i + 1; j < d.Length; j++)
if (d[j] % d[i] == 0ul)
d[j] = 0ul;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1ul)) / d[0] * d[0];
ulong gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1ul) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++)
{
d[i] /= gcd;
if (a % d[i] == 0ul)
return a * gcd;
}
ulong best = !up ? d[count - 1] : ((a + d[0] - 1ul) / d[0] * d[0]);
if (d[count - 1] > a)
{
if (d[count - 1] < best)
best = d[count - 1];
count--;
}
var st = new Stack<ulong>();
UlongBitArray ba = new UlongBitArray(a + 1ul);
for (int i = 0; i < count; i++)
{
ba.Set(d[i], true);
st.Push(d[i]);
}
while (st.Count > 0)
{
ulong v1 = st.Pop();
for (int i = 0; i < count; i++)
{
ulong val = v1 + d[i];
if (val <= a && !ba.Get(val))
{
if ((a - val) % d[0] == 0ul)
return a * gcd;
ba.Set(val, true);
st.Push(val);
if (!up && val > best)
best = val;
}
else if (up && val > a && val < best)
best = val;
}
}
return best * gcd;
}
private static ulong euclid(ulong a, ulong b)
{
while (b != 0)
{
ulong h = a % b;
a = b;
b = h;
}
return a;
}
class UlongBitArray
{
ulong[] bits;
public UlongBitArray(ulong length)
{
this.bits = new ulong[(length - 1ul) / 32ul + 1ul];
}
public bool Get(ulong index)
{
return (this.bits[index / 32ul] & (1ul << (int)(index % 32ul))) > 0ul;
}
public void Set(ulong index, bool val)
{
if (val)
this.bits[index / 32ul] |= 1ul << (int)(index % 32ul);
else
this.bits[index / 32ul] &= ~(1ul << (int)(index % 32ul));
}
}
#endregion
Edit 8
I have made some improvements and in random tests outperformed #maraca's latest update :) If you choose to use my custom stack class, please make measurements in release mode. (This custom stack class is of course much slower in debug mode but %5-15 faster than .NET's in relase mode. In my tests using the .NET Stack class did not change the performance comparison between two, its just an extra boost.)
private delegate int RoundAmountDelegate(int amount, int[] denoms, bool roundUp);
private static int REPEAT = 100;
private static int[] D_COUNT = { 2, 5, 10, 20, 50, 100 };
private static int[] D_MAX = { 100, 10000, 1000000 };
private static int[] A_MAX = { 10000, 1000000 };
private static void testR()
{
#if DEBUG
while (true)
#endif
{
Random r = new Random();
long wT1 = 0; RoundAmountDelegate func1 = RoundAmount_maraca;
long wT2 = 0; RoundAmountDelegate func2 = RoundAmount_koray;
for (int i = 0; i < REPEAT; i++)
{
for (int j = 0; j < D_COUNT.Length; j++)
{
for (int k = 0; k < D_MAX.Length; k++)
{
for (int l = 0; l < A_MAX.Length; l++)
{
int[] d = new int[D_COUNT[j]];
ulong[] dl = new ulong[D_COUNT[j]];
for (int m = 0; m < d.Length; m++)
{
d[m] = r.Next(D_MAX[k]) + 1;
dl[m] = (ulong)d[m];
}
int a = r.Next(A_MAX[l]);
ulong al = (ulong)a;
Stopwatch w1 = Stopwatch.StartNew();
int m1 = func1(a, d, false);
int m2 = func1(a, d, true);
w1.Stop();
wT1 += w1.ElapsedMilliseconds;
Stopwatch w2 = Stopwatch.StartNew();
int k1 = func2(a, d, false);
int k2 = func2(a, d, true);
w2.Stop();
wT2 += w2.ElapsedMilliseconds;
if ((m1 != k1) || (m2 != k2))
{
#if !DEBUG
MessageBox.Show("error");
#else
throw new Exception("something is wrong!");
#endif
}
}
}
}
}
//some results with release compile
//maraca: 1085 msec
//koray(with .NET Stack<int>): 801 msec
//maraca: 1127 msec
//koray(with .NET Stack<int>): 741 msec
//maraca: 989 msec
//koray(with .NET Stack<int>): 736 msec
//maraca: 962 msec
//koray(with .NET Stack<int>): 632 msec
//-------------------------------------------
//maraca: 1045 msec
//koray(with custom stack): 674 msec
//maraca: 1060 msec
//koray(with custom stack): 606 msec
//maraca: 1175 msec
//koray(with custom stack): 711 msec
//maraca: 878 msec
//koray(with custom stack): 699 msec
#if !DEBUG
MessageBox.Show(wT1 + " " + wT2 + " %" + (double)wT2 / (double)wT1 * 100d);
#endif
}
}
#region Koray
private static int RoundAmount_koray(int amount, int[] denoms, bool roundUp)
{
int[] sorted = new int[denoms.Length];
Buffer.BlockCopy(denoms, 0, sorted, 0, sorted.Length * sizeof(int));
Array.Sort(sorted);
int minD = sorted[0];
if (amount < minD)
return roundUp ? minD : 0;
HashSet<int> hs = new HashSet<int>();
for (int i = 0, count = sorted.Length; i < count; i++)
{
int v = sorted[i];
if (v != 0)
{
if (!roundUp && v > amount)
break;
else if (hs.Add(v))
{
if (amount % v == 0)
return amount;
else
for (int j = i + 1; j < count; j++)
if (sorted[j] != 0)
if (v % sorted[j] == 0)
sorted[j] = 0;
else if (amount % (v + sorted[j]) == 0)
return amount;
}
}
}
denoms = new int[hs.Count];
int k = 0;
foreach (var v in hs)
denoms[k++] = v;
HashSet<int> hsOK = new HashSet<int>(denoms);
stack st = new stack(denoms);
//Stack<int> st = new Stack<int>(denoms);
BitArray ba = new BitArray(amount + denoms[denoms.Length - 1] * 2 + 1);
int minOK = roundUp ? amount : amount - minD;
int maxOK = roundUp ? amount + minD : amount;
while (st.Count > 0)
{
int v1 = st.Pop();
foreach (int v2 in denoms)
{
int val = v1 + v2;
if (val <= maxOK)
{
if (!ba.Get(val))
{
if (amount % val == 0)
return amount;
int diff = amount - val;
if (diff % v1 == 0 || diff % v2 == 0)
return amount;
ba.Set(val, true);
if (val < amount)
st.Push(val);
if (val >= minOK)
hsOK.Add(val);
}
}
else
break;
}
}
if (!roundUp)
{
int retval = 0;
foreach (int v in hsOK)
if (v > retval && v <= amount)
retval = v;
return retval;
}
else
{
int retval = int.MaxValue;
foreach (int v in hsOK)
if (v < retval && v >= amount)
retval = v;
return retval;
}
}
private sealed class stack
{
int[] _array;
public int Count;
public stack()
{
this._array = new int[0];
}
public stack(int[] arr)
{
this.Count = arr.Length;
this._array = new int[this.Count*2];
Buffer.BlockCopy(arr, 0, this._array, 0, this.Count * sizeof(int));
}
public void Push(int item)
{
if (this.Count == this._array.Length)
{
int[] destinationArray = new int[2 * this.Count];
Buffer.BlockCopy(this._array, 0, destinationArray, 0, this.Count * sizeof(int));
this._array = destinationArray;
}
this._array[this.Count++] = item;
}
public int Pop()
{
return this._array[--this.Count];
}
}
#endregion
#region Maraca
private static int RoundAmount_maraca(int a, int[] d0, bool up)
{
int[] d = new int[d0.Length];
Buffer.BlockCopy(d0, 0, d, 0, d.Length * sizeof(int));
Array.Sort(d);
if (a < d[0])
return up ? d[0] : 0;
int count = 0;
for (int i = 0; i < d.Length; i++)
{
if (d[i] == 0)
continue;
for (int j = i + 1; j < d.Length; j++)
if (d[j] % d[i] == 0)
d[j] = 0;
if (d[i] > a && !up)
break;
d[count++] = d[i];
if (d[i] > a)
break;
}
if (count == 1)
return (!up ? a : (a + d[0] - 1)) / d[0] * d[0];
int gcd = euclid(d[1], d[0]);
for (int i = 2; i < count && gcd > 1; i++)
gcd = euclid(d[i], gcd);
if (up)
a = (a + gcd - 1) / gcd;
else
a /= gcd;
for (int i = 0; i < count; i++)
{
d[i] /= gcd;
if (a % d[i] == 0)
return a * gcd;
}
int best = !up ? d[count - 1] : ((a + d[0] - 1) / d[0] * d[0]);
if (d[count - 1] > a)
{
if (d[count - 1] < best)
best = d[count - 1];
count--;
}
var st = new Stack<int>();
BitArray ba = new BitArray(a + 1);
for (int i = 0; i < count; i++)
{
ba.Set(d[i], true);
st.Push(d[i]);
}
while (st.Count > 0)
{
int v1 = st.Pop();
for (int i = 0; i < count; i++)
{
int val = v1 + d[i];
if (val <= a && !ba.Get(val))
{
if ((a - val) % d[0] == 0)
return a * gcd;
ba.Set(val, true);
st.Push(val);
if (!up && val > best)
best = val;
}
else if (up && val > a && val < best)
best = val;
}
}
return best * gcd;
}
private static int euclid(int a, int b)
{
while (b != 0)
{
int h = a % b;
a = b;
b = h;
}
return a;
}
#endregion

This is a standard Knapsack problem and you can google it to refer to its wiki page for its concept.
I think your problem can be splitted to two parts.
Do Knapsack for denominations.
Use f[i] to represent the last denomination used to construct amount i, and f[i]==-1 means that i is not able to get.
fill f with -1
f[0] = 0
for i from 0 to target_amount + min(denoms) - 1
for j from 0 to denoms.size()
if f[i - denoms[j]] != -1
{
f[i] = denoms[j]
break
}
Find nearest amount based on roundUp.
roundUp == true
Starting from target_amount, ascendingly find a f[i] which is not -1.
roundUp == false
Starting from target_amount, descendingly find a f[i] which is not -1.
Optional: find which denominations construct your target amount
Backtrack your f[target_amount].

Just fill array of length amount + smallestdenomination + 1 with possible combinations of coins (standard dynamic programming problem).
Then walk this array from amount index in rounding direction.
Delphi example
var
A : array of Integer;
Denoms: array of Integer;
coin, amount, idx, i, Maxx: Integer;
roundUp: Boolean;
s: string;
begin
amount := 29;
SetLength(Denoms, 2);
Denoms[0] := 7;
Denoms[1] := 13;
Maxx := amount + MinIntValue(Denoms);
SetLength(A, Maxx + 1);
A[0] := 1;
for coin in Denoms do begin
for i := 0 to Maxx - coin do
if A[i] <> 0 then
A[i + coin] := coin;
end;
roundUp := True;
idx := amount;
i := 2 * Ord(roundUp) - 1;// 1 for roundUp=true, -1 for false
while A[idx] = 0 do //scan for nonzero entry
idx := idx + i;
s := '';
while idx > 0 do begin //roll back to get components of this sum
s := s + Format('%d ', [A[idx]]);
idx := idx - A[idx];
end;
Memo1.Lines.Add(s);
outputs 13 13 7 combination for roundUp := True; and 7 7 7 7 otherwise.
(Code does not seek for "optimal" solution)
Example for coins 3 and 5:
[0, 0, 0, 3, 0, 5, 3, 0, 5, 3, 5]
To find what coins make cell 8, step down by cell value:by 5 then by 3.

The Coin Problem is a well-researched topic and I would like to reference some papers where you can probably find better solutions:
The Money Changing Problem Revisited
Coin Problem
Also, using C# (statically typed language) will restrict you from having the most efficient algorithm over a dynamically typed language. If you plan to go down that route, you can have a look at this website The Frobenius problem. You can right click and inspect the code (though I really didn't understand much having no experience of javascript)
Anyhow, this is how I would tackle the problem in C#:
private static List<int> _denominations = new List<int>() { 1000, 5000 };
private static int _denominationMin = _denominations[0];
static void Main()
{
bool roundDown = false;
Console.WriteLine("Enter number: ");
int input = Convert.ToInt32(Console.ReadLine());
if(roundDown)
{
for(int i = input; i > _denominationMin; i--)
{
if(Check(0,0,i))
{
Console.WriteLine("Number: {0}", i);
break;
}
}
}
else
{
for (int i = input; i < int.MaxValue; i++)
{
if (Check(0, 0, i))
{
Console.WriteLine("Number: {0}", i);
break;
}
}
}
Console.Read();
}
static bool Check(int highest, int sum, int goal)
{
//Bingo!
if (sum == goal)
{
return true;
}
//Oops! exceeded here
if (sum > goal)
{
return false;
}
// Loop through _denominations.
foreach (int value in _denominations)
{
// Add higher or equal amounts.
if (value >= highest)
{
if(Check(value, sum + value, goal))
{
return true;
}
}
}
return false;
}
Worked well with {4,6} for input 19999, so I don't think it is all that bad. Surely has scope for improvements for not running into Stackoverflow Exception. One could half the input or quarter it. Or subtract a number that has factors whose subset are the denominations. Also, important to have the denominations sorted and contain no multiples of another entry E.x. {4, 6, 8} -> {4, 6}.
Anyhow, if I have time I will try to make it more efficient. Just wanted to provide an alternate solution.

Need to optimise counting positive and negative values

I need to optimise code that counts pos/neg values and remove non-qualified values by time.
I have queue of values with time-stamp attached.
I need to discard values which are 1ms old and count negative and positive values. here is pseudo code
list<val> l;
v = q.dequeue();
deleteold(l, v.time);
l.add(v);
negcount = l.count(i => i.value < 0);
poscount = l.count(i => i.value >= 0);
if(negcount == 10) return -1;
if(poscount == 10) return 1;
I need this code in c# working with max speed. No need to stick to the List. In fact arrays separated for neg and pos values are welcome.
edit: probably unsafe arrays will be the best. any hints?
EDIT: thanks for the heads up.. i quickly tested array version vs list (which i already have) and the list is faster: 35 vs 16 ms for 1 mil iterations...
Here is the code for fairness sake:
class Program
{
static int LEN = 10;
static int LEN1 = 9;
static void Main(string[] args)
{
Var[] data = GenerateData();
Stopwatch sw = new Stopwatch();
for (int i = 0; i < 30; i++)
{
sw.Reset();
ArraysMethod(data, sw);
Console.Write("Array: {0:0.0000}ms ", sw.ElapsedTicks / 10000.0);
sw.Reset();
ListMethod(data, sw);
Console.WriteLine("List: {0:0.0000}ms", sw.ElapsedTicks / 10000.0);
}
Console.ReadLine();
}
private static void ArraysMethod(Var[] data, Stopwatch sw)
{
int signal = 0;
int ni = 0, pi = 0;
Var[] n = new Var[LEN];
Var[] p = new Var[LEN];
for (int i = 0; i < LEN; i++)
{
n[i] = new Var();
p[i] = new Var();
}
sw.Start();
for (int i = 0; i < DATALEN; i++)
{
Var v = data[i];
if (v.val < 0)
{
int x = 0;
ni = 0;
// time is not sequential
for (int j = 0; j < LEN; j++)
{
long diff = v.time - n[j].time;
if (diff < 0)
diff = 0;
// too old
if (diff > 10000)
x = j;
else
ni++;
}
n[x] = v;
if (ni >= LEN1)
signal = -1;
}
else
{
int x = 0;
pi = 0;
// time is not sequential
for (int j = 0; j < LEN; j++)
{
long diff = v.time - p[j].time;
if (diff < 0)
diff = 0;
// too old
if (diff > 10000)
x = j;
else
pi++;
}
p[x] = v;
if (pi >= LEN1)
signal = 1;
}
}
sw.Stop();
}
private static void ListMethod(Var[] data, Stopwatch sw)
{
int signal = 0;
List<Var> d = new List<Var>();
sw.Start();
for (int i = 0; i < DATALEN; i++)
{
Var v = data[i];
d.Add(new Var() { time = v.time, val = v.val < 0 ? -1 : 1 });
// delete expired
for (int j = 0; j < d.Count; j++)
{
if (v.time - d[j].time < 10000)
d.RemoveAt(j--);
else
break;
}
int cnt = 0;
int k = d.Count;
for (int j = 0; j < k; j++)
{
cnt += d[j].val;
}
if ((cnt >= 0 ? cnt : -cnt) >= LEN)
signal = 9;
}
sw.Stop();
}
static int DATALEN = 1000000;
private static Var[] GenerateData()
{
Random r = new Random(DateTime.Now.Millisecond);
Var[] data = new Var[DATALEN];
Var prev = new Var() { val = 0, time = DateTime.Now.TimeOfDay.Ticks};
for (int i = 0; i < DATALEN; i++)
{
int x = r.Next(20);
data[i] = new Var() { val = x - 10, time = prev.time + x * 1000 };
}
return data;
}
class Var
{
public int val;
public long time;
}
}

To get negcount and poscount, you are traversing the entire list twice.
Instead, traverse it once (to compute negcount), and then poscount = l.Count - negcount.

Some ideas:
Only count until max(negcount,poscount) becomes 10, then quit (no need to count the rest). Only works if 10 is the maximum count.
Count negative and positive items in 1 go.
Calculate only negcount and infer poscount from count-negcount which is easier to do than counting them both.
Whether any of them are faster than what you have now, and which is fastest, depends among other things on what the data typically looks like. Is it long? Short?
Some more about 3:
You can use trickery to avoid branches here. You don't have to test whether the item is negative, you can add its negativity to a counter. Supposing the item is x and it is an int, x >> 31 is 0 for positive x and -1 for negative x. So counter -= x >> 31 will give negcount.
Edit: unsafe arrays can be faster, but shouldn't be in this case, because the loop would be of the form
for (int i = 0; i < array.Length; i++)
do something with array[i];
Which is optimized by the JIT compiler.