new problems

Author: Mohamed Sayed-ElMedany

src/main/java/javarevisited/top/fifty/java/programs/from/coding/interviews/ArmstrongNumber.java

@@ -0,0 +1,58 @@
+package javarevisited.top.fifty.java.programs.from.coding.interviews;
+
+import java.util.Scanner;
+
+/**
+ * @author medany
+ */
+
+/*
+ * A number is called an Armstrong number if it is equal to the cube of its each
+ * digit. for example, 153 is an Armstrong number because 153= 1+ 125+27 which
+ * is equal to 1^3+5^3+3^3. You need to write a program to check if given number
+ * is Armstrong number or not.
+ */
+public class ArmstrongNumber {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		sc.close();
+
+		System.out.println("Number : " + n + " is " + (isArmStrong(n) ? "armstrong number" : "not a armstrong number"));
+
+	}
+
+	public static boolean isArmStrong(int number) {
+		int result = 0;
+		int orig = number;
+		while (number != 0) {
+			int remainder = number % 10;
+			result = result + remainder * remainder * remainder;
+			number = number / 10;
+		}
+		if (orig == result) {
+			return true;
+		}
+		return false;
+	}
+
+	public static boolean isArmstrong(int input) {
+
+		Integer number = 0;
+		char[] s = ("" + input).toCharArray();
+
+		for (char c : s) {
+			number += Integer.valueOf("" + c) * Integer.valueOf("" + c) * Integer.valueOf("" + c);
+			if (number.compareTo(input) == 1) {
+				return false;
+			}
+		}
+
+		if (number.compareTo(input) == 0) {
+			return true;
+		}
+		return false;
+	}
+
+}

src/main/java/javarevisited/top/fifty/java/programs/from/coding/interviews/Factorial.java

@@ -0,0 +1,40 @@
+package javarevisited.top.fifty.java.programs.from.coding.interviews;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+
+/**
+ * @author medany
+ */
+
+/*
+ * This is one of the simplest programs you can expect on interviews. It is
+ * generally asked to see if you can code or not. Sometimes interviewer may also
+ * ask about changing a recursive solution to iterative one or vice-versa.
+ */
+public class Factorial {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		BigInteger i = sc.nextBigInteger();
+		sc.close();
+
+		System.out.println("Factorial of number, " + i + ", is : " + Fact(i));
+	}
+
+	public static BigInteger fact(BigInteger num) {
+		if (num.compareTo(BigInteger.ZERO) == 0)
+			return BigInteger.ONE;
+		BigInteger fact = BigInteger.ONE;
+		for (int i = num.intValue(); i > 0; i--) {
+			fact = fact.multiply(BigInteger.valueOf(i));
+		}
+		return fact;
+	}
+
+	public static BigInteger Fact(BigInteger num) {
+		if (num.compareTo(BigInteger.ZERO) == 0)
+			return BigInteger.ONE;
+		return num.multiply(Fact(num.subtract(BigInteger.ONE)));
+	}
+}

src/main/java/javarevisited/top/fifty/java/programs/from/coding/interviews/FindStringRepeatedCharacters.java

@@ -0,0 +1,91 @@
+package javarevisited.top.fifty.java.programs.from.coding.interviews;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Scanner;
+
+/**
+ * @author medany
+ */
+
+/*
+ * 
+ */
+public class FindStringRepeatedCharacters {
+
+	public static void main(String[] args) {
+		Scanner in = new Scanner(System.in);
+		String word = in.nextLine();
+		in.close();
+
+		// Map<String, Integer> result = findDuplicates(word);
+		// Map<String, Integer> result = findduplicates(word);
+		Map<String, Integer> result = findduplicaates(word);
+		for (String key : result.keySet()) {
+			System.out.println(key + " : " + result.get(key));
+		}
+
+	}
+
+	public static Map<String, Integer> findDuplicates(String word) {
+
+		char[] keyword = word.toCharArray();
+		Arrays.sort(keyword);
+
+		Map<String, Integer> result = new HashMap<>();
+		char previous = keyword[0];
+
+		for (int i = 1; i < keyword.length; i++) {
+			char ch = keyword[i];
+			if (previous == ch) {
+				if (result.get("" + ch) != null)
+					result.put("" + ch, result.get("" + ch) + 1);
+				else
+					result.put("" + ch, 2);
+
+			}
+			previous = ch;
+		}
+		return result;
+	}
+
+	public static Map<String, Integer> findduplicates(String word) {
+
+		Map<String, Integer> result = new HashMap<>();
+
+		for (int i = 0; i < word.length(); i++) {
+			boolean found = false;
+			for (int j = i + 1; j < word.length(); j++) {
+				if (word.charAt(i) == word.charAt(j)) {
+					found = true;
+					break;
+				}
+			}
+			if (found)
+				if (result.get("" + word.charAt(i)) != null)
+					result.put("" + word.charAt(i), result.get("" + word.charAt(i)) + 1);
+				else
+					result.put("" + word.charAt(i), 2);
+
+		}
+		return result;
+	}
+
+	public static Map<String, Integer> findduplicaates(String word) {
+
+		int[] letters = new int[26];
+		Map<String, Integer> result = new HashMap<>();
+		for (char f : word.toCharArray()) {
+			letters[f - 'a']++;
+			if (letters[f - 'a'] > 1) {
+				if (result.get("" + f) != null)
+					result.put("" + f, result.get("" + f) + 1);
+				else
+					result.put("" + f, 2);
+			}
+		}
+
+		return result;
+	}
+}

src/main/java/javarevisited/top/fifty/java/programs/from/coding/interviews/PrintingPatterns.java

@@ -0,0 +1,23 @@
+package javarevisited.top.fifty.java.programs.from.coding.interviews;
+
+/**
+ * @author medany
+ */
+
+/*
+ * How to Print a Pattern in Java. ex. Pyramid Pattern
+ */
+public class PrintingPatterns {
+	public static void main(String[] args) {
+		drawPyrmidPattern(5, "* ");
+	}
+
+	public static void drawPyrmidPattern(int n, String block) {
+		for (int i = 0; i < n; i++) {
+			for (int j = 0; j <= i; j++) {
+				System.out.print(block);
+			}
+			System.out.println();
+		}
+	}
+}

src/main/java/javarevisited/top/fifty/java/programs/from/coding/interviews/RemoveArrayDuplicates.java

@@ -0,0 +1,42 @@
+package javarevisited.top.fifty.java.programs.from.coding.interviews;
+
+import java.util.Arrays;
+
+/**
+ * @author medany
+ */
+
+/*
+ * Write a program to remove duplicates from an array in Java without using the
+ * Java Collection API. The array can be an array of String, Integer or
+ * Character, your solution should be independent of the type of array. If you
+ * want to practice more array based questions then see this list of top 30
+ * array interview questions from Java interviews.
+ */
+public class RemoveArrayDuplicates {
+
+	public static void main(String[] args) {
+		Object[] arr = { 'a', 'a', 'd', 'c', 'b', 'c', 'e', 'd' };
+
+		System.out.println("Array with doublicates: " + Arrays.toString(arr));
+		System.out.println("Array without doublicates: " + Arrays.toString(removeDuplicates(arr)));
+	}
+
+	public static Object[] removeDuplicates(Object[] arr) {
+
+		Arrays.sort(arr);
+
+		Object[] result = new Object[arr.length];
+		Object previous = arr[0];
+		result[0] = previous;
+
+		for (int i = 1; i < arr.length; i++) {
+			Object ch = arr[i];
+			if (previous != ch) {
+				result[i] = ch;
+			}
+			previous = ch;
+		}
+		return result;
+	}
+}