// Sample solutions to lab 1b

public class lab1bsolutions
{
    //1
    public static boolean inarray(String s, String[] SA)
    {
	for(String x:SA) if (x.equals(s)) return true;
	return false;
    }

    //2a
    public static int sum(int[] A)
    {
	int ax = 0;  // accumulator
	for(int x:A) ax+=x;
	return ax;
    }

    //2b
    public static String smallest(String[] SA)
    {
	if (SA==null || SA.length==0) return null;
	int si = 0; // assume smallest string is at index 0
	for(int i=1;i<SA.length;i++)
	   if (SA[i].compareTo(SA[si])<0) si = i; // update when smaller found
	return SA[si];
    }

    //3
    public static String reverse(String s)
    {
	String r = "";
	for(int i=0;i<s.length();i++) r = s.charAt(i) + r;
	return r;
	// notice that r string is being used like a stack by "push"
	// chars in front, thus producing a reverse string
    }

    //3b
    public static boolean palindrome(String s)
    {
	int middle = s.length()/2;
	for(int i=0;i<middle;i++)
	    if (s.charAt(i) != s.charAt(s.length()-1-i)) return false;
	return true;
	// alternatively you can just compare the string with its reverse,
	// but this is more efficient.
    }

    // 4 check for duplicates - this requires a nested loop
    public static boolean hasDuplicates(String[] S)
    {
	for(int i=0;i<S.length-1;i++)
	    for(int k=i+1;k<S.length;k++)
		if (S[i].equals(S[k])) return true;
	return false;
    }

    //5
    public static void main(String[] av)
    {
	String[] S = {"ac","az","ab"};
	int[] I = {4,5,3,0};
	System.out.println(inarray("az",S)); // positive test
	System.out.println(inarray("bz",S)); // negative test
	System.out.println(sum(I));
	System.out.println(smallest(S));
	System.out.println(reverse("abcd"));
	System.out.println(palindrome("noon") && palindrome("bob"));
	System.out.println(palindrome("adba")); // negative test
	System.out.println(hasDuplicates(S)); // negative
	String[] T = {"ab","xy","ab","vu"};
	System.out.println(hasDuplicates(T)); // positive

	// testing for part 2:
	team.seasonsim(); // calls static function in team class below
    }//main
}//lab1bsolutions


//// part2

interface Playable
{
   void win();
   void lose();
   // optionally, you may also allow ties.
   void printrecord();
   void play(team x);
   double winningpercentage();
}

class team implements Playable, Comparable<team>
{
    public final String name; // name of team, can't be changed
    protected int wins = 0; 
    protected int losses=0;
    public team(String n) { name=n; } // constructor
    public void win() { wins++; }
    public void lose() { losses++; }
    public void printrecord()
    {
	System.out.println("W-L: "+wins+"-"+losses);
    }
    public double winningpercentage()
    {
	int games = wins+losses; // games played
	if (games<1) return 0;
	return (wins*1.0)/games; // *1.0 converts int to double.
    }
    public void play(team other)  // other instead of x is fine
    {
	double r = Math.random();  // random num between 0 and 1
	if (r<0.5) // win
	    {
		win();  other.lose();
		System.out.println(name+" win, "+other.name+" lose");
	    }
	else //lose
	    {
		lose();  other.win();
		System.out.println(other.name+" win, "+name+" lose");
	    }
    }//play

    // comparable for sorting:
    public int compareTo(team other)
    {
	int wp1 = (int)(winningpercentage()*1000+0.5); // round off percentages
	int wp2 = (int)(other.winningpercentage()*1000+0.5);
	return wp1 - wp2;
    }

    
    ////////
    public static void seasonsim() // for testing, called from main
    {
	String[] fbn = {"Giants","Jets","Rams","Patriots","Falcons","Steelers","Packers","Eagles","Chiefs","Bills","Seahawks","Cowboys","Chargers","Raiders","Dolphins","Saints","49ers"};
	team[] TEAM = new team[fbn.length];
	for(int i =0;i<TEAM.length;i++)
	    TEAM[i] = new team(fbn[i]);  // create teams with names

	// every team plays every other team once:
	for(int i=0;i<TEAM.length-1;i++)
	    for(int k=i+1;k<TEAM.length;k++)
		TEAM[i].play(TEAM[k]);

	// find team with highest winning percentage
	int bi = 0; // index of best team
	for(int k=1;k<TEAM.length;k++)
	    if (TEAM[k].compareTo(TEAM[bi])>0) bi = k;
	System.out.println(TEAM[bi].name+" has the best winning percentage at "+TEAM[bi].winningpercentage());
	// sorting skipped, but can use quicksort code.
	
    }//seasonsim
    
}//team class


/////////  Sample solution to time class:
class time implements Comparable<time>
{

    protected int min; // minutes
    protected int sec; // seconds
    public time(int m, int s) // constructor
    {
	if (sec<0 || min<0) throw new RuntimeException("invalid time");
	sec = s%60; min=m+s/60; 
    }
    public time add(time B)
    {
	int s = sec + B.sec;
	int m = min + B.min + s/60;
	return new time(m,s%60);
    }
    public void tick()
    {
	sec++;
	min += sec/60;
	sec = sec%60;
    }
    public String toString() { return min+" min "+sec+" sec"; }
    public int compareTo(time B)
    {
	// convert both times to seconds
	return (min*60+sec) - (B.min*60+B.sec);
    }

    public static void test()
    {
	time t1 = new time(2,40); // 2 minutes and 40 seconds
	time t2 = new time(1,19); // 1 minute and 19 seconds
	time t3 = t1.add(t2);     // add t1 and t2 times non-destructively
        System.out.println(t3);   // should print "3 min 59 sec"
	t3.tick();  // destructively advance t3 by one second
	System.out.println(t3); // should now print "4 min 0 sec"
        System.out.println(t1.add(new time(1,30))); // prints "4 min 10 sec"
	System.out.println(t1.compareTo(t2)); // should print a positive int.
    } //test

    // you need to complete the rest of the class so that test() will work
}//time class