java编程算法题

(1)

该公司笔试题就1个，要求在10分钟内作完。

    题目如下：用1、2、2、3、4、5这六个数字，用java写一个main函数，打印出所有不同的排列，如：512234、412345等，要求："4"不能在第三位，"3"与"5"不能相连。

package mu.orderstr;
import java.util.ArrayList;
import java.util.List;
public class GetAll {
List list= new ArrayList();
public GetAll(){
    list.add( "22");
}
public void AllOrder(String str){
    List listlin= new ArrayList();
     for( int i=0;i<list.size();i++){
     String nstr=(String )list.get(i);
     nstr=str+nstr;
     String cmpstr=nstr;
     listlin.add(nstr);
     nstr=ChangeStr(nstr);
     while(!cmpstr.equals(nstr)){
        listlin.add(nstr);
        nstr=ChangeStr(nstr);
     }
    }
     list.clear();
    list.addAll(listlin);
}
    
public void OutAll(){
     //过虑
     for( int j=0;j<list.size();j++){
     String outstr=(String)list.get(j);
     if((outstr.indexOf("3")+1==outstr.indexOf("5")) || (outstr.indexOf("3")-1==outstr.indexOf("5"))||(outstr.indexOf("4")==2))
                                        continue;
                         System.out.println( "-----------"+outstr);
        
    }
}
public String ChangeStr(String str){
     char arr[]=str.toCharArray();
    char first=arr[0];
    str=str.substring(1,str.length())+first;
     return str;
}
public static void main(String args[]){
    GetAll getall= new GetAll();
    getall.AllOrder( "1");
    getall.AllOrder( "3");
    getall.AllOrder( "4");
    getall.AllOrder( "5");
    getall.OutAll();
}
}

 

(2)

写一个方法，用 一个for循环打印九九乘法表

/**
         * 打印九九乘法口诀表
         */
         public void nineNineMulitTable(){
                 for ( int i = 1,j = 1; j <= 9; i++) {    
                            System.out.print(i+ "*"+j+ "="+i*j+ " ");    
                             if(i==j){    
                                    i=0;    
                                    j++;    
                                    System.out.println();    
                            }    
                    }    
        }

若可以用两个for,则也可以如下：

public void show()
        {
             for( int a=1;a<=9;a++)
            {
                 for( int b=1;b<=a;b++)
                 {
                         System.out.print(b+ "*"+a+ "="+(b*a)+ "    ");
                         if(a==b)
                         {
                                 System.out.println("");    
                         }
                 }    
            }    
        }

也可变相用while和a++，哈哈：

         public void show()
        {
             for( int a=1;a<=9;a++)
            {
                     int b=1;
                     while(b<=a)
                    {
                            System.out.print(b+ "*"+a+ "="+(b*a)+ "    ");
                            b++;
                    }
                    System.out.println("");    
            }    
        }

输出如下：

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

 

(3)

写一个方法，能够判断任意一个整数是否素数 :

素数:即只能被自己和1整除的数.如2,3等.1不是素数.

Math.sqrt(num):返回数的正平方根.

    
         /**    
        * 判断任意一个整数是否素数    
        * @param num    
        * @return boolean    
        */    
         public boolean isPrimeNumber( int num)    
        {    
             for ( int i = 2; i <= Math.sqrt(num); i++) {    
                     if(num%i==0)    
                    {    
                             return false;    
                    }    
            }    
             return true;    
        }

 

输出1-100的素数（math.sqrt()的方法:

import java.lang.Math;
public class SuShu{

public static void main(String[] args){
  boolean flag=false;
  for(int i=3;i<=100;i+=2)
  {
   flag=false;
   for(int j=2;j<=Math.sqrt(i);j++)
   {
    if(i%j==0) flag=true;   
   }
   if (!flag)
   System.out.print(i+" ");
  }

}

}

}

 

创建一个有5个值的数组，求最大值，最小值:

public class ShuZu{
public static void main(String[] args){
int temp=0;
int[] a={9,11,8,5,6};
for( int i=0;i<5;i++){ //先对数组排序

   /*将第一位的数据与其它各数进行比较,把小的放到第一位.
    * 这样,第一次循环后,第一位数,将是最小的;
    * 然后进行第二次循环,结果把第二小的数放于第二位.
    **/
for( int j=4;j>i;j--){
if(a[i]>a[j]){
temp=a[i];a[i]=a[j];a[j]=temp;
}
}

}

System.out.println( "max="+a[4]+ " min="+a[0]);
}

}

或用：

  int temp=0;
  int[] a={9,11,8,5,6};
  for(int i=0;i<5;i++){//先对数组排序
   /*将第一位的数据与其它各数进行比较,把小的放到第一位.
    * 这样,第一次循环后,第一位数,将是最小的;
    * 然后进行第二次循环,结果把第二小的数放于第二位.
    **/
   for(int j=i+1;j<5;j++){
//    if(a[i]>a[j]){ //从小到大排序
    if(a[i]<a[j]){ //从大到小排序
     temp=a[i];a[i]=a[j];a[j]=temp;
    }
   }
  }

 

 

(4)

写一个方法，输入任意一个整数，返回它的阶乘

**    
            *获得任意一个整数的阶乘    
            *@param n    
            *@returnn!    
            */    
             public int factorial( int num)    
            {    
                 //递归    
                 if(num == 1)    
                {    
                         return 1;    
                }    
                 return num*factorial(num-1);
            }

 

(5)

写一个方法，用二分查找法判断任意整数在任意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1

/**    
             *二分查找特定整数在整型数组中的位置(递归)    
             *@param dataset    
             *@param data    
             *@param beginIndex    
             *@param endIndex    
             *@return index    
             */    
             public int binarySearch( int[] dataset, int data, int beginIndex, int endIndex){    
                 int midIndex = (beginIndex+endIndex)/2;    
                 //如果查找的数要比开始索引的数据要小或者是比结束索引的书要大，或者开始查找的索引值大于结束的索引值返回-1没有查到
                 if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
                         return -1;
                 }
                 if(data <dataset[midIndex]){    
                         return binarySearch(dataset,data,beginIndex,midIndex-1);    
                 } else if(data>dataset[midIndex])    
                 {    
                         return binarySearch(dataset,data,midIndex+1,endIndex);    
                 } else {    
                         return midIndex;    
                 }    
             }    
                
             /**    
                *二分查找特定整数在整型数组中的位置(非递归)    
                *@param dataset    
                *@param data    
                *@return index    
                */    
                 public int binarySearch( int[] dataset , int data)    
                {    
                     int beginIndex = 0;    
                     int endIndex = dataset.length - 1;    
                     int midIndex = -1;    
                     if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
                             return -1;    
                    }
                     while(beginIndex <= endIndex) {    
                            midIndex = (beginIndex+endIndex)/2;    
                             if(data <dataset[midIndex]) {    
                                 endIndex = midIndex-1;    
                            } else if(data>dataset[midIndex]) {    
                                beginIndex = midIndex+1;    
                            } else {    
                                 return midIndex;    
                            }    
                    }    
                     return -1;    
                }

 

1．现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset
import java.util.*;
public class bycomma{
 public static String[] splitStringByComma(String source){
   if(source==null||source.trim().equals(""))
    return null;
   StringTokenizer commaToker = new StringTokenizer(source,",");
   String[] result = new String[commaToker.countTokens()];
   int i=0;
   while(commaToker.hasMoreTokens()){
    result[i] = commaToker.nextToken();
    i++;
   }
   return result;
 }
 public static void main(String args[]){
 String[] s = splitStringByComma("5,8,7,4,3,9,1");
 int[] ii = new int[s.length];
 for(int i = 0;i<s.length;i++){
 ii[i] =Integer.parseInt(s[i]);
 }
    Arrays.sort(ii);
    //asc
    for(int i=0;i<s.length;i++){
    System.out.println(ii[i]);
    }
    //desc
    for(int i=(s.length-1);i>=0;i--){
    System.out.println(ii[i]);
    }
 }
}

-------------------------------------------------------------------------------
2.产生9个大于1小于10的随机数，且放于数组中：
//Math.random()产生的随机数是大于0小于1，如：0.25994233953477175
  int[] ii = new int[9]; 
  for (int i = 0; i < ii.length; i++) { 
   ii[i] = (int)( 10*Math.random()); 
   System.out.println(ii[i]); 
  }  

-------------------------------------------------------------------------------
3.将一个形如：Stting="asdsdfsdfasdasda"这样的字符串，计算出这个字符串的同种字符的个数，以及有多少种不同的字符？
String s="asdsdfsdfasdasda";
  //对字符串中的各字符的处理方式一：
//  char [] b=s.toCharArray();
//  for(int i=0;i<b.length;i++)
//  {
//   System.out.println("b:"+b[i]);
//  }
  
    int differentCount = 0;
    //泛化只能用Character，不能用char

   //用hashmap,来存放各种不同字符及其个数，也用于计算，累加字符的个数
    Map<Character,Integer> map = new HashMap<Character,Integer>();
    //对字符串中的各字符的处理方式二：
    for(int i=0;i<s.length();i++){
     Character c = new Character(s.charAt(i));
     if(map.containsKey(c)){
   //hashtable,hashmap, 如下：
//      Hashtable ht=new Hashtable();
//      ht.put("a",1);
//      ht.put("a",2);
//      System.out.println("ht:"+ht); //输出结果是ht:{a=2}
      map.put(c, map.get(c).intValue()+1);
     }else{
      map.put(c, new Integer(1));
     }
    }

    Iterator<Character> it = map.keySet().iterator();
    while(it.hasNext()){
     Character tmpc = it.next();
     differentCount++;
     System.out.println(tmpc+"="+map.get(tmpc));
    }
    System.out.println("differentCount="+differentCount);

-------------------------------------------------------------------------------
4.有一个String s="SDsBEaA"
要求产生这样的结果:s="AaBDESs"
public class MySort {

        public static void main(String[] args) {
                List<Character> result = new ArrayList<Character>();
                String s = "SDsBEAa";

                char[] strArray = s.toCharArray();
                //排序后是：strArray = ABDESas
                Arrays.sort(strArray);
                for (int i = 97; i < 122; i++) {
                        char tempLowCase = (char) i;
                        char tempUpperCase = (char) (i - 32);
                        for (int j = 0; j < strArray.length; j++) {
                                if (Character.isUpperCase(strArray[j])) {
                                        if (tempUpperCase == strArray[j]) {
                                                result.add(tempUpperCase);
                                        }
                                }
                                if (tempLowCase == strArray[j]) {
                                        result.add(strArray[j]);
                                }
                        }
                }
                System.out.println(result);
        }
}
-------------------------------------------------------------------

6.Java编程,打印昨天的当前时刻
Calendar cal = Calendar.getInstance();
cal.add(Calendar.DATE, -1);  

 

-------------------------------------------------------------------

7. JAVA多线程编程。用JAVA写一个多线程程序，如写四个线程，二个加1，二个对一个变量减一，输出。(须考虑同步)

//将要加减的变量设置为static;将加减操作及相应的变量定义在另一类中.在线程中进行调用即可.

//只要是多线程,就要考虑其同步.即要用synchrnized
class t
{
    private static int x=10;

    public synchronized void add()
    {
        x++;
        System.out.println("x="+x);
    }  
    public synchronized void jian()
    {
        x--;
        System.out.println("x="+x);
    }
}

class t1 extends Thread
{
 public void run()
 {
  t t1=new t();
  t1.add();
 }      
}
class t2 extends Thread
{
 public void run()
 {
  t t1=new t();
  t1.jian();
 }
}

public class ThreadTest
{
    public static void main(String [] args)
    {
        t1 t11=new t1();
        t1 t12=new t1();
        t2 t21=new t2();
        t2 t22=new t2();
        t11.start();
        t12.start();
        t21.start();
        t22.start();
    }
}

-------------------------------------------------------------------

8.金额转换，阿拉伯数字的金额转换成中国传统的形式如：
public class NumToChinese {

  public static String NumberToChinese(String input){
   String s1="零壹贰叁肆伍陆柒捌玖";      //设置对应关系。
   String s4="分角整元拾佰仟万拾佰仟亿拾佰仟";
   String temp="";
   String result="";
   if (input==null) return "输入的字串不是数字串只能包括以下字符（'0'~'9','.'),

输入字串最大只能精确到仟亿，小数点只能两位！";
   temp=input.trim();
   float f;
   try{
    f=Float.parseFloat(temp);
   }catch(Exception e){
    return "输入的字串不是数字串只能包括以下字符（'0'~'9','.'),输入字串最

大只能精确到仟亿，小数点只能两位！";
   }
   int len=0;
   if(temp.indexOf(".")==-1) len=temp.length();
   else len=temp.indexOf(".");
   if(len>s4.length()-3) return("输入字串最大只能精确到仟亿，小数点只能两位！");
   int n1=0;
   String num="";
   String unit="";
   for(int i=0;i<temp.length();i++){
    if(i>len+2){break;}
    if(i==len) {continue;}
    n1=Integer.parseInt(String.valueOf(temp.charAt(i)));
    num=s1.substring(n1,n1+1);
    n1=len-i+2;
    unit=s4.substring(n1,n1+1);
    result=result.concat(num).concat(unit);
   }
   if((len==temp.length())||(len==temp.length()-1)) result=result.concat("整");
   if(len==temp.length()-2) result=result.concat("零分");
   return result;
  }
  
  public static void main(String[] args) {
   NumToChinese i=new NumToChinese();
   System.out.println(i.NumberToChinese("1234.53"));
  }
 }

-------------------------------------------------------------------

9.杨辉三角：
/*杨辉三角最本质的特征是，它的两条斜边都是由数字1组成的，而其余的数则是等于它肩上的两个数之和。*/

int[][] sum = new int[10][10];
sum[0][0] = 1;
  for (int i = 0; i < 10; i++) {

   for (int j = 1; j <= i; j++) {
    sum[i][j] = sum[i - 1][j - 1] + sum[i - 1][j];
    System.out.print(sum[i][j] + "\t");
   }
   System.out.println();
  }
 }

-------------------------------------------------------------------

(10)

烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个

小时十五分钟呢？
1.三根绳子点燃，第1，2根点一头，第3根点两头
2.第3根燃尽的时候熄灭第1根
3.第2根燃尽时，将第一根两头点燃
4.第一根燃尽1小时15分计时结束