Thursday Code Puzzler: Playing With Numbers

Java solution for a good start:

 
public class Digitizer {
    static final int SUM_MAX=5;
    static int[] digits=new int[SUM_MAX];
   
    static void addDigit(int digitNum, int digitSum){
        int digit=1;
        for (;digit<SUM_MAX-digitSum;digit++){
            digits[digitNum]=digit;
            addDigit(digitNum+1,digitSum+digit);
        }
        printDigit(digitNum,digit);
    }
   
    static private void printDigit(int digitNum,int lastDigit) {
        for (int i=0;i<digitNum;i++)
            System.out.print(digits[i]);
        System.out.println(lastDigit+"\n");
    }

    static public void main(String[] params){
        addDigit(0,0);
    }
}

Jeez... My solution even without buffering the output printing gives me always 0ms...

Probably faster PC...

;)

import java.util.*;

public class Honesty {

	public static void main(String[] args) {
		int MAX_DIGIT = 5;
		int START_DIGIT = 1;
		ArrayList<Integer> al = new ArrayList<Integer>();

		for(int i = 0; i < MAX_DIGIT; i++){
			for (int j = 0; j < MAX_DIGIT; j++) {
				if ( ( (MAX_DIGIT - j) + (START_DIGIT + i) ) == 5 ) {
					al.add( (START_DIGIT + i) * 10 + MAX_DIGIT - j);
				}
				if ( ( (MAX_DIGIT - i) + (START_DIGIT + j) ) == 5 ){
					al.add( (MAX_DIGIT - i) * 10 + START_DIGIT + j);
				}
			}
		}
		System.out.println("There are " + al.size() + " numbers that are added to become 5 \nAnd list is: " + al);
	}

}

Jarek Acyrf was the best although it prints number 5 .
I didn't think about using recursivity and avoiding buffering the output... I will get it next time

Considering 5 as acceptable value: (otherwise change count start from 14 and 53 to 52)

 StringBuffer buffer = new StringBuffer();
        start = System.currentTimeMillis();
        for (int count = 5; count <= 11111; count++) {
            String daNumber = String.valueOf(count);
            int sum = 0;
            for (int i = 0; i < daNumber.length() && sum < 6; i++) {
                if (daNumber.charAt(i) == 48 || daNumber.charAt(i) > 53) {
                    sum = 6;
                    break;
                }
                sum += daNumber.charAt(i) - 48;
            }
            if (sum == 5) {
                buffer.append(daNumber);
                buffer.append("\n");
            }

        }
        System.out.println(System.currentTimeMillis() - start + " millisenconds");

System.out.println(buffer); 

public class Print5 {
    
    int t[] = new int[5];
    
    void find(int size, int sum) {
        if (sum==5) print(size);
        for (int d=1;d<=5-sum;d++) { t[size]=d; find(size+1, sum+d); }
    }
    
    void print(int size) {
        for (int i=0;i<size;i++) System.out.print(t[i]);
        System.out.println();
    }
    
    public static void main(String[] args) {
        new Print5().find(0,0);
    }
}

Why is everyone stopping at 11111?  20000 (5 digits) & 200000000000 (12 digits) still only sum their digits to 1.

To brute force it you have to go 0 -> Integer.MAX_VALUE.  This is in the same vein as the Tower of Hanoi problem.  If nobody posts an answer sooner I'll do so this weekend.

#include <iostream>
using namespace std;

int main() {

	int minVal = 1;
	int maxVal = 4;
		
	for (int i = minVal; i <= maxVal; i++) {
		for (int j = maxVal; j >= minVal; j--) {
			int val = i + j;
			if (val == 5)
				cout << i << j << endl;
			}
		}
	return 0;
}

public class PlayingWithNubers {
    public static void main(String[] args) {        
        int size = 100000000;        
        long startTime = System.currentTimeMillis();        
        for (int i = 0; i < size; i++) {
            char[] arrNum = String.valueOf(i).toCharArray();
            int sum = 0;
            int count = 0;

            for (int j = 0; j < arrNum.length; j++) {
                if (Integer.parseInt(String.valueOf(arrNum[j])) == 0) {
                    count++;
                    break;
                } else {
                    if (count < 1)
                        sum = sum + Integer.parseInt(String.valueOf(arrNum[j]));
                }
            }
            if (count < 1 && sum == 5)
                System.out.println(">>> Number is : " +i + "   and sum is " + sum);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("Total time taken for size = 100000000 is "+(endTime-startTime)/1000 +" seconds.");

    }
}

Result: For size = 100000000

 >>> Number is : 5   and sum is 5
>>> Number is : 14   and sum is 5
>>> Number is : 23   and sum is 5
>>> Number is : 32   and sum is 5
>>> Number is : 41   and sum is 5
>>> Number is : 113   and sum is 5
>>> Number is : 122   and sum is 5
>>> Number is : 131   and sum is 5
>>> Number is : 212   and sum is 5
>>> Number is : 221   and sum is 5
>>> Number is : 311   and sum is 5
>>> Number is : 1112   and sum is 5
>>> Number is : 1121   and sum is 5
>>> Number is : 1211   and sum is 5
>>> Number is : 2111   and sum is 5
>>> Number is : 11111   and sum is 5

Total time taken for size = 100000000 is 47 seconds.

My solution:

public class Main {
    private static final int TARGET_NUMBER = 5;
    private static Collection<Integer> result = new HashSet<Integer>();

    public static void findSolution(int currentDigitCount, int previousSum, int currentValue) {
        if (currentDigitCount <= TARGET_NUMBER) {
            for (int i = (currentValue > 0 ? 1 : 0); i <= TARGET_NUMBER - previousSum; i++) {
                if (previousSum + i == TARGET_NUMBER) {
                    result.add(currentValue * 10 + i);
                } else if (currentDigitCount < TARGET_NUMBER) {
                    findSolution(currentDigitCount + 1, previousSum + i, currentValue * 10 + i);
                }
            }
        }
    }

    public static void main(String[] args) {
        long start = System.nanoTime();
        findSolution(0, 0, 0);
        long end = System.nanoTime();

        for (Integer integer : result) {
            System.out.println(integer);
        }

        System.out.println("Time: " + (end - start));

    }
}

It takes about 150000 nano seconds on my PC.

for(Integer i=0;i<106000;i++)               

{                                 

            int k = i;                                   

            int temp = 0;                            

            while(k > 9)                              

            {                                             

                        if((k%10 == 0)||(k/10 > 4 && k/10 < 10)) {k=0;temp=0; break;}                                    

                        temp = temp + (k%10);                                    

                        k = k/10;                                             

                        if (k < 5) {                                                       

                                    temp = temp + k;                                             

                        }                                 

            }                                 

            if(i == 5 || temp == 5)                          

            {                                             

                        System.err.println("........."+i+".........");                         

            }

}