From 7f24a50c9a7c37f32596ed52c52204aab24b5b17 Mon Sep 17 00:00:00 2001 From: "Nicholas.Morhun" Date: Sat, 10 Oct 2015 21:40:11 +0300 Subject: [PATCH 1/4] Initial commit --- .gitignore | 3 +++ src/Main.java | 8 ++++++++ 2 files changed, 11 insertions(+) create mode 100644 .gitignore create mode 100644 src/Main.java diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a8e25f1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*.iml +.idea/ +/out/ diff --git a/src/Main.java b/src/Main.java new file mode 100644 index 0000000..34957a8 --- /dev/null +++ b/src/Main.java @@ -0,0 +1,8 @@ + +public class Main { + + public static void main(String args[]) { + System.out.println("Test"); + } + +} \ No newline at end of file From 4601b3c021396a7924a2cb0a41dfcf759e551b28 Mon Sep 17 00:00:00 2001 From: "Nicholas.Morhun" Date: Sat, 10 Oct 2015 21:44:40 +0300 Subject: [PATCH 2/4] Added FibonacciSequencePrinter --- src/Main.java | 12 +++- src/fibonacci/FibonacciSequencePrinter.java | 67 +++++++++++++++++++++ 2 files changed, 78 insertions(+), 1 deletion(-) create mode 100644 src/fibonacci/FibonacciSequencePrinter.java diff --git a/src/Main.java b/src/Main.java index 34957a8..aae1107 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,8 +1,18 @@ +import fibonacci.FibonacciSequencePrinter; public class Main { public static void main(String args[]) { - System.out.println("Test"); + test(); + } + + private static void test() { + // test Fibonacci's number sequence + FibonacciSequencePrinter fibonacciSequencePrinter = new FibonacciSequencePrinter(10); + fibonacciSequencePrinter.print(); + System.out.println("=================================================="); + fibonacciSequencePrinter.setLengthOfSequence(200); + fibonacciSequencePrinter.print(); } } \ No newline at end of file diff --git a/src/fibonacci/FibonacciSequencePrinter.java b/src/fibonacci/FibonacciSequencePrinter.java new file mode 100644 index 0000000..8abaf46 --- /dev/null +++ b/src/fibonacci/FibonacciSequencePrinter.java @@ -0,0 +1,67 @@ +package fibonacci; + +import java.math.BigInteger; + +/** + * Class for printing first n members of Fibonacci's sequence + * @version 1.0 + * @author Morhun N. + */ +public class FibonacciSequencePrinter { + + /** the point of transition from long to BigInteger */ + private static final long TRANSITION_POINT = 92; + + private long lengthOfSequence; + + public FibonacciSequencePrinter(long lengthOfSequence) { + setLengthOfSequence(lengthOfSequence); + } + + public void setLengthOfSequence(long lengthOfSequence) { + if (lengthOfSequence < 2) { + throw new IllegalArgumentException("Fibonacci's sequence must have at least two members!"); + } + this.lengthOfSequence = lengthOfSequence; + } + + /** + * Prints sequence of fibonacci's numbers to {@code lengthOfSequence} + */ + public void print() { + // print two first Fibonacci's numbers + System.out.println("1 : 1"); + System.out.println("2 : 1"); + // print rest + if (lengthOfSequence < TRANSITION_POINT) { + printUsingLong(); + } else { + printUsingBigInteger(); + } + } + + private void printUsingLong() { + long prev1 = 1; + long prev2 = 1; + long current; + for (long counter = 3; counter <= lengthOfSequence; counter++) { + current = prev1 + prev2; + prev2 = prev1; + prev1 = current; + System.out.println(counter + " : " + current); + } + } + + private void printUsingBigInteger() { + BigInteger prev1 = BigInteger.ONE; + BigInteger prev2 = BigInteger.ONE; + BigInteger current; + for (long counter = 3; counter <= lengthOfSequence; counter++) { + current = prev1.add(prev2); + prev2 = prev1; + prev1 = current; + System.out.println(counter + " : " + current); + } + } + +} From d55922e3083b5234ced308024d435d05cdb1095d Mon Sep 17 00:00:00 2001 From: "Nicholas.Morhun" Date: Sat, 10 Oct 2015 22:55:08 +0300 Subject: [PATCH 3/4] Added factorial calculator --- src/Main.java | 11 +++- src/factorial/FactorialCalculator.java | 79 ++++++++++++++++++++++++++ 2 files changed, 89 insertions(+), 1 deletion(-) create mode 100644 src/factorial/FactorialCalculator.java diff --git a/src/Main.java b/src/Main.java index aae1107..4f2c857 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,3 +1,4 @@ +import factorial.FactorialCalculator; import fibonacci.FibonacciSequencePrinter; public class Main { @@ -10,9 +11,17 @@ private static void test() { // test Fibonacci's number sequence FibonacciSequencePrinter fibonacciSequencePrinter = new FibonacciSequencePrinter(10); fibonacciSequencePrinter.print(); - System.out.println("=================================================="); + System.out.println("--------------------------------------------------"); fibonacciSequencePrinter.setLengthOfSequence(200); fibonacciSequencePrinter.print(); + + System.out.println("=================================================="); + + // test factorial calculator + FactorialCalculator factorialCalculator = new FactorialCalculator(); + System.out.println(factorialCalculator.calculate(5)); + System.out.println(factorialCalculator.calculate(50)); + } } \ No newline at end of file diff --git a/src/factorial/FactorialCalculator.java b/src/factorial/FactorialCalculator.java new file mode 100644 index 0000000..633ac9e --- /dev/null +++ b/src/factorial/FactorialCalculator.java @@ -0,0 +1,79 @@ +package factorial; + +import java.math.BigInteger; + +/** + * Class for calculating factorials + * @version 1.0 + * @author Morhun N. + */ +public class FactorialCalculator { + + /** the point of transition from long to BigInteger */ + private static final long TRANSITION_POINT = 20; + + /** + * Calculates factorial function. + * If result can be placed in {@code long} its used, + * otherwise {@code BigInteger} is used. + * @param arg factorial function argument + * @return factorial of argument + */ + public Number calculate(int arg) { + return factorialFactory(arg).calculate(arg); + } + + private Factorial factorialFactory(int arg) { + if (arg < 0) { + throw new IllegalArgumentException("Factorial argument must be non negative"); + } + Factorial factorial; + if (arg < TRANSITION_POINT) { + factorial = new FactorialLong(); + } else { + factorial = new FactorialBigInteger(); + } + return factorial; + } + + private abstract class Factorial { + + public Number calculate(int arg) { + T result = initResult(); + for (int counter = 1; counter <= arg; counter++) { + result = nextIteration(result, counter); + } + return result; + } + + protected abstract T initResult(); + protected abstract T nextIteration(T currentResult, int currentIterator); + } + + private class FactorialLong extends Factorial { + + @Override + protected Long initResult() { + return 1l; + } + + @Override + protected Long nextIteration(Long currentResult, int currentIterator) { + return currentResult * currentIterator; + } + } + + private class FactorialBigInteger extends Factorial { + + @Override + protected BigInteger initResult() { + return BigInteger.ONE; + } + + @Override + protected BigInteger nextIteration(BigInteger currentResult, int currentIterator) { + return currentResult.multiply(BigInteger.valueOf(currentIterator)); + } + } + +} From ace897aaff5f82db627ecdd3f80e3d3f85ec34a8 Mon Sep 17 00:00:00 2001 From: "Nicholas.Morhun" Date: Sun, 11 Oct 2015 01:54:17 +0300 Subject: [PATCH 4/4] Added numbers in words writer --- src/Main.java | 22 ++- src/numbersWriter/NumbersWriterInWords.java | 163 ++++++++++++++++++++ 2 files changed, 181 insertions(+), 4 deletions(-) create mode 100644 src/numbersWriter/NumbersWriterInWords.java diff --git a/src/Main.java b/src/Main.java index 4f2c857..161479d 100644 --- a/src/Main.java +++ b/src/Main.java @@ -1,13 +1,14 @@ import factorial.FactorialCalculator; import fibonacci.FibonacciSequencePrinter; +import numbersWriter.NumbersWriterInWords; public class Main { public static void main(String args[]) { - test(); + tests(); } - private static void test() { + private static void tests() { // test Fibonacci's number sequence FibonacciSequencePrinter fibonacciSequencePrinter = new FibonacciSequencePrinter(10); fibonacciSequencePrinter.print(); @@ -18,10 +19,23 @@ private static void test() { System.out.println("=================================================="); // test factorial calculator + int testFactorialCalculateArray[] = {5, 50}; FactorialCalculator factorialCalculator = new FactorialCalculator(); - System.out.println(factorialCalculator.calculate(5)); - System.out.println(factorialCalculator.calculate(50)); + for (int x : testFactorialCalculateArray) { + System.out.println("Factorial of " + x + " is " + + factorialCalculator.calculate(x)); + } + System.out.println("=================================================="); + + // test writing number in words + long[] testWriteInWordsArray = {4587l, -505l, 1000000000000001l, 30, + -1234567890l, 5278234857329573485l, 30109005l, 0}; + NumbersWriterInWords numbersWriterInWords = new NumbersWriterInWords(); + for (long number : testWriteInWordsArray) { + System.out.print("\nNumber " + number + " read as: "); + numbersWriterInWords.printNumberInWords(number); + } } } \ No newline at end of file diff --git a/src/numbersWriter/NumbersWriterInWords.java b/src/numbersWriter/NumbersWriterInWords.java new file mode 100644 index 0000000..afc39a0 --- /dev/null +++ b/src/numbersWriter/NumbersWriterInWords.java @@ -0,0 +1,163 @@ +package numbersWriter; + +import java.util.ArrayList; +import java.util.List; + +/** + * Class for generating {code String} from number + * @version 1.0 + * @author Morhun N. + */ +public class NumbersWriterInWords { + + private static final int MAXIMAL_NUMBER_OF_GROUPS = 7; // long can not contain more + private static final String GROUP_NAMES[] = { + "", + "thousand", + "million", + "milliard", + "billion", + "billiard", + "trillion" + }; + private static final String DIGITS[] = { + "zero", + "one", + "two", + "three", + "four", + "five", + "six", + "seven", + "eight", + "nine" + }; + private static final String DOZENS[] = { + "", + "ten", + "twenty", + "thirty", + "forty", + "fifty", + "sixty", + "seventy", + "eighty", + "ninety" + }; + private static final String NUMBERS_FROM_10_TO_19[] = { + "ten", + "eleven", + "twelve", + "thirteen", + "fourteen", + "fifteen", + "sixteen", + "seventeen", + "eighteen", + "nineteen" + }; + private static final String MINUS_WORD = "minus"; + private static final String HUNDRED_WORD = "hundred"; + private static final String AND_WORD = "and"; + + /** + * Writes specified number in words + * @param number number for writing in words + * @return specified number in words + */ + public String getNumberInWords(long number) { + if (number == 0l) { + return DIGITS[0]; + } + + List result = new ArrayList<>(); + if (number < 0) { + result.add(MINUS_WORD); + number = - number; + } + + int groups[] = divideNumberOnGroups(number); + for (int i = MAXIMAL_NUMBER_OF_GROUPS - 1; i >= 0; i--) { + if (groups[i] != 0) { + result.addAll(getGroupInWords(groups[i], i)); + } + } + + return joinList(result); + } + + /** + * Prints into console specified number in words + * @param number number for printing + */ + public void printNumberInWords(long number) { + System.out.print(getNumberInWords(number)); + } + + /** + * Divides number on groups of three digits + * @param number number for dividing on groups + * @return array of groups of specified number + */ + private int[] divideNumberOnGroups(long number) { + int groups[] = new int[MAXIMAL_NUMBER_OF_GROUPS]; + for (int i = 0; i < MAXIMAL_NUMBER_OF_GROUPS && number != 0l; i++) { + groups[i] = (int) (number % 1000); + number /= 1000; + } + return groups; + } + + /** + * Forming a group of three digits and adds corresponding to this group suffix + * If group is empty (all numbers are zeros) then returns empty list + * @param group group of three digits + * @param groupNumber sequence number of group + * @return formed group with corresponding suffix + */ + private List getGroupInWords(int group, int groupNumber) { + List result = new ArrayList<>(5); + + int hundreds = group / 100; + int tensAndUnits = group % 100; + + if (hundreds != 0) { + result.add(DIGITS[hundreds]); + result.add(HUNDRED_WORD); + } + if (tensAndUnits != 0) { + if (hundreds != 0) { + result.add(AND_WORD); + } + + if (tensAndUnits < 10) { + result.add(DIGITS[tensAndUnits]); + } else if (tensAndUnits < 20) { + result.add(NUMBERS_FROM_10_TO_19[tensAndUnits - 10]); + } else { + int dozens = tensAndUnits / 10; + int units = tensAndUnits % 10; + result.add(DOZENS[dozens]); + if (units != 0) { + result.add(DIGITS[units]); + } + } + } + + if (! result.isEmpty()) { + result.add(GROUP_NAMES[groupNumber]); + } + + return result; + } + + /** + * Joins string list into one string with whitespace as separator + * @param list string list for joining into one string + * @return joined into string list + */ + private String joinList(List list) { + return String.join(" ", list); + } + +}