# CodeChef – Small Factorials

using System;
using System.Collections.Generic;
using System.Numerics;

public class Program
{
public static void Main()
{
List<BigInteger> data = new List<BigInteger>();

for(int i = 0; i < dataSize; i++)
{
}

foreach(BigInteger n in data)
{
Console.WriteLine(CalculateFactorial(n));
}
}

public static BigInteger CalculateFactorial(BigInteger n)
{
if(n > 1)
{
n = n * CalculateFactorial(n-1);
return n;
}
else
{
return n;
}
}
}

So here’s a proper factorial calculator as opposed to the previous post entitled ‘Factorials.’ This code actually calculates the factorial of a number. I have to admit though that this code was not accepted by CodeChef because there is a compiling error due to the fact that CodeChef uses an older version of .Net in which the namespace Numerics does not exist. You can do this with doubles fine but the judge on CodeChef doesn’t accept scientific notation. And if you convert the scientific notation with format specifiers, the number still gets rounded up too much. Apparently there is a way to do this problem without Numerics and the BigInteger data type but I’m pretty satisfied with my solution regardless.

Here’s a link to the problem.

# CodeChef – Factorial

using System;

public class Program
{
public static void Main()
{
double[] data = new double[dataSize];

for(int i = 0; i < dataSize; i++)
{
}

for(int i = 0; i < dataSize; i++)
{
Console.WriteLine(FindTrailingZeros(data[i]));
}
}

public static double FindTrailingZeros(double n)
{
double quotient = 1;
double sumOfQuotients = 0;
int power = 1;

while(true)
{
quotient = n / Math.Pow(5, power);
quotient = Math.Truncate(quotient);
power++;

if(quotient > 0)
{
sumOfQuotients += quotient;
}
else
{
return sumOfQuotients;
}
}
}
}

Here’s my code for the Factorial problem on CodeChef, though I think the title doesn’t really describe the problem well. You are not supposed to find the factorial of a number but rather the number of trailing zeros of the factorial. My first instinct was to find the factorial, put the numbers in a string, and iterate through the string to check for zeros. The problem with that algorithm though is that factorials are huge! And moreover, an input could be as large as 1 billion which would produce an astronomically large number. So I read the editorial for the problem and they had a little trick for finding trailing zeros of a factorial which was way more efficient.

Here’s a link to the problem.

# CodeChef-Bytelandian Gold Coin

using System;
using System.Collections.Generic;

public class Program
{
public static void Main()
{
uint input;
bool b = true;

while(b)
{
if(b)
{
Console.WriteLine(FindBestDeal(input));
}
}
}

static Dictionary<uint, uint> cache = new Dictionary<uint, uint>();

public static uint FindBestDeal(uint n)
{
if(cache.ContainsKey(n))
{
return cache[n];
}

if(n/2 + n/3 + n/4 > n)
{
uint sum = FindBestDeal(n/2) + FindBestDeal(n/3) + FindBestDeal(n/4);
cache[n] = sum;
return sum;
}
else
{
return n;
}
}
}

This is my final solution to the Bytelandian Gold Coin problem on CodeChef. This was my first shot at a problem of a medium level of difficulty on this site. And honestly I thought it was surprisingly simple at first but that was only because I didn’t give the problem proper considerations. I busted out some code, submitted it feeling confident and then found out my solution was incorrect. I went through a number of iterations and finally came up with this.

Here’s a description of the problem here.

I won’t go through every iteration I went through but here are a couple of key concepts required for a problem like this.

### Recursion

Recursion is a concept in which an algorithm calls itself.  In the problem, we need to take a coin, divide it by two, three, and four, and add up the quotients.  If the sum of quotients is greater, than we have to return the highest possible sum.  And in order to do that, we have to divide all of the previous quotients by two, three, and four, and up up those quotients.  For example, 24 becomes 12 +  8 + 6 which is a total of 26.  26 however is not the right answer because one of our new quotients is 12.  And 12 becomes 6 + 4 + 3 which is 13.  So the correct answer for 24 is 27.  So basically you just have use the same logic on all of the cascading quotients as you do the initial input.  Have a look at line 32 to see where the recursion begins.

### Memoization

It’s weawy hawd for me to even think about this technique without giggling.  It weawy takes me back to my pwe-speech class days when I had twouble with my ‘r’ sounds.  Anyways, memoization is a technique used to optimize repeated methods.  It works by caching data and then checking that cache to determine whether or not certain data has already been computed. It seems like a good practice for recursive algorithms as it saves tons of CPU cycles.  And in this problem on CodeChef, you need to implement memoization in order to stay under the time limit.  You can look at the memoization parts of this program on lines 21, 25-28, and 33.

### The uint Data Type

There really isn’t much to this but because the problem potentially requires integers larger than a regular int can store, you need something with a larger boundary like a uint.  Though if you test this program with 1000000000 you still get very close to the maximum integer a uint can store.

# CodeChef-Ciel and A-B

using System;

public class Program
{
public static void Main()
{
string[] splitLines = line.Split(' ');

int a = int.Parse(splitLines[0]);
int b = int.Parse(splitLines[1]);
int answerNumber = a - b;

for(int i = 0; i < length; i++)
{
}

{
}
else
{
}

{
Console.Write(num);
}
}
}

So here’s another solution to a CodeChef problem. The problem is to take two user-generated integers on the same line(‘A’ and ‘B’), find the difference, and then make the answer incorrect but changing one of it’s integers. And finally write the incorrect answer to the console. The OCD part of my brain was not a huge fan of writing an algorithm to produce an incorrect answer to a simple math problem but I think it was overall a good exercise for the basics.

Here’s a link to the problem.

# CodeChef-Enormous Input Test

using System;

public class Program
{
public static void Main()
{
string[] splitLines = lines.Split(' ');

int n = int.Parse(splitLines[0]);
int k = int.Parse(splitLines[1]);
int[] t = new int[n];
int output = 0;

for(int i = 0; i < n; i++)
{
}

foreach(int i in t)
{
if(i % k == 0)
{
output++;
}
}

Console.WriteLine(output);
}
}

I’m now officially addicted to CodeChef. These problems are so much fun. This is my solution to another beginner problem. In this one, the user inputs two integers separated by a space(hints the split with a ‘ ‘ on line 8). The first integer is ‘n’ and it indicates how many numbers are going to be tested. The second integer is ‘k’ and this is going to be used to find out if each subsequent integer is a multiple of ‘k’.

Here’s a link to the problem.

# CodeChef-ATM

using System;

public class Test
{
public static void Main()
{
string[] splitLines = line.Split(' ');

double withdrawal = double.Parse(splitLines[0]);
double balance = double.Parse(splitLines[1]);

if(withdrawal % 5 == 0 && balance >= withdrawal + 0.5)
{
double updatedBalance = balance - withdrawal - 0.5;
Console.WriteLine(updatedBalance.ToString("F"));
}
else
{
Console.WriteLine(balance.ToString("F"));
}
}
}

Here’s my solution to the ATM problem on CodeChef.  The user has to input a withdrawal amount and a balance amount on the same line(Why? IDK).  There is an ATM usage fee of \$0.50 that must be added to the withdrawal.  The withdrawal of course cannot exceed the balance and must be a multiple of 5.  Simple may this problem be, I actually felt like I learned few things from doing it.

1. Split() is a really nifty method for when you need to split strings.
2. Format specifiers, in this case “F”, are really nifty for when you need to specify precision.
3. Try not to get big-headed even when doing simple tasks.  Next thing you know, you’ll have a logical brain fart, get frustrated, and slip into an existential crisis.

Here’s the link to the problem.

# CodeChef

I’ve been looking for a site to practice some programming problems when I came across CodeChef.  It has tons of problems ranging from beginner to advanced.  Some of the more advanced problems are what I would imagine in a coding interview.  You have to make an account but it’s all free.  There are also contests and rankings and things.  It’s pretty convenient too because once you submit your solution, it tells you right away rather you solved it or not as the process is automated.  The following code is my solution to an easy problem I did to test it out.  All it is, is a program to print integers to the console until the number 42 is inputted.  And here’s a link to the problem.

using System;

public class Program
{
public static void Main()
{
int input = 0;

while(input != 42)
{