I want to store integers(in an array or anything) that in range of int "i" and int "j".
eg:-Think, "int i = 1" and "int j = 10".I want to store integers from 1 and 10.
So that (1,2,3,4,5,6,7,8,9,10)
Because I want to answer to HackerRank "Beautiful Days at the Movies".
link below.
https://www.hackerrank.com/challenges/beautiful-days-at-the-movies/problem?isFullScreen=false
here is my code and it a garbage.
static int beautifulDays(int i, int j, int k) {
var total = 0;
for(var a = i; a <= j; a++ )
{
if (a != 0)
{
int ri = Reverse(i);
int rj = Reverse(j);
var ra = Reverse(a);
if((ra/k) % 1 == 0)
{
total++;
}
if((rj/k) % 1 == 0)
{
total++;
}
if((ri/k) % 1 == 0)
{
total++;
}
}
return total;
}
return total;
}
public static int Reverse(int inval)
{
int result = 0;
do
{
result = (result * 10) + (inval % 10);
inval = inval / 10;
}
while(inval > 0);
return result;
}
simply, can you give me the answer of HackerRank "Beautiful Days at the Movies".
link below.
https://www.hackerrank.com/challenges/beautiful-days-at-the-movies/problem?isFullScreen=false
Using Java you can easily stream a range of numbers with IntStream, then map the reverse function for each value, then filter those that fulfils the condition and count. With streams you don't need to store, you can get straight to the answer.
IntUnaryOperator reverse = (opperand) -> {
int reversed = 0;
int num = opperand;
while (num != 0) {
int digit = num % 10;
reversed = reversed * 10 + digit;
num /= 10;
}
return Math.abs(opperand - reversed);
};
return (int) IntStream.rangeClosed(i, j).map(reverse)
.filter(v -> v % k == 0).count();
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.
I've written the following code in C# for obtaining the length of longest common subsequence of two texts given by use, but it doesn't work with large strings. Could you please help me. I'm really confused.
public Form1()
{
InitializeComponent();
}
public int lcs(char[] s1, char[] s2, int s1size, int s2size)
{
if (s1size == 0 || s2size == 0)
{
return 0;
}
else
{
if (s1[s1size - 1] == s2[s2size - 1])
{
return (lcs(s1, s2, s1size - 1, s2size - 1) + 1);
}
else
{
int x = lcs(s1, s2, s1size, s2size - 1);
int y = lcs(s1, s2, s1size - 1, s2size);
if (x > y)
{
return x;
}
else
return y;
}
}
}
private void button1_Click(object sender, EventArgs e)
{
string st1 = textBox2.Text.Trim(' ');
string st2 = textBox3.Text.Trim(' ');
char[] a = st1.ToCharArray();
char[] b = st2.ToCharArray();
int s1 = a.Length;
int s2 = b.Length;
textBox1.Text = lcs(a, b, s1, s2).ToString();
}
Here you are using the Recursion method. So it leads the program to occur performance problems as you mentioned.
Instead of recursion, use the dynamic programming approach.
Here is the C# Code.
public static void LCS(char[] str1, char[] str2)
{
int[,] l = new int[str1.Length, str2.Length];
int lcs = -1;
string substr = string.Empty;
int end = -1;
for (int i = 0; i < str1.Length; i++)
{
for (int j = 0; j < str2.Length; j++)
{
if (str1[i] == str2[j])
{
if (i == 0 || j == 0)
{
l[i, j] = 1;
}
else
l[i, j] = l[i - 1, j - 1] + 1;
if (l[i, j] > lcs)
{
lcs = l[i, j];
end = i;
}
}
else
l[i, j] = 0;
}
}
for (int i = end - lcs + 1; i <= end; i++)
{
substr += str1[i];
}
Console.WriteLine("Longest Common SubString Length = {0}, Longest Common Substring = {1}", lcs, substr);
}
Here is a solution how to find the longest common substring in C#:
public static string GetLongestCommonSubstring(params string[] strings)
{
var commonSubstrings = new HashSet<string>(strings[0].GetSubstrings());
foreach (string str in strings.Skip(1))
{
commonSubstrings.IntersectWith(str.GetSubstrings());
if (commonSubstrings.Count == 0)
return string.Empty;
}
return commonSubstrings.OrderByDescending(s => s.Length).DefaultIfEmpty(string.Empty).First();
}
private static IEnumerable<string> GetSubstrings(this string str)
{
for (int c = 0; c < str.Length - 1; c++)
{
for (int cc = 1; c + cc <= str.Length; cc++)
{
yield return str.Substring(c, cc);
}
}
}
I found it here: http://www.snippetsource.net/Snippet/75/longest-common-substring
Just for fun, here is one example using Queue<T>:
string LongestCommonSubstring(params string[] strings)
{
return LongestCommonSubstring(strings[0], new Queue<string>(strings.Skip(1)));
}
string LongestCommonSubstring(string x, Queue<string> strings)
{
if (!strings.TryDequeue(out var y))
{
return x;
}
var output = string.Empty;
for (int i = 0; i < x.Length; i++)
{
for (int j = x.Length - i; j > -1; j--)
{
string common = x.Substring(i, j);
if (y.IndexOf(common) > -1 && common.Length > output.Length) output = common;
}
}
return LongestCommonSubstring(output, strings);
}
It's still using recursion though, but it's a nice example of Queue<T>.
I refactored the C++ code from Ashutosh Singh at https://iq.opengenus.org/longest-common-substring-using-rolling-hash/ to create a rolling hash approach in C# - this will find the substring in O(N * log(N)^2) time and O(N) space
using System;
using System.Collections.Generic;
public class RollingHash
{
private class RollingHashPowers
{
// _mod = prime modulus of polynomial hashing
// any prime number over a billion should suffice
internal const int _mod = (int)1e9 + 123;
// _hashBase = base (point of hashing)
// this should be a prime number larger than the number of characters used
// in my use case I am only interested in ASCII (256) characters
// for strings in languages using non-latin characters, this should be much larger
internal const long _hashBase = 257;
// _pow1 = powers of base modulo mod
internal readonly List<int> _pow1 = new List<int> { 1 };
// _pow2 = powers of base modulo 2^64
internal readonly List<long> _pow2 = new List<long> { 1L };
internal void EnsureLength(int length)
{
if (_pow1.Capacity < length)
{
_pow1.Capacity = _pow2.Capacity = length;
}
for (int currentIndx = _pow1.Count - 1; currentIndx < length; ++currentIndx)
{
_pow1.Add((int)(_pow1[currentIndx] * _hashBase % _mod));
_pow2.Add(_pow2[currentIndx] * _hashBase);
}
}
}
private class RollingHashedString
{
readonly RollingHashPowers _pows;
readonly int[] _pref1; // Hash on prefix modulo mod
readonly long[] _pref2; // Hash on prefix modulo 2^64
// Constructor from string:
internal RollingHashedString(RollingHashPowers pows, string s, bool caseInsensitive = false)
{
_pows = pows;
_pref1 = new int[s.Length + 1];
_pref2 = new long[s.Length + 1];
const long capAVal = 'A';
const long capZVal = 'Z';
const long aADif = 'a' - 'A';
unsafe
{
fixed (char* c = s)
{
// Fill arrays with polynomial hashes on prefix
for (int i = 0; i < s.Length; ++i)
{
long v = c[i];
if (caseInsensitive && capAVal <= v && v <= capZVal)
{
v += aADif;
}
_pref1[i + 1] = (int)((_pref1[i] + v * _pows._pow1[i]) % RollingHashPowers._mod);
_pref2[i + 1] = _pref2[i] + v * _pows._pow2[i];
}
}
}
}
// Rollingnomial hash of subsequence [pos, pos+len)
// If mxPow != 0, value automatically multiply on base in needed power.
// Finally base ^ mxPow
internal Tuple<int, long> Apply(int pos, int len, int mxPow = 0)
{
int hash1 = _pref1[pos + len] - _pref1[pos];
long hash2 = _pref2[pos + len] - _pref2[pos];
if (hash1 < 0)
{
hash1 += RollingHashPowers._mod;
}
if (mxPow != 0)
{
hash1 = (int)((long)hash1 * _pows._pow1[mxPow - (pos + len - 1)] % RollingHashPowers._mod);
hash2 *= _pows._pow2[mxPow - (pos + len - 1)];
}
return Tuple.Create(hash1, hash2);
}
}
private readonly RollingHashPowers _rhp;
public RollingHash(int longestLength = 0)
{
_rhp = new RollingHashPowers();
if (longestLength > 0)
{
_rhp.EnsureLength(longestLength);
}
}
public string FindCommonSubstring(string a, string b, bool caseInsensitive = false)
{
// Calculate max neede power of base:
int mxPow = Math.Max(a.Length, b.Length);
_rhp.EnsureLength(mxPow);
// Create hashing objects from strings:
RollingHashedString hash_a = new RollingHashedString(_rhp, a, caseInsensitive);
RollingHashedString hash_b = new RollingHashedString(_rhp, b, caseInsensitive);
// Binary search by length of same subsequence:
int pos = -1;
int low = 0;
int minLen = Math.Min(a.Length, b.Length);
int high = minLen + 1;
var tupleCompare = Comparer<Tuple<int, long>>.Default;
while (high - low > 1)
{
int mid = (low + high) / 2;
List<Tuple<int, long>> hashes = new List<Tuple<int, long>>(a.Length - mid + 1);
for (int i = 0; i + mid <= a.Length; ++i)
{
hashes.Add(hash_a.Apply(i, mid, mxPow));
}
hashes.Sort(tupleCompare);
int p = -1;
for (int i = 0; i + mid <= b.Length; ++i)
{
if (hashes.BinarySearch(hash_b.Apply(i, mid, mxPow), tupleCompare) >= 0)
{
p = i;
break;
}
}
if (p >= 0)
{
low = mid;
pos = p;
}
else
{
high = mid;
}
}
// Output answer:
return pos >= 0
? b.Substring(pos, low)
: string.Empty;
}
}
I'm a beginner in C#, trying to make a lottery form applicaton.
There are types, first when you have 5 tips ( otos bool ) and 5 tips ( hatos bool ).
And there are many types of how many numbers will be raffled (tiz, harminc, kilencven, negyvenot).
I tried to scan the numbers after the raffle with Array.Equals with this code:
for (int i = 0; i <= 4; i++)
{
for (int y = 0; y <= 4; y++)
{
if (Array.Equals(lottoszamok[i], lottoszamok[y]))
lottoszamok[i] = r.Next (1, ?);
}
}
but at this the number will be scanned with itself too, so it will be always equal.
here is my code by the way:
if (otos == true)
{
for (int i = 0; i <= 5; i++)
{
if (tiz == true)
{
lottoszamok[i] = r.Next(1, 10);
}
else if (harminc == true)
{
lottoszamok[i] = r.Next(1, 30);
}
else if (kilencven == true)
{
lottoszamok[i] = r.Next(1, 90);
}
else if (negyvenot == true)
{
lottoszamok[i] = r.Next(1, 45);
}
else if (egyeni == true)
{
lottoszamok[i] = r.Next(1, (egyeniertek + 1));
}
}
}
if (hatos == true)
{
for (int i = 0; i <= 6; i++)
{
if (tiz == true)
{
lottoszamok[i] = r.Next(1, 10);
}
else if (harminc == true)
{
lottoszamok[i] = r.Next(1, 30);
}
else if (kilencven == true)
{
lottoszamok[i] = r.Next(1, 90);
}
else if (negyvenot == true)
{
lottoszamok[i] = r.Next(1, 45);
}
else if (egyeni == true)
{
lottoszamok[i] = r.Next(1, (egyeniertek + 1));
}
}
}
If you're trying to pick numbers from a range 1..n without repetitions, you need to "shuffle" the numbers out:
int[] allPossibleNumbers = Enumerable.Range(1, maxNumber).ToArray();
int[] picked = new int[numberToPick];
for (int i = 0; i < numberToPick; i++)
{
int index = r.Next(i, maxNumber);
picked[i] = allPossibleNumbers[index];
allPossibleNumbers[index] = allPossibleNumbers[i];
}
where numberToPick is 5 if otos or 6 if hatos, and maxNumber depends on tiz, harminc, kilencven, negyvenot, egyeni and egyeniertek.
If your maxNumber is huge and you only want to pick a few numbers, the following doesn't require the whole range to be in memory at once:
Dictionary<int, int> outOfPlace = new Dictionary<int,int>();
int[] picked = new int[numberToPick];
for (int i = 0; i < numberToPick; i++)
{
int shuffleOut = outOfPlace.ContainsKey(i) ? outOfPlace[i] : i;
int index = r.Next(i, maxNumber);
picked[i] = 1 + (outOfPlace.ContainsKey(index) ? outOfPlace[index] : index);
outOfPlace[index] = shuffleOut;
outOfPlace.Remove(i);
}
Try this one!
if (i!=y && Array.Equals(lottoszamok[i], lottoszamok[y]))
I made it this way, if you want you could put swapping like method.
static void SwapInts(int[] array, int position1, int position2)
{
// Swaps elements in an array.
int temp = array[position1]; // Copy the first position's element
array[position1] = array[position2]; // Assign to the second element
array[position2] = temp; // Assign to the first element
}
static void Main()
{
Random rng = new Random();
int n = int.Parse(Console.ReadLine());
int[] intarray = new int[n];
for (int i = 0; i < n; i++)
{
// Initialize array
intarray[i] = i + 1;
}
// Exchange resultArray[i] with random element in resultArray[i..n-1]
for (int i = 0; i < n; i++)
{
int positionSwapElement1 = i + rng.Next(0, n - i);
SwapInts(intarray, i, positionSwapElement1);
}
for (int i = 0; i < n; i++)
{
Console.Write(intarray[i] + " ");
}
}
}
I spend many time to get this, but i believe i can do it, now it's done, By the Easier way in the word, this kill every think about Random not duplicate,very simply code without any philosophy or difficulty of Developers made ... (welcome to my work) that (BEST OF THE BEST):
Numbers between (1-10) without any duplicate, 1- MY WORK in C#
private void TenNumbersRandomly()
{
int[] a = new int[10];
Random r = new Random();
int x;
for (int i = 0; i < 10; i++)
{
x= r.Next(1, 11);
for (int j = 0; j <= i ; j++)
{
while (a[j] == x)
{
x = r.Next(1, 11);
j = 0;
}
}
a[i] = x;
tb1.Text += a[i]+"\n";
}
}
2- in VB some Different i also have it :
Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
Dim x As Integer, i As Integer, j As Integer
x = Int(Rnd() * 10) + 1
Label1.Text = ""
Dim a(9) As Integer
For i = 0 To 9
x = Int(Rnd() * 10) + 1
For j = 0 To i
While (a(j) = x)
x = Int(Rnd() * 10) + 1
j = 0
End While
Next j
a(i) = x
Label1.Text += a(i).ToString() + " "
Next i