HackerRank Chocolate Feast Solution

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

int main() {

    int t, n, c, m;
    scanf("%d", &t);
    while ( t-- )
    {
    scanf("%d%d%d",&n,&c,&m);
        n/=c;
        int k = n;
        while (n >= m )
        {
             k++,n-=(m-1);   
        }
        printf("%d\n",k);
    }
    return 0;
}

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;


int main() {
    /* Enter your code here. Read input from STDIN. Print output to STDOUT */   
    int t,n,c,m;
    cin>>t;
    while(t--){
        cin>>n>>c>>m;
        int ans=0;
        ans+=n/c;
        int x=n/c;
        while(x>=m){
            ans+=x/m;
            x=x/m+x%m;
        }
        cout<<ans<<endl;
    }
    return 0;
}

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for(int i = 0; i < t; i++){
            System.out.println(f(in.nextInt(), in.nextInt(), in.nextInt()));
        }
    }
    
    private static long f(int n, int a, int b){
        return n/a + g(n/a, b);
    }
    
    private static long g(int a, int b){
        if(a < b) return 0;
        else return a/b + g(a-a/b*b + a/b, b);
    }
}

T = int(raw_input())
for t in xrange(T):
    N, C, M = [int(e) for e in raw_input().strip().split()]
    chocolates = 0
    wrappers = 0
    while N >= C:
        nc = N // C
        N -= (nc * C)
        chocolates += nc
        wrappers += nc
    while wrappers >= M:
        wr = wrappers // M
        wrappers -= M * wr
        wrappers += wr
        chocolates += wr
    print chocolates

function processData(input) {
    input = input.trim();
    var lines = input.split("\n");
    var T = parseInt(lines[0]);
    for(var i = 1; i <= T;i++){
        var data = lines[i].split(" ");
        var N = parseInt(data[0]);
        var M = parseInt(data[2]);
        var C = parseInt(data[1]);
        var total = Math.floor(N/C);
        var add = Math.floor(total/M);
        
        var sum = add;
        add += total%M;
        while(add >= M){
            var cho = Math.floor(add/M);
            add = cho + add%M;
            sum += cho;
        }
        
        
        console.log(total+sum);
    }    
} 

process.stdin.resume();
process.stdin.setEncoding("ascii");
_input = "";
process.stdin.on("data", function (input) {
    _input += input;
});

process.stdin.on("end", function () {
   processData(_input);
});

import scala.io._

object Solution {

	val in = new In(Source.stdin)
	
	def main(args: Array[String]): Unit = 
	{
		val testCount = in().toInt
		for (_ <- 1 to testCount)
		{
			val N, C, M = in().toInt
			
			var cho = N/C
			var wrap = cho
			
			while (wrap >= M)
			{
				cho += wrap/M 
				wrap = wrap%M + wrap/M
			}
			
			println(cho)
		}
	}
}

class TokenIterator(iter: BufferedIterator[Char], delims: String) extends Iterator[String]
{	
	private val sb = new StringBuilder
	def hasNext: Boolean = {
		skipDelims()
		iter.hasNext
	}
	def skipDelims() {
		while (iter.hasNext && delims.indexOf(iter.head) != -1) {
			iter.next()
		}
	}
	def next(): String = {
		skipDelims()
		while (iter.hasNext && delims.indexOf(iter.head) == -1) {
			sb.append(iter.next())
		}
		val ret = sb.toString()
		sb.clear()
		ret
	}
}

class In(source: Source) {
	val iter = source.buffered
	val tokenIterator = new TokenIterator(iter, " \r\n")
	val lineIterator = new TokenIterator(iter, "\r\n")
	def apply() = tokenIterator.next() // lineIterator.next()
	def apply(n: Int) = lineIterator.take(n)
}

var tt,ii,n,m,c,w,res,tmp:longint;
var settled:boolean;
begin
    read(tt);
    for ii:=1 to tt do begin
        read(n,c,m);
        settled:=false;
        res:=0;
        w:=0;
        while not(settled) do begin
            settled:=true;
            if n>=c then begin
                settled:=false;
                tmp:=trunc(n/c);
                inc(res,tmp);
                n:=n mod c;
                inc(w,tmp);
            end;
            if w>=m then begin
                settled:=false;
                tmp:=trunc(w/m);
                inc(res,tmp);
                w:=w mod m;
                inc(w,tmp);
            end;
        end;
        writeln(res);
    end;
end.