anoopelias

package jperftest;

import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Callable;

anoopelias

10
14
9 3
2 5
6 5
9 8
0 3
4 7
2 1
0 6

anoopelias

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * Diameter and center of a tree.
 * 
 * Given a connected graph with no cycles,
 * 
 * Diameter: design a linear-time algorithm to find the longest simple path in

anoopelias

There are two forms of recursion,

• Tail Recursion : The return value is calculated as a combination of the value of current subroutine and the return value of the next call. Example,

   int factorial(int a) {
       if(a==0)
           return 1;
       else
           return a * factorial( a-1 );
  

}

anoopelias

public class AppleStock {
 
    public static void main(String[] args) {
        int[] stockPricesYesterday = { 500, 501, 503, 495, 503 };
 
        int buy = -1;
        int sell = -1;
        int lowest = -1;
 
        for (int i = 0; i < stockPricesYesterday.length; i++) {

anoopelias

Assume you have a couple of classes,

case class Person(name: String, age: Int)
case class Employee(person: Person, salary: Double)

Lets say for some reason,

• You don't want to change this source, but
• You should be able to add features save(person) and save(employee), and
• You need clearly separate implementations for both the types,

anoopelias

Typically, you can't use a 'new' operator on a generic type. This is because of type erasure.

scala> def create[T] = new T
<console>:7: error: class type required but T found
   def create[T] = new T
                       ^

Scala gives a way of getting around this problem, with the Manifest class.

scala> def create[T](implicit m:Manifest[T]) = m.erasure.newInstance

anoopelias

scala> case class Name(name:String)
defined class Name

scala> val a = Name("Anoop")
a: Name = Name(Anoop)

scala> val Name(n) = a
n: String = Anoop

scala>

anoopelias

package concept

object ImpicitConversion {

  class Val {
    def value = 10
  }
  
  /* Implicit Conversion begins */

anoopelias

package concept

object Impicit {
  implicit val i : Int = 1                        //> i  : Int = 1
  
  def add(a:Int)(implicit b:Int) = a + b          //> add: (a: Int)(implicit b: Int)Int
  
  add(10)(15)                                     //> res0: Int = 25
  add(10)                                         //> res1: Int = 11
}