Java

<code>package Function;
/**
 * This interface defines a function
 * @author
 */

public interface Function {
/**
 * The smallest difference between two values
 * which is used to check and see if the difference
 * equals zero
 */
    public static double EPSILON = 0.000000001;  // nano
/**
 * Returns the range value for this function given
 * the domain value <code>inValue</code>
 * @param inValue
 * @return
 */
    public double getValue( double inValue );

}

package Function;<br />
/**<br />
 * This interface defines a function<br />
 * @ <br />
 */<br />
<br />
public interface Function {<br />
/**<br />
 * The smallest difference between two values<br />
 * which is used to check and see if the difference<br />
 * equals zero<br />
 */<br />
    public static double EPSILON = 0.000000001;  // nano<br />
/**<br />
 * Returns the range value for this function given<br />
 * the domain value <code>inValue</code><br />
 * @param inValue<br />
 * @return<br />
 */<br />
    public double getValue( double inValue );<br />
<br />
}

<code>/*
 *
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

package Function;

/**
 *
 * @author 
 */
public class Main {
    
    /** Creates a new instance of Main */
    public Main() {
    }
    
    /**
     *
     * @param args
     */
    public static void main(String[] args) {
        //three constrctors are called through f, g, andh//
      Function f = new LinearFunction();
      Function g = new LinearFunction(2);
      Function h = new LinearFunction(3, 6);
      
     f.getYIntercept(1.0); 
             
      System.out.println("Y intercept="+f.getSlope());

      System.out.println("Slope="+f.setSlope());

        f.setSlope(2.0);

        

        

      for (int i = 0 ; i<10; i++ ){
          
        System.out.print("f(" +i+ ")="+f.getValue(i)+ "    ");
        System.out.print("g(" +i+ ")="+g.getValue(i)+ "    ");
        System.out.println("h(" +i+ ")="+h.getValue(i)+ "    ");
        
     
      }
      
    
      System.out.println();
    
}
}

import java.io.*;
import java.util.*;

public class NQueensProblemSingleSolution {

  private int n;
  private int[] solutionVector;

  public NQueensProblemSingleSolution(int n) {

      if (n % 6 == 2) {
          for (m=1; m++; m=n/2)          
              // i want to place a queen at (m, 2m) and (n/2 + ,2m - 1)
      }
      if (n % 6 == 0) {
          for (m=1; m++; m=n/2)
              // i want to place a queen at (m, 1 + (2(m-1) + n/2 - 1) % n) and 
              // (n+1-m, n - (2(m-1) + n/2 - 1) % n)
      }
      if (n % 2 != 0) {
          for (m=1; m++; m=n/2)
              // i want to use (1) or (2), whichever one is appropriate, on n-1 and extend with a queen
              // at (n,n)
      }                        
  }
    @Override
  public String toString() {
        return "This is the solution: "+solutionVector; 
  //this toString is not right; i'll worry about this once i figure out the first part
    }


  public static void main(String[] args) {

    if (args.length != 1) {
      System.out.println("usage: java NQueensProblemSingleSolution <outputfile>");
      System.exit(0);
    }
    try {
      PrintWriter outFile = new PrintWriter(new FileWriter(args[0]));
      for (int i = 4; i <= 16; i++) {
        NQueensProblemSingleSolution result = new NQueensProblemSingleSolution(i);
        outFile.println(i + ": " + result);
      }     
      outFile.close();
    }
    catch(FileNotFoundException fnfe) {
      System.out.println("Open error: " + fnfe);
    }
    catch(IOException ioe) {
      System.out.println("I/O error: " + ioe);
    }
  }
}

public NQueensProblemSingleSolution(int n) {
      int rows;
      int columns;
      Array[][] one = new Array[][];
      if (n % 6 == 2) {
          for (m=1; m++; m=n/2)
              board[n][n]= ;
}

import java.util.Scanner;

public class bioPalindrome {
	
	public static void main(String[] args) {
		
		Scanner console = new Scanner(System.in);
		
		System.out.println("Please enter the DNA string to be examined."); // prompting user for the dna string.
		String dnaString = console.nextLine(); // storing the input in to the variable dnaString
		dnaString = dnaString.toUpperCase(); // converting the characters to upper case.
		System.out.println(dnaString + " " + dnaString.length()); // to check that the variables are being properly initialized...remove later.
		

		boolean isPalindrome = checkPalindrome(dnaString, 0, dnaString.length()); // calling the method, checkPalindrome, where 0 is the position of the first character of the string and stringLength is the  last character of the string.
		
		if(isPalindrome == true)
			System.out.println("The DNA string entered is a biopalindrome.");
		else 
			System.out.println("The DNA string entered is not a biopalindrome.");
		
	}

	//-----------------------------------------------------------------------------------------------------------------------------------
	// User defined recursive method to check that the input is a biopalindrome.
	
	public static boolean checkPalindrome(String stringIn, int start, int end) {
		/*System.out.println(start + " " + end); // to verify that the values are being passed properly.
		stringIn = stringIn.substring(start, end);
		System.out.println(stringIn);*/
		if(stringIn.length() - 1 == 0 && start == end) // base case
			return true;
		else if(stringIn.charAt(start) == 'A' && stringIn.charAt(end - 1) == 'T' || stringIn.charAt(start) == 'T' && stringIn.charAt(end - 1) == 'A' || stringIn.charAt(start) == 'C' && stringIn.charAt(end - 1) == 'G' || stringIn.charAt(start) == 'G' && stringIn.charAt(end - 1) == 'C') { // general case
			start++;
			end--;
			return checkPalindrome(stringIn, start, end);
		} else
			return false;
	}
}

import java.io.*;
  import java.util.*;

   class MergeSortArray
  {
      public static void main(String[] args)
     {

        int choice = 0;

        int[]values;
        int counter = 0;
        int backCounter = 10;

        values = new int[10];

        while(counter != 10)
        {
           Scanner scanner = new Scanner (System.in);
           System.out.println("Enter " + backCounter + " more integers:");
           choice = scanner.nextInt();
           values[counter] = choice;
           counter++;
           backCounter--;
        }

        System.out.println(counter);


            mergeSort (values, 0, values.length-1);
            merge (values, first, mid, last);



        int i=0;
        while(i<10)
        {
           System.out.println(values[i]);
           i++;
        }

     }
         // RIGHT HERE....what do they want from me?
            public static void mergeSort (Comparable[] data, int min, int max)
     {
        if (min < max)
        {
           int mid = (min + max) / 2;
           mergeSort(data, min, mid);
           mergeSort(data, mid+1, max);
           merge (data, min, mid, max);

        }
     }

  //---------------------------------------------------------------------------------------
  //  Sorts the specified array of objects using the merge sort algorithm.
  //---------------------------------------------------------------------------------------

      public static void merge (Comparable[] data, int first, int mid, int last)
     {
        Comparable[] temp = new Comparable[data.length];

        int first1 = first, last1 = mid; //endpoints of first subarray
        int first2 = mid + 1, last2 = last; //endpoints of second subarray
        int index = first1; // next index open in temp array

     // Copy smaller item from each subarry into temp until one of the subarrays is exhausted

        while (first1 <= last1 && first2 <= last2)
        {
           if (data[first1].compareTo(data[first2]) < 0)
           {
              temp[index] = data[first1];
              first1++;
           }
           else
           {
              temp[index] = data[first2];
              first2++;
           }
           index++;
        }
     //  Copy remaining elements from first subarray, if any
        while (first1 <= last1)
        {
           temp[index] = data[first1];
           first1++;
           index++;
        }

     //  Copy remaining elements from second subarray, if any
        while (first2 <= last2)
        {
           temp[index] = data[first2];
           first2++;
           index++;
        }

     // Copy merged data into original array
        for (index = first; index <= last; index++)
           data[index] = temp[index];
     }
  }