Reverse A String using Recursion

public class ReverseAString {

       public static void main(String[] args) {

             ReverseAString ras = new ReverseAString();

             System.out.println(ras.reverseString("checkit"));

       }

       public String reverseString(String input) {

             return input.isEmpty() ? input : reverseString(input.substring(1)) + input.charAt(0);

       }

}

Wonder-Land Number

This a way to generate the wonderland number.

It has six digits.

If you multiply it by 2,3,4,5, or 6, the resulting number has all the same digits in at as the original number.

The only difference is the position that they are in.

Source: https://github.com/gigasquid/wonderland-clojure-katas

import java.util.ArrayList;

import java.util.List;

public class WonderLandNumber {

     public static void main(String[] args) {         

          for (int i = 100000; i < 1000000; i++) {

               if (isWonderLandNumber(i)) {

                    System.out.println(i);

                    break;

               }

          }

     }

     public static boolean isWonderLandNumber(int number) {

          return containsAll(number, 2 * number) && containsAll(number, 3 * number) && containsAll(number, 4 * number)

                    && containsAll(number, 5 * number) && containsAll(number, 6 * number);

     }

     public static boolean containsAll(int number, int multiple) {

          String one = String.valueOf(number);

          String two = String.valueOf(multiple);

          return one.length() == two.length() && getDigits(one).containsAll(getDigits(two));

     }

     public static List getDigits(String number) {

          List digits = new ArrayList<>();

          for (String digit : number.split("")) {

               digits.add(digit);

          }

          return digits;

     }

}

Output:

142857

Balanced String

A program to determine if the parentheses (), the brackets [], and the braces {}, in a string are balanced.

For example:

{{)(}} is not balanced because ) comes before (

({)} is not balanced because) is not balanced between {} and similarly the { is not balanced between ()

[({})] is balanced

{}([]) is balanced

{()}[[{}]] is balanced

import java.util.Stack;

public class BalancedParenthesis {

     public static void main(String[] args) {

          BalancedParenthesis bp = new BalancedParenthesis();

          System.out.println(bp.isBalanced("{{)(}}"));

          System.out.println(bp.isBalanced("({)}"));

          System.out.println(bp.isBalanced("[({})]"));

          System.out.println(bp.isBalanced("{}([])"));

          System.out.println(bp.isBalanced("{()}[[{}]]"));

     }

     public boolean isBalanced(String string) {

          Stack stack = new Stack<>();

          for (String token : string.split("")) {

               if ("(".equals(token) || "[".equals(token) || "{".equals(token)) {

                    stack.push(token);

               } else if (")".equals(token) || "]".equals(token) || "}".equals(token)) {

                    if (stack.isEmpty()) {

                         return false;

                    }

                    String pop = stack.pop();

                    if ((")".equals(token) && !"(".equals(pop))

                              || ("]".equals(token) && !"[".equals(pop))

                              || ("}".equals(token) && !"{".equals(pop))) {

                         return false;

                    }

               }

          }

          return true;

     }

}

Output:

false

false

true

true

true

MyStack (LIFO) : Stack implementation with Array and Generics

MyStack.java:

package com.lnn.ds.stack;

import java.util.Objects;

public class MyStack<T> {

      private T[] data;

      private int size = -1;

      private int capacity;

      @SuppressWarnings("unchecked")

      public MyStack(int capacity) {

            this.capacity = capacity;

            this.data = (T[]) new Object[capacity];

      }

      public boolean isFull() {

            return (size + 1 == capacity);

      }

      public boolean isEmpty() {

            return (size == -1);

      }

      public T pop() {

            if (!isEmpty()) {

                  return data[size--];

            }

            return null;

      }

      public boolean push(T element) {

            if (!isFull()) {

                  data[++size] = element;

                  return true;

            }

            return false;

      }

      public boolean search(T element) {

            for (int i = 0; i <= size; i++) {

                  if (Objects.equals(data[i], element)) {

                        return true;

                  }

            }

            return false;

      }

      public String toString() {

            StringBuilder builder = new StringBuilder();

            builder.append("[");

            for (int i = 0; i <= size; i++) {

                  builder.append(data[i]);

                  if (i < size) {

                        builder.append(", ");

                  }

            }

            builder.append("]");

            return builder.toString();

      }

}

MyStackTest.java:

package com.lnn.ds.stack;

public class MyStackTest {

      public static void main(String[] args) {

            MyStack<Integer> stack = new MyStack<Integer>(10);

            for (int i = 0; i < 10; i++) {

                  stack.push(i);

            }

            for (int i = 0; i < 10; i++) {

                  System.out.println(stack);

                  stack.pop();

            }

      }

}