import java.io.*;
import java.lang.*;
import java.util.*;
class Main {
public static void get(int[] array, int index){
int result = array[index];
System.out.println("Value of index " + index + " is " + result);
}
public static int[] create_array(int size){
int[] new_array;
new_array = new int[size];
System.out.println("The array it's crated, size: " + new_array.length);
return new_array;
}
public static void fill_array(int[] array, int index, int value){
array[index] = value;
}
public static void reverse_string(String value){
System.out.println("Origianl word: " + value);
String ls_word = "";
char ch;
for (int i=0; i<value.length(); i++){
ch= value.charAt(i); //extracts each character
ls_word= ch+ls_word; //adds each character in front of the existing string
}
System.out.println("Reversed word: "+ ls_word);
}
public static int[] MergeSortedArrays(int[] FirstArray, int[] SecondArray){
int MergedArray[];
MergedArray = new int [(FirstArray.length) + (SecondArray.length)];
int i=0, j=0, k=0;
while (i < FirstArray.length && j < SecondArray.length)
{
if (FirstArray[i] < SecondArray[j])
{
MergedArray[k] = FirstArray[i];
i++;
k++;
}else{
MergedArray[k] = SecondArray[j];
j++;
k++;
}
}
while (i < FirstArray.length)
{
MergedArray[k] = FirstArray[i];
i++;
k++;
}
while (j < SecondArray.length)
{
MergedArray[k] = SecondArray[j];
j++;
k++;
}
//funcion predefinida para juntar 2 arrays
//System.arraycopy(FirstArray, 0, MergedArray, 0, FirstArray.length);
//System.arraycopy(SecondArray, 0, MergedArray, FirstArray.length, SecondArray.length);
return MergedArray;
}
public static boolean undefined_array(int[] value){
for(int i=0; i < value.length; i++){
for(int j=i+1; j < value.length; j++){
if(value[i] == value[j]){
System.out.println(value[i]);
return true;
}
}
}
//System.out.println("Undefined");
return false;
}
public static void insertLinkedList(LinkedList<Integer> list, int index, int value){
list.add(index,value);
}
public static void removeLinkedList(LinkedList<Integer> list){
list.remove();
}
static void stack_push(Stack<Integer> stack){
for(int i=0; i<5; i++){
stack.push(i);
}
}
static void stack_pop(Stack<Integer> stack){
for(int i=0; i<5; i++){
int y = (Integer)stack.pop();
System.out.println(y);
}
}
static void stack_peek(Stack<Integer> stack){
int element = (int)stack.peek();
System.out.println("Element on stack top is: "+ element);
}
static void stack_search(Stack<Integer> stack, int element){
int pos = (int)stack.search(element);
if(pos == -1){
System.out.println("Element " + element + " not found");
}else{
System.out.println("Element: " + element + " is found at position " + pos);
}
}
static int findFactorialIterative(int number){
int bandera = number - 1;
int value = number;
int result = 1;
for(int i = 1; i < number; i++){
if (i == 1){
result = value * bandera;
}else{
result = result * bandera;
}
bandera = bandera - 1;
}
return result;
}
static int findFactorialRecursive(int number){
if(number == 2){
return 2;
}
return number * findFactorialRecursive(number - 1);
}
static int fibonacciRecursive(int number){
if(number < 2){
return number;
}
return fibonacciRecursive(number - 1) + fibonacciRecursive(number - 2);
}
class Node {
int key;
Node left, right;
public Node(int item)
{
key = item;
left = right = null;
}
}
// Root of BST
Node root;
// Constructor
void BinarySearchTree() { root = null; }
void BinarySearchTree(int value) {
root = new Node(value);
//return root;
}
// This method mainly calls insertRec()
void insert(int key) { root = insertRec(root, key); }
Node insertRec(Node root, int key)
{
/* If the tree is empty,
return a new node */
if (root == null) {
root = new Node(key);
return root;
}
/* Otherwise, recur down the tree */
else if (key < root.key)
root.left = insertRec(root.left, key);
else if (key > root.key)
root.right = insertRec(root.right, key);
/* return the (unchanged) node pointer */
return root;
}
void inorder() { inorderRec(root); }
// A utility function to
// do inorder traversal of BST
void inorderRec(Node root)
{
if (root != null) {
inorderRec(root.left);
System.out.println(root.key);
inorderRec(root.right);
}
}
public static void main(String[] args) {
System.out.println("Hello World! ----> Arrays");
int[] main_array;
int[] second_array;
int[] la_MergedArray;
//////////////////////////////////////
int[] la_excersiseArray = new int[10];
la_excersiseArray[0]=2;
la_excersiseArray[1]=5;
la_excersiseArray[2]=1;
la_excersiseArray[3]=2;
la_excersiseArray[4]=3;
la_excersiseArray[5]=5;
la_excersiseArray[6]=1;
la_excersiseArray[7]=2;
la_excersiseArray[8]=4;
la_excersiseArray[9]=5;
/////////////////////////////////////////////
main_array = create_array(10);
second_array = create_array(10);
int li_size_array = main_array.length;
int li_sec_size_array = second_array.length;
for(int i = 0; i < li_size_array; i++){
int x = i+i+1;
fill_array(main_array,i,x+1);
}
for(int i = 0; i < li_sec_size_array; i++){
int x = i+i+1;
fill_array(second_array,i,x);
}
System.out.println("Main array " + Arrays.toString(main_array));
System.out.println("Second array " + Arrays.toString(second_array));
get(main_array,6);
reverse_string("Oscar Medina");
la_MergedArray = MergeSortedArrays(main_array, second_array);
System.out.println("Second array " + Arrays.toString(la_MergedArray));
System.out.println("-----------------------------------------------------------");
System.out.println("Hello World! ----> Hash Tables");
Hashtable<Integer, String> ht1 = new Hashtable<>();
Hashtable<Integer, String> ht2 = new Hashtable<Integer,String>();
ht1.put(1,"one");
ht1.put(2,"two");
ht1.put(3,"three");
ht1.put(4,"four");
ht2.put(5,"five");
ht2.put(6,"six");
ht2.put(7,"seven");
ht2.put(8,"eigth");
System.out.println("HashTable1: " + ht1);
System.out.println("HashTable2: " + ht2);
Enumeration enuHt1 = ht1.keys();
Enumeration enuHt2 = ht2.keys();
System.out.println("Keys for ht1");
while (enuHt1.hasMoreElements()) {
// Displaying the Enumeration
System.out.println(enuHt1.nextElement());
}
System.out.println("Keys for ht2");
while (enuHt2.hasMoreElements()) {
// Displaying the Enumeration
System.out.println(enuHt2.nextElement());
}
System.out.println("Excercise undefined");
boolean lb_undefined = undefined_array(la_excersiseArray);
System.out.println(lb_undefined);
System.out.println("-----------------------------------------------------------");
System.out.println("Hello World! ----> Linked Lists");
LinkedList<Integer> firstLinkList = new LinkedList<Integer>();
firstLinkList.add(5);
firstLinkList.add(10);
firstLinkList.add(16);
System.out.println(firstLinkList);
firstLinkList.add(1,16);
insertLinkedList(firstLinkList,1,18);
System.out.println(firstLinkList);
firstLinkList.addFirst(9);
System.out.println(firstLinkList);
removeLinkedList(firstLinkList);
//remove method remove the head of the linkedlist
System.out.println(firstLinkList);
//reverse
LinkedList list = new LinkedList();
/*list.head = new Node(85);
list.head.next = new Node(15);
list.head.next.next = new Node(4);
list.head.next.next.next = new Node(20);
System.out.println("Given Linked list");
list.printList(head);
head = list.reverse(head);
System.out.println("");
System.out.println("Reversed linked list ");
list.printList(head);*/
System.out.println("-----------------------------------------------------------");
System.out.println("Hello World! ----> Stacks and Queues");
System.out.println("Stacks");
Stack<Integer> stack = new Stack<Integer>();
stack_push(stack);
stack_pop(stack);
stack_push(stack);
stack_peek(stack);
stack_search(stack, 2);
stack_search(stack, 6);
System.out.println("Queues");
Queue<Integer> q1= new LinkedList<Integer>();
for(int i = 0; i<10; i++){
q1.add(i*10);
}
System.out.println("Elements in Queue: " + q1);
System.out.println("Elements remove: " + q1.remove());
System.out.println("Elements head: " + q1.element());
System.out.println("Poll() remove an return HJead in Queue: " + q1.poll());
System.out.println("Peek in Queue: " + q1.peek());
System.out.println("Final Queue: " + q1);
System.out.println("-----------------------------------------------------------");
System.out.println("Hello World! ----> Algorithms");
int li_factorial = findFactorialIterative(10);
System.out.println("Factorial Iterative es: " + li_factorial);
int li_factorialRec = findFactorialRecursive(10);
System.out.println("Factorial Recursive es: " + li_factorialRec);
int li_fibonacciRec = fibonacciRecursive(10);
System.out.println("Factorial Recursive es: " + li_fibonacciRec);
System.out.println("-----------------------------------------------------------");
System.out.println("Hello World! ----> Binary Tree");
//BinarySearchTree tree = new BinarySearchTree();
/*
tree.insert(50);
tree.insert(30);
tree.insert(20);
tree.insert(40);
tree.insert(70);
tree.insert(60);
tree.insert(80);
// print inorder traversal of the BST
tree.inorder();
*/
}
}
