华为机试练习代码

 长度为n的数组乱序存放着0至n-1. 现在只能进行0与其他数的交换.将数组中的元素按对应位置放置使得a[i]=i

import java.util.*;

public class Main {


  
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
       // while(sc.hasNext()){
            int arr [] ={5,3,4,2,0,1};
            sort(arr);
       // }
        sc.close();
    }

    public static void sort(int[] array) {  
        int len = array.length;  
        if(len <= 1){  
            return;  
        }  
        for(int i = len - 1; i > 0; --i){       //从最后一位开始，将最大的数放到最大位置上，然后依次找次大的放  
            if(array[i] == i) continue;        //已经相等，则不交换,避免不必要的重复交换  
            swap_with_zero(array, array[i]);  //现将0和最后一位交换，以便将第n最大值换到第n大位置上  
            //print(array);  
            int curMax = array[i];  
            for(int j = i; j >= 0; --j){       //找出第n大的数  
                 if(array[j] > curMax){  
                     curMax = array[j];  
                 }  
            }  
            swap_with_zero(array, curMax); //将第n大的数和0互换，从而放到第n大的位置上  
            print(array);  
        }  
    }  
    
    public static void print(int[] arr){  
        for(int i=0;i<arr.length;i++){  
            System.out.print(" " + arr[i] + "   ");  
        }  
        System.out.println();  
        for(int i=0;i<arr.length;i++){  
            System.out.print("[" + i + "]" + "  ");  
        }  
        System.out.println();  
        System.out.println();  
    }  
    
    public static void swap_with_zero(int[] array, int number){  
        int len = array.length;  
        int zIndex = -1;  
        int nIndex = -1;  
        for(int i = 0; i < len; ++i){  
            if(array[i] == 0){  
                zIndex = i;  
            }  
            if(array[i] == number){  
                nIndex = i;  
            }  
        }  
        int temp = array[zIndex];  
        array[zIndex] = array[nIndex];  
        array[nIndex] = temp;  

    }  
}

题目描述

查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。

输入描述:

输入两个字符串

输出描述:

返回重复出现的字符
示例1

输入

abcdefghijklmnop
abcsafjklmnopqrstuvw

输出

jklmnop
PS:之前提交错误 是 因为题目中有个  以最少的字符串为准
import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
        ArrayList<String> list = new ArrayList<String>();
        String str1 = sc.nextLine();
        String str2 = sc.nextLine();
        String content =null;
        String str=null;
        if(str1.length()<str2.length()){
            content = str2;
            str = str1;
        }else{
            content = str1;
            str = str2;
        }
        for(int i=str.length();i>0;i--){
            for(int j = 0;j<str.length()-i+1;j++){
                String substring = str.substring(j, j+(i));
                if(content.contains(substring)){
                    list.add(substring);
                    //System.out.println(substring);
                    break;
                }
            }
            //break;
        }
    
        System.out.println(list.get(0));
    }
  }
}

题目描述

题目描述

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

输入

每个用例包含二个整数M和N。0<=m<=10，1<=n<=10。

样例输入

7 3

样例输出

8

/**

* 计算放苹果方法数目


* 输入值非法时返回-1

* 1 <= m,n <= 10

* @param m 苹果数目

* @param n 盘子数目数

* @return 放置方法总数

*

*/

public static int count(int m, int n)

输入描述:

输入两个int整数

输出描述:

输出结果，int型

示例1

输入

7 3

输出

8
PS:完全不会
import java.util.*;
 
/*  解题分析：
        设f(m,n) 为m个苹果，n个盘子的放法数目，则先对n作讨论，
        当n>m：必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即if(n>m) f(m,n) = f(m,m)　　
        当n<=m：不同的放法可以分成两类：
        1、有至少一个盘子空着，即相当于f(m,n) = f(m,n-1);  
        2、所有盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即f(m,n) = f(m-n,n).
        而总的放苹果的放法数目等于两者的和，即 f(m,n) =f(m,n-1)+f(m-n,n) 
    递归出口条件说明：
        当n=1时，所有苹果都必须放在一个盘子里，所以返回１；
        当没有苹果可放时，定义为１种放法；
        递归的两条路，第一条n会逐渐减少，终会到达出口n==1; 
        第二条m会逐渐减少，因为n>m时，我们会return f(m,m)　所以终会到达出口m==0．
*/



public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
            if(m<1 || n>10){
                System.out.println(-1);
            }else{
                System.out.println(shareCount(m,n));
            }
             
        }
    }
    public static int shareCount(int m, int n){
        if(m<0){
            return 0;
        }
        if(m==1 || n==1){
            return 1;
        }
        return shareCount(m, n-1)+shareCount(m-n,n);
    }
}





题目描述






            1


         1  1  1


      1  2  3  2  1


   1  3  6  7  6  3  1


1  4  10 16 19  16 10  4  1


以上三角形的数阵，第一行只有一个数1，以下每行的每个数，是恰好是它上面的数，左上角数到右上角的数，3个数之和（如果不存在某个数，认为该数就是0）。


求第n行第一个偶数出现的位置。如果没有偶数，则输出-1。例如输入3,则输出2，输入4则输出3。


输入n(n <= 1000000000)


输入描述:


输入一个int整数


输出描述:


输出返回的int值




示例1






输入




4








输出




3














PS:心得：不用太固执去看一个东西，要有发散思维

//完全是个找规律的题目啊
import java.util.Scanner;
 
/**
 * Created by Pan on 2017/8/6.
 */
public class Main{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
 
        while (scanner.hasNext()) {
            int line = scanner.nextInt();
            if (line <= 2) {
                System.out.println(-1);
                return;
            }
            if (line % 2 == 1)
                System.out.println(2);
            else {
                if ((line / 2) % 2 == 1)
                    System.out.println(4);
                else
                    System.out.println(3);
            }
        }
    }
}





题目描述






现有一组砝码，重量互不相等，分别为m1,m2,m3…mn；
每种砝码对应的数量为x1,x2,x3...xn。现在要用这些砝码去称物体的重量，问能称出多少中不同的重量。



注：


称重重量包括0



方法原型：public static int fama(int n, int[] weight, int[] nums)













输入描述:


输入包含多组测试数据。

对于每组测试数据：

第一行：n --- 砝码数(范围[1,10])

第二行：m1 m2 m3 ... mn --- 每个砝码的重量(范围[1,2000])

第三行：x1 x2 x3 .... xn --- 每个砝码的数量(范围[1,6])


输出描述:


利用给定的砝码可以称出的不同的重量数




示例1






输入




2
1 2
2 1









输出




5














import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Scanner;
import java.util.Set;
/**
 * 1.称重
 * @author bee
 * 思路： 以列为准，每一个遍历，然后加上新的值
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            Set<Integer> set = new LinkedHashSet<Integer>();//排序还去重复
            int n = sc.nextInt();
            int [] mg = new int[n];
            int [] num = new int[n];
            for(int i=0;i<n;i++){
                mg[i]=sc.nextInt();
            }
            for(int i=0;i<n;i++){
                num[i]=sc.nextInt();
            }
            for(int i=0;i<=num[0];i++){
                set.add(mg[0]*i);//把第一列加上去
            }
            for(int i=1;i<n;i++){//从第二个发麻开始
                List<Integer>list =new ArrayList<Integer>(set);//这是之前能称重的
                for(int j=1;j<=num[i];j++){//遍历砝码的个数
                    for(int k=0;k<list.size();k++)
                    {
                        set.add(list.get(k)+j*mg[i]);
                    }
                }
            }
            System.out.println(set.size());
            
        }
        sc.close();
        
    }
  
}





题目描述






请编写一个函数（允许增加子函数），计算n x m的棋盘格子（n为横向的格子数，m为竖向的格子数）沿着各自边缘线从左上角走到右下角，总共有多少种走法，要求不能走回头路，即：只能往右和往下走，不能往左和往上走。




输入描述:


输入两个正整数


输出描述:


返回结果




示例1






输入




2
2









输出




6




PS: 这个题完全不会
import java.util.*;
public class Main {
     
    public static int find(int m, int n){
        if(m == 0 || n == 0)
            return 1;
        else
            return find(m - 1, n) + find(m, n - 1); 
    }
     
    public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);
      while(sc.hasNext()){
          int m = sc.nextInt();
          int n = sc.nextInt();
          System.out.println(find(m, n));
      }
      sc.close();
    }     
}




import java.util.*;
public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int n = in.nextInt();
            int m = in.nextInt();
            int[][] nm =new int[n+1][m+1];
            for(int i=0;i<n;i++){
                nm[i][m] = 1;
            }
            for(int i=0;i<m;i++){
                nm[n][i] = 1;
            }
            for(int i=n-1;i>=0;i--){
                for(int j=m-1;j>=0;j--){
                    nm[i][j] = nm[i+1][j]+nm[i][j+1];
                }
            }
            System.out.println(nm[0][0]);
        }
         
    }
}







 















题目描述






有6条配置命令，它们执行的结果分别是：






命   令
执   行




reset
reset what




reset board
board fault




board add
where to add




board delet
no board at all




reboot backplane
impossible




backplane abort
install first




he he
unkown command






  注意：he he不是命令。


为了简化输入，方便用户，以“最短唯一匹配原则”匹配：
1、若只输入一字串，则只匹配一个关键字的命令行。例如输入：r，根据该规则，匹配命令reset，执行结果为：reset what；输入：res，根据该规则，匹配命令reset，执行结果为：reset what； 
2、若只输入一字串，但本条命令有两个关键字，则匹配失败。例如输入：reb，可以找到命令reboot backpalne，但是该命令有两个关键词，所有匹配失败，执行结果为：unkown command 
3、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果仍不唯一，匹配失败。例如输入：r b，找到匹配命令reset board，执行结果为：board fault。


4、若输入两字串，则先匹配第一关键字，如果有匹配但不唯一，继续匹配第二关键字，如果唯一，匹配成功。例如输入：b a，无法确定是命令board add还是backplane abort，匹配失败。
5、若输入两字串，第一关键字匹配成功，则匹配第二关键字，若无匹配，失败。例如输入：bo a，确定是命令board add，匹配成功。
6、若匹配失败，打印“unkown command”













输入描述:


多行字符串，每行字符串一条命令


输出描述:


执行结果，每条命令输出一行




示例1






输入




reset
reset board
board add
board delet
reboot backplane
backplane abort









输出




reset what
board fault
where to add
no board at all
impossible
install first














import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            
           String keys [] = {"reset","reset board", "board add","board delet", "reboot backplane", "backplane abort" };
           String ans[] ={"reset what", "board fault", "where to add","no board at all","impossible","install first","unkown command" };
           String str = sc.nextLine();
           String[] cmds = str.split(" ");
           String result = "unkown command";
           if(cmds.length==1){
               for(int i=0;i<keys.length;i++){
                   if(keys[i].startsWith(str)){
                       String[] split = keys[i].split(" ");
                       if(split.length==1){
                           result =ans[i];
                           break;
                       }else{
                           result =ans[6];
                       }
                   }else{
                       result =ans[6];
                   }
               }
           }else if(cmds.length==2){
               String cmd1 = cmds[0];
               String cmd2 = cmds[1];
               int tt = 0;
               for(int i=0;i<keys.length;i++){
                   int count=0;
                   String[] split = keys[i].split(" ");
                   if(split.length==1){
                     
                   }else{
                       if(split[0].startsWith(cmd1)){
                           count++;
                       }
                       if(split[1].startsWith(cmd2)){
                           count++;
                       }
                   }
                   if(count==2){
                       result = ans[i];
                       tt++;
                   }
               }
               if(tt>1){
                   result = ans[6];
               }
           }
           System.out.println(result);
        }
        sc.close();
    }
    
}





题目描述






MP3 Player因为屏幕较小，显示歌曲列表的时候每屏只能显示几首歌曲，用户要通过上下键才能浏览所有的歌曲。为了简化处理，假设每屏只能显示4首歌曲，光标初始的位置为第1首歌。



现在要实现通过上下键控制光标移动来浏览歌曲列表，控制逻辑如下：


    

  1. 

    歌曲总数<=4的时候，不需要翻页，只是挪动光标位置。
    

    2. 



光标在第一首歌曲上时，按Up键光标挪到最后一首歌曲；光标在最后一首歌曲时，按Down键光标挪到第一首歌曲。




其他情况下用户按Up键，光标挪到上一首歌曲；用户按Down键，光标挪到下一首歌曲。




  2. 歌曲总数大于4的时候（以一共有10首歌为例）：



特殊翻页：屏幕显示的是第一页（即显示第1 – 4首）时，光标在第一首歌曲上，用户按Up键后，屏幕要显示最后一页（即显示第7-10首歌），同时光标放到最后一首歌上。同样的，屏幕显示最后一页时，光标在最后一首歌曲上，用户按Down键，屏幕要显示第一页，光标挪到第一首歌上。




一般翻页：屏幕显示的不是第一页时，光标在当前屏幕显示的第一首歌曲时，用户按Up键后，屏幕从当前歌曲的上一首开始显示，光标也挪到上一首歌曲。光标当前屏幕的最后一首歌时的Down键处理也类似。




其他情况，不用翻页，只是挪动光标就行。





输入描述:


输入说明：
1 输入歌曲数量
2 输入命令 U或者D


输出描述:


输出说明
1 输出当前列表
2 输出当前选中歌曲




示例1






输入




10
UUUU









输出




7 8 9 10
7














PS: 学会了队列的使用，
q.offer()入队；
q.poll();出队
 q.peek()获取栈顶元素
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            Queue<Integer> queue = new LinkedList<Integer>();//队列
            int n = Integer.parseInt(sc.nextLine());
            String cmd = sc.nextLine();
            int cur = 1;
            for(int i=0;i<cmd.length();i++){
                if(n<=4){
                    if(queue.size()==0){
                        for(int j=1;j<=n;j++){
                            queue.offer(j);//初始化队列
                        }
                    }
                    if(cmd.charAt(i)=='D'){
                        cur++;
                        if(cur>n){
                            cur = 1;
                        }
                    }else if(cmd.charAt(i)=='U'){
                        cur--;
                        if(cur<=0){
                            cur =n;
                        }
                    }
                }else{//大于4个
                    if(queue.size()==0){
                        for(int j=1;j<=4;j++){
                            queue.offer(j);//初始化队列
                        }
                    }
                    if(cmd.charAt(i)=='U'){
                        cur--;
                        if(cur<=0){//特殊
                            cur =n;
                            queue.clear();
                            for(int j=cur-3;j<=cur;j++){
                                queue.offer(j);//更新队列
                            }
                            continue;
                        }else{//一般的U
                            if((queue.peek()-cur)==1){
                                queue.clear();
                                for(int j=cur;j<=cur+3;j++){
                                    queue.offer(j);//跟新队列
                                }
                            }
                        }
                    }else if(cmd.charAt(i)=='D'){
                        cur++;
                        if(cur>n){//特殊的D
                            cur = 1;
                            queue.clear();
                            for(int j=1;j<=4;j++){
                                queue.offer(j);//跟新队列
                            }
                        }else{
                            if((cur-queue.peek()-3)==1){
                                queue.poll();//出队
                                queue.offer(cur);
                            }
                        }
                        
                    }
                    
                }
            }
            String result="";
            for (Integer x : queue) { 
                result+=x+" ";
            } 
            System.out.println(result.substring(0,result.length()-1));
            System.out.println(cur);
        }
        sc.close();
    }
    
}





题目描述






定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5 × 5数组下所示： 



int maze[5][5] = {



        0, 1, 0, 0, 0,



        0, 1, 0, 1, 0,



        0, 0, 0, 0, 0,



        0, 1, 1, 1, 0,



        0, 0, 0, 1, 0,



};



它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。入口点为[0,0],既第一空格是可以走的路。


Input


一个N × M的二维数组，表示一个迷宫。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。


Output


左上角到右下角的最短路径，格式如样例所示。


Sample Input


0 1 0 0 0


0 1 0 1 0


0 0 0 0 0


0 1 1 1 0


0 0 0 1 0


Sample Output


(0, 0)


(1, 0)


(2, 0)


(2, 1)


(2, 2)


(2, 3)


(2, 4)


(3, 4)


(4, 4)
 














输入描述:


输入两个整数，分别表示二位数组的行数，列数。再输入相应的数组，其中的1表示墙壁，0表示可以走的路。数据保证有唯一解,不考虑有多解的情况，即迷宫只有一条通道。


输出描述:


左上角到右下角的最短路径，格式如样例所示。




示例1






输入




5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0









输出




(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)














PS:这道题别人是用 深度 和广度优先算法实现的 ，我用的A*
import java.util.*;

public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int m = sc.nextInt();
            int n = sc.nextInt();
            int [][] arr = new int[m][n];
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    arr[i][j] = sc.nextInt();
                }
            }
            ArrayList<Node> search = getRoadCount(arr,0, 0, m-1, n-1);
            for(int i=0;i<search.size();i++)
            {
                 System.out.println("("+search.get(i).getX()+","+search.get(i).getY()+")");  
            }
        }
        sc.close();
    }
    public static ArrayList<Node> getRoadCount(int [][] map,int x1,int y1,int x2,int y2)
    {
         int[][] vitualMap = endAndEntranceToFinal(map,y2,x2);// y ,x
        
          AStar aStar=new AStar(vitualMap, vitualMap.length, vitualMap[0].length);  //H W
          ArrayList<Node> resultList = aStar.search(x1, y1, x2, y2);  //,y1  x1 ,x2,y2
           return  resultList;
    }
    
    /**
     * 把地图进行转换,从出口到指定的车位，除下指定车位不是障碍，其余都是  x,y是指定的车位
     * 0，是障碍，1是路
     * @param map
     * @return
     */
    private static int[][] endAndEntranceToFinal(int [][] map,int x,int y) {
        int[][] result = new int[map.length][map[0].length];
         for (int i = 0; i < map.length; i++) {  
             for (int j = 0; j < map[0].length; j++) {  
                 if(map[i][j]==0){
                     result[i][j] = 1;
                 }else{
                     result[i][j] = 0;
                 }
             }      
         }
        return result;
    }    
}

  
class AStar {  
  
    private int[][] map;// 地图(1可通过 0不可通过)  
    private List<Node> openList;// 开启列表  
    private List<Node> closeList;// 关闭列表  
    private final int COST_STRAIGHT = 10;// 垂直方向或水平方向移动的路径评分  
    private final int COST_DIAGONAL = 14;// 斜方向移动的路径评分  
    private int row;// 行  
    private int column;// 列  
  
    public AStar(int[][] vitualMap, int row, int column) {  
        this.map = vitualMap;  
        this.row = row;  
        this.column = column;  
        openList = new ArrayList<Node>();  
        closeList = new ArrayList<Node>();  
    }  
  
    // 查找坐标（-1：错误，0：没找到，1：找到了）  
    public ArrayList<Node> search(int x1, int y1, int x2, int y2) {  
        if(map[x1][y1]==0||map[x2][y2]==0){           // return -1;  
        }  
        Node sNode=new Node(x1,y1,null);  
        Node eNode=new Node(x2,y2,null);        
        openList.add(sNode);  
        ArrayList<Node> resultList=(ArrayList<Node>) search(sNode, eNode);  
     
        for(Node node:resultList){  
            map[node.getX()][node.getY()]=-1;  
        }  
        return resultList;  
    }  
  
    // 查找核心算法  
    private List<Node> search(Node sNode, Node eNode) {  
        List<Node> resultList = new ArrayList<Node>();  
        boolean isFind = false;  
        Node node = null;  
        while (openList.size() > 0) {  
            // 取出开启列表中最低F值，即第一个存储的值的F为最低的  
            node = openList.get(0);  
            // 判断是否找到目标点  
            if (node.getX() == eNode.getX() && node.getY() == eNode.getY()) {  
                isFind = true;  
                break;  
            }  
            // 上  
            if ((node.getY() - 1) >= 0) {  
                checkPath(node.getX(), node.getY() - 1, node, eNode,  
                        COST_STRAIGHT);  
            }  
            // 下  
            if ((node.getY() + 1) < column) {  
                checkPath(node.getX(), node.getY() + 1, node, eNode,  
                        COST_STRAIGHT);  
            }  
            // 左  
            if ((node.getX() - 1) >= 0) {  
                checkPath(node.getX() - 1, node.getY(), node, eNode,  
                        COST_STRAIGHT);  
            }  
            // 右  
            if ((node.getX() + 1) < row) {  
                checkPath(node.getX() + 1, node.getY(), node, eNode,  
                        COST_STRAIGHT);  
            }  
          
            // 从开启列表中删除  
            // 添加到关闭列表中  
            closeList.add(openList.remove(0));  
            // 开启列表中排序，把F值最低的放到最底端  
            Collections.sort(openList, new NodeFComparator());  
        }  
        if (isFind) {  
            getPath(resultList, node);  
        }  
        return resultList;  
    }  
  
    // 查询此路是否能走通  
    private boolean checkPath(int x, int y, Node parentNode, Node eNode,  
            int cost) {  
        Node node = new Node(x, y, parentNode);  
        // 查找地图中是否能通过  
        if (map[x][y] == 0) {  
            closeList.add(node);  
            return false;  
        }  
        // 查找关闭列表中是否存在  
        if (isListContains(closeList, x, y) != -1) {  
            return false;  
        }  
        // 查找开启列表中是否存在  
        int index = -1;  
        if ((index = isListContains(openList, x, y)) != -1) {  
            // G值是否更小，即是否更新G，F值  
            if ((parentNode.getG() + cost) < openList.get(index).getG()) {  
                node.setParentNode(parentNode);  
                countG(node, eNode, cost);  
                countF(node);  
                openList.set(index, node);  
            }  
        } else {  
            // 添加到开启列表中  
            node.setParentNode(parentNode);  
            count(node, eNode, cost);  
            openList.add(node);  
        }  
        return true;  
    }  
  
    // 集合中是否包含某个元素(-1：没有找到，否则返回所在的索引)  
    private int isListContains(List<Node> list, int x, int y) {  
        for (int i = 0; i < list.size(); i++) {  
            Node node = list.get(i);  
            if (node.getX() == x && node.getY() == y) {  
                return i;  
            }  
        }  
        return -1;  
    }  
  
    // 从终点往返回到起点  
    private void getPath(List<Node> resultList, Node node) {  
        if (node.getParentNode() != null) {  
            getPath(resultList, node.getParentNode());  
        }  
        resultList.add(node);  
    }  
  
    // 计算G,H,F值  
    private void count(Node node, Node eNode, int cost) {  
        countG(node, eNode, cost);  
        countH(node, eNode);  
        countF(eNode);  
    }  
  
    // 计算G值  
    private void countG(Node node, Node eNode, int cost) {  
        if (node.getParentNode() == null) {  
            node.setG(cost);  
        } else {  
            node.setG(node.getParentNode().getG() + cost);  
        }  
    }  
  
    // 计算H值  
    private void countH(Node node, Node eNode){  
        int x = Math.abs(node.getX() - eNode.getX());  
        int y = Math.abs(node.getY() - eNode.getY());  
        if(x<y){  
            node.setH(x * COST_DIAGONAL + (y-x) * COST_STRAIGHT);  
        }else{  
            node.setH(y * COST_DIAGONAL + (x-y) * COST_STRAIGHT);  
        }  
    }  
  
    // 计算F值  
    private void countF(Node node) {  
        node.setF(node.getG() + node.getH());  
    }  
  
   
}  
  
// 节点类  
class Node {  
    private int x;// X坐标  
    private int y;// Y坐标  
    private Node parentNode;// 父类节点  
    private int g;// 当前点到起点的移动耗费  
    private int h;// 当前点到终点的移动耗费，即曼哈顿距离|x1-x2|+|y1-y2|(忽略障碍物)  
    private int f;// f=g+h  
  
    public Node(int x, int y, Node parentNode) {  
        this.x = x;  
        this.y = y;  
        this.parentNode = parentNode;  
    }  
  
    public int getX() {  
        return x;  
    }  
  
    public void setX(int x) {  
        this.x = x;  
    }  
  
    public int getY() {  
        return y;  
    }  
  
    public void setY(int y) {  
        this.y = y;  
    }  
  
    public Node getParentNode() {  
        return parentNode;  
    }  
  
    public void setParentNode(Node parentNode) {  
        this.parentNode = parentNode;  
    }  
  
    public int getG() {  
        return g;  
    }  
  
    public void setG(int g) {  
        this.g = g;  
    }  
  
    public int getH() {  
        return h;  
    }  
  
    public void setH(int h) {  
        this.h = h;  
    }  
  
    public int getF() {  
        return f;  
    }  
  
    public void setF(int f) {  
        this.f = f;  
    }  
}  
  
// 节点比较类  
class NodeFComparator implements Comparator<Node> {  
    @Override  
    public int compare(Node o1, Node o2) {  
        return o1.getF() - o2.getF();  
    }  
}  





题目描述






给出一个名字，该名字有26个字符串组成，定义这个字符串的“漂亮度”是其所有字母“漂亮度”的总和。 
每个字母都有一个“漂亮度”，范围在1到26之间。没有任何两个字母拥有相同的“漂亮度”。字母忽略大小写。 
给出多个名字，计算每个名字最大可能的“漂亮度”。 












输入描述:


整数N，后续N个名字


输出描述:


每个名称可能的最大漂亮程度




示例1






输入




2
zhangsan
lisi









输出




192
101














PS:这个题题目都不太明白
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
 



/*


思路：为使名字漂亮度最大，让出现次数越多的字符占用的漂亮度尽可能的大，


其实就是在忽略大小写字母的前提下，求和最大。


步骤：1.读入


     2.统计，并排序


     3.求和


*/


public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int num = sc.nextInt();
            for(int i=0;i<num;i++){
                calculate(sc.next());
            }
        }
        sc.close();
    }
    public static void calculate(String input){
        int[] num_ch = new int[26];
        for(int i=0;i<input.length();i++){
            switch(input.charAt(i)){
            case 'a':num_ch[0]++;break;
            case 'b':num_ch[1]++;break;
            case 'c':num_ch[2]++;break;
            case 'd':num_ch[3]++;break;
            case 'e':num_ch[4]++;break;
            case 'f':num_ch[5]++;break;
            case 'g':num_ch[6]++;break;
            case 'h':num_ch[7]++;break;
            case 'i':num_ch[8]++;break;
            case 'j':num_ch[9]++;break;
            case 'k':num_ch[10]++;break;
            case 'l':num_ch[11]++;break;
            case 'm':num_ch[12]++;break;
            case 'n':num_ch[13]++;break;
            case 'o':num_ch[14]++;break;
            case 'p':num_ch[15]++;break;
            case 'q':num_ch[16]++;break;
            case 'r':num_ch[17]++;break;
            case 's':num_ch[18]++;break;
            case 't':num_ch[19]++;break;
            case 'u':num_ch[20]++;break;
            case 'v':num_ch[21]++;break;
            case 'w':num_ch[22]++;break;
            case 'x':num_ch[23]++;break;
            case 'y':num_ch[24]++;break;
            case 'z':num_ch[25]++;break;
            case 'A':num_ch[0]++;break;
            case 'B':num_ch[1]++;break;
            case 'C':num_ch[2]++;break;
            case 'D':num_ch[3]++;break;
            case 'E':num_ch[4]++;break;
            case 'F':num_ch[5]++;break;
            case 'G':num_ch[6]++;break;
            case 'H':num_ch[7]++;break;
            case 'I':num_ch[8]++;break;
            case 'J':num_ch[9]++;break;
            case 'K':num_ch[10]++;break;
            case 'L':num_ch[11]++;break;
            case 'M':num_ch[12]++;break;
            case 'N':num_ch[13]++;break;
            case 'O':num_ch[14]++;break;
            case 'P':num_ch[15]++;break;
            case 'Q':num_ch[16]++;break;
            case 'R':num_ch[17]++;break;
            case 'S':num_ch[18]++;break;
            case 'T':num_ch[19]++;break;
            case 'U':num_ch[20]++;break;
            case 'V':num_ch[21]++;break;
            case 'W':num_ch[22]++;break;
            case 'X':num_ch[23]++;break;
            case 'Y':num_ch[24]++;break;
            case 'Z':num_ch[25]++;break;
            }
        }
        Arrays.sort(num_ch);
        int result = 0;
        for(int i=1;i<=26;i++){
            result+=i*num_ch[i-1];
        }
        System.out.println(result);
    }
}





题目描述






题目标题：


判断短字符串中的所有字符是否在长字符串中全部出现


详细描述：


接口说明


原型：


boolIsAllCharExist(char* pShortString,char* pLongString);


输入参数：


    char* pShortString：短字符串


    char* pLongString：长字符串








输入描述:


输入两个字符串。第一个为短字符，第二个为长字符。


输出描述:


返回值：




示例1






输入




bc
abc









输出




true




import java.util.Scanner;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            int count =0;
            String shoreStr = sc.nextLine();
            String longStr = sc.nextLine();
            for(int i=0;i<shoreStr.length();i++){
                for(int j=0;j<longStr.length();j++){
                    if(shoreStr.charAt(i)==longStr.charAt(j)){
                        count++;
                        break;
                    }
                }
            }
            if(count==shoreStr.length()){
                System.out.println("true");
            }else{
                System.out.println("false");
            }
        }
        sc.close();
    }

    
    
}
////思路二 ，人家是一唯的

import java.util.Scanner;
 
//字符是否出现不一定是按顺序的，如ca与abc，如aa与abc，结果都是true
//不是求最小公共子序列，也不是求最小公共子串
public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String s1=sc.next();//第一个是短字符，第二个是长字符
            String s2=sc.next();
            System.out.println(boolIsAllCharExist(s1,s2));
        }
        sc.close();
    }
     
    public static boolean boolIsAllCharExist(String s1,String s2){
        for(int i=0;i<s1.length();i++){
            if(!s2.contains(s1.charAt(i)+""))
            return false;
        }
        return true;
    }
}




    















题目描述






查找和排序


题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
      都按先录入排列在前的规则处理。


   例示：
   jack      70
   peter     96
   Tom       70
   smith     67


   从高到低  成绩            
   peter     96    
   jack      70    
   Tom       70    
   smith     67    


   从低到高


   smith     67  


   Tom       70    
   jack      70    
   peter     96      













输入描述:


输入多行，先输入要排序的人的个数，然后分别输入他们的名字和成绩，以一个空格隔开


输出描述:


按照指定方式输出名字和成绩，名字和成绩之间以一个空格隔开




示例1






输入




3
0
fang 90
yang 50
ning 70








输出




fang 90
ning 70
yang 50














import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int val = sc.nextInt();
            int flag = sc.nextInt();
      
            ArrayList<Person> arr = new ArrayList<>();
            
            int order = 0;
            for (int i = 0; i < val; i++) {
                String name = sc.next();//sc.next    和  sc.nextLine是不一样的
                int score = sc.nextInt();
                arr.add(new Person(name,score, order++));//先添加的元素具有较小的order值
            }
            if(flag == 0){//降序
                //x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。
                Collections.sort(arr, new Comparator<Person>() {
                    @Override
                    public int compare(Person s1, Person s2) {
                        if(s1.score > s2.score)
                            return -1;
                        else if(s1.score < s2.score)
                            return 1;
                        else{
                            if(s1.order > s2.order)  //插入次序不变
                                return 1;
                            else return -1;
                        }
                    }
                });
            }
            if(flag == 1){
                Collections.sort(arr, new Comparator<Person>() {
                    @Override
                    public int compare(Person s1, Person s2) {
                        if(s1.score > s2.score)
                            return 1;
                        else if(s1.score < s2.score)
                            return -1;
                        else{
                            if(s1.order > s2.order) //插入次序不变
                                return 1;
                            else return -1;
                        }
                    }
                });
            }
            for(Person ss : arr)
                System.out.println(ss);
        }
        sc.close();
    }
}
class Person{
    /* 按成绩进行排序，乘积相同按照输入的前后进行排序，设想将乘积相同的对象，插入一个标志，标记器被添加的顺序，但是这样不好进行操作
     * */
    public String name;
    public int score;
    public int order;
    public Person(String name, int score, int order){
        this.name = name;
        this.score = score;
        this.order = order;
    }
    @Override
    public String toString() {
        return name + " " + score;
    }
}





题目描述






给定一个字符串描述的算术表达式，计算出结果值。


输入字符串长度不超过100，合法的字符包括”+, -, *, /, (, )”，”0-9”，字符串内容的合法性及表达式语法的合法性由做题者检查。本题目只涉及整型计算。




输入描述:


输入算术表达式


输出描述:


计算出结果值




示例1






输入




400+5









输出




405




PS:


 中缀表达式：9+(3-1)*3+10/2      就是待计算的
 后缀表达式 ：9 3 1 - 3 * + 10 2 / +




import java.util.*;
public class Main { 
    public static void main(String[] args){
         Scanner sc=new Scanner(System.in);
         while(sc.hasNext()){
             String str = sc.nextLine();
            
             String suffix = infixToSuffix(str);
             System.out.println(suffix);
             System.out.println(calculateSuffix(suffix));
         }
         sc.close();
    }

    public static int calculateSuffix(String suffix){
        /**
         * 遇到数字就进栈
         */
        Stack<Integer> numStack=new Stack<Integer>();
        //s 匹配任何空白字符，包括空格、制表符、换页符等。与 [ f

	v] 等效。
        String[] str = suffix.split("\s+");
        int n1,n2;
        for(int i=0;i<str.length;i++){
            String s=str[i];
            if(s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/")){
                n2 = numStack.pop();
                n1 =numStack.pop();
                 if(s.equals("+"))
                     numStack.push(n1+n2);
                 else if(s.equals("-"))
                     numStack.push(n1-n2);
                 else if(s.equals("*"))
                     numStack.push(n1*n2);
                 else
                     numStack.push(n1/n2);
            }else{
                numStack.push(Integer.valueOf(s));//放入 数字  和 括号
            }
        }
        return numStack.pop();    
        
    }
    private static String infixToSuffix(String infix) {
        /**
         * PS:1.如果是数字，放入sb
         *      2.符号和括号进栈
         *         还有不同符号优先级的判断  ： 如果是乘除直接弹栈
         */
         Stack<Character> stack=new Stack<Character>();
        StringBuilder suffix=new StringBuilder();
        char[] ch=infix.toCharArray();
        
        for(int i=0;i<ch.length;i++){
            if(ch[i]=='('){
                stack.push(ch[i]);
 
            }
             
            else if(ch[i]>='0' && ch[i]<='9')
                suffix.append(ch[i]);
            else if(ch[i]=='*' || ch[i]=='/'){
                while(!stack.isEmpty()){
                    char tmp=stack.peek();
                    if(tmp=='*' || tmp=='/'){
                        suffix.append(" ").append(stack.pop()).append(" ");
                    }
                    else
                        break;
                }
                stack.push(ch[i]);
                suffix.append(" ");
            }
            else if(ch[i]=='+' || ch[i]=='-'){
                if(ch[i]=='-'){
                    char before=ch[i-1];
                    if(before=='(' || before=='+' || before=='-' || before=='*' || before=='/')
                        suffix.append(" ").append(ch[i]);
                    else{
                        while(!stack.isEmpty()){
                            if(stack.peek()!='(')
                                suffix.append(" ").append(stack.pop());
                            else
                                break;
                        }
                        stack.push(ch[i]);
                        suffix.append(" ");
                    }                       
                }
                else{
                    while(!stack.isEmpty()){
                        if(stack.peek()!='(')
                            suffix.append(" ").append(stack.pop());
                        else
                            break;
                    }
                    stack.push(ch[i]);  
                    suffix.append(" ");
                     
                }
                 
                 
            }
            else{
                while(!stack.isEmpty()){
                    char tmp=stack.pop();
                    if(tmp!='(')
                        suffix.append(" ").append(tmp);
                    else
                        break;                  
                }
                 
            }                           
        }
        while(!stack.isEmpty())
            suffix.append(" ").append(stack.pop()); 
            return suffix.toString();
        }
}


















题目描述






Levenshtein 距离，又称编辑距离，指的是两个字符串之间，由一个转换成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。编辑距离的算法是首先由俄国科学家Levenshtein提出的，故又叫Levenshtein Distance。


Ex：


字符串A:abcdefg


字符串B: abcdef


通过增加或是删掉字符”g”的方式达到目的。这两种方案都需要一次操作。把这个操作所需要的次数定义为两个字符串的距离。


要求：


给定任意两个字符串，写出一个算法计算它们的编辑距离。



请实现如下接口


/*  功能：计算两个字符串的距离


 *  输入： 字符串A和字符串B


 *  输出：无


 *  返回：如果成功计算出字符串的距离，否则返回-1


 */


     public   static   int calStringDistance (String charA, String  charB)


    {


        return  0;


    }  






输入描述:


输入两个字符串


输出描述:


得到计算结果




示例1






输入




abcdefg
abcdef









输出




1


所谓Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，操作包括一切你使用的手段将一个字符串转换成另一个字符串，比如插入一个字符、删除一个字符..等等；操作次数越少，说明两个字符串距离Levenshtein Distance越小，表示两个字符串越想似。


应用最广泛的的当然就是DNA序列比对了。


此处算法思想用一个“代价表”表示（我这里这么称呼，因为比对过程中产生的代价总和就是字符串的距离），比如有两个字符串s1=“ABCDEFGZ”,s2="ABFDFEGXY"；则代价表如下：（代价表实现思想：若比较过程中两个字符相同，则直接取左上角代价，若不同，则取左上角、左、上三方代价最小值再加1.）



代价表



 
 
A
B
C
D
E
F
G
Z




 
0
1
2
3
4
5
6
7
8




A
1
0
1
2
3
4
5
6
7




B
2
1
0
1
2
3
4
5
6




F
3
2
1
1
2
3
3
4
5




D
4
3
2
2
1
2
3
4
5




F
5
4
3
3
2
2
2
3
4




E
6
5
4
4
3
2
3
3
4




G
7
6
5
5
4
3
4
3
4




X
8
7
6
6
5
4
5
4
4




Y
9
8
7
7
6
5
6
5
5







由上述表可得：s1=“ABCDEFGZ”与s2="ABFDFEGXY"的距离为5




PS:这个题完全不会做
import java.util.*;
public class Main { 
    public static int Ldistance(char[] ch1,char[] ch2){
        int m = ch1.length;
        int n = ch2.length;
        int[][] dp = new int[m+1][n+1];
        for(int i=0;i<m+1;i++){
            dp[i][0]=i;
        }
        for(int j=0;j<n+1;j++){
            dp[0][j]=j;
        }
        for(int i = 1 ; i < ch1.length + 1 ; i++){ 
            for(int j = 1 ; j < ch2.length + 1 ; j++){ 
            if(ch1[i-1] == ch2[j-1])//如果i,j位相同，则不用变化，与上一轮结果是一样的
                dp[i][j] = dp[i-1][j-1]; 
            else{//如果i,j位不同，那么就需要从给ch1增加一个字母，给ch2增加一个字母或者把ch1一个字母变成和ch2一样来选一个最小的作为这个点的改变距离
                dp[i][j] = Math.min(Math.min(dp[i-1][j] + 1 ,dp[i][j-1] + 1) , dp[i-1][j-1] + 1); 
                } 
            } 
        } 
        return dp[m][n];
    }
public static void main(String[] args) { 
    Scanner scanner = new Scanner(System.in); 
        while(scanner.hasNext()){ 
            String str1 = scanner.next();
            String str2 = scanner.next();
            char[] ch1 = str1.toCharArray();
            char[] ch2 = str2.toCharArray();
            System.out.println(Ldistance(ch1,ch2));
        } 
    scanner.close(); 
    } 
}















题目描述






完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。


它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。


例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。


给定函数count(int n),用于计算n以内(含n)完全数的个数。计算范围, 0 < n <= 500000


返回n以内完全数的个数。 异常情况返回-1



/**


 * 


 *  完全数（Perfect number），又称完美数或完备数，是一些特殊的自然数。


 *  它所有的真因子（即除了自身以外的约数）的和（即因子函数），恰好等于它本身。


 *  例如：28，它有约数1、2、4、7、14、28，除去它本身28外，其余5个数相加，1+2+4+7+14=28。


 * 


 *  给定函数count(int n),用于计算n以内(含n)完全数的个数


 * @param n  计算范围, 0 < n <= 500000


 * @return n 以内完全数的个数, 异常情况返回-1


 * 


 */    


public   static   int  count( int  n)






输入描述:


输入一个数字


输出描述:


输出完全数的个数




示例1






输入




1000








输出




3




/*
1.输入一个数
2.这个数从1到n递增;
3.对每一个数进行处理，
  3.1数从1递增到这个数，如果这个数（不含本身） 除以 递增 ==0，弄一个东西统计这个等于0的数，在执行完num相加之后（这个num相加==i）;count++
 //两个循环
*/
import java.util.Scanner;

public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext())
        {
            int n = sc.nextInt();
            //System.out.println(getCount(n));
            getCount(n);
        }
        sc.close();
    }

    private static void getCount(int n) {
        int count =0;
        for(int i=1;i<=n;i++)//i就是这个数字
        {
            int num =0;
            //System.out.println(i);
            for(int j=1;j<i;j++)//这是不包含i   , j代表内部递增的数字
            {
                
                if(i%j==0)
                {
                    num =num+j;//这个num就是i
                    //System.out.println("num:"+num);
                    //System.out.print("此时i:"+i+",j:"+ j+", num:"+num+"  ");
                }
                
            }
            if(num==i)
            {
                count++;
            }
            //System.out.println();
        }
        System.out.println(count);
    }


    
}















编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。但是要保证汉字不被截半个，如"我ABC"4，应该截为"我AB"，输入"我ABC汉DEF"6，应该输出为"我ABC"而不是"我ABC+汉的半个"。 




输入描述:


输入待截取的字符串及长度


 




输出描述:


截取后的字符串




链接：https://www.nowcoder.com/questionTerminal/a30bbc1a0aca4c27b86dd88868de4a4a
来源：牛客网

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String s = sc.next();
            int num = sc.nextInt();
            int num_chinese = 0;
            for(int i=0;i<num;i++){
                if(!Character.isJavaLetterOrDigit(s.charAt(i))){
                    num_chinese++;
                }
            }
            System.out.println(s.substring(0,num-num_chinese/2));
        }
        sc.close();
    }
}




/**
PS:这个思路很好，对比，是字符+汉字的和；与字节做对比
*/
import java.util.Arrays;
import java.util.Scanner;
 
public class Main {
    public static String process(String str,int num){
        StringBuilder res=new StringBuilder();
        int len=str.length();
        int total=0;
        for(int i=0;i<len;i++){
            char c=str.charAt(i);
            int cur= (0<=c && c<=127 ) ? 1 : 2;   //判断字符是不是汉字
            if(total+cur>num){
                return res.toString();
            }else if(total+cur==num){
                res.append(c);
                return res.toString();
            }else{
                res.append(c);
                total+=cur;
            }
        }
        return res.toString();
    }
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
         while (sc.hasNext()) {
             String str=sc.next();
             int num=sc.nextInt();
             System.out.println(process(str,num));
         }
        sc.close();
        //System.out.println(process("我ABC汉DEF",6));
    }
}







 





题目描述






假设一个球从任意高度自由落下，每次落地后反跳回原高度的一半; 再落下, 求它在第5次落地时，共经历多少米?第5次反弹多高？ 



    /**
     * 统计出第5次落地时，共经过多少米?
     * 
     * @param high 球的起始高度
     * @return 英文字母的个数
     */
    public static double getJourney(int high)
    {
        return 0;
    }
    
    /**
     * 统计出第5次反弹多高?
     * 
     * @param high 球的起始高度
     * @return 空格的个数
     */
    public static double getTenthHigh(int high)
    {
        return 0;
    }
















输入描述:


输入起始高度，int型


输出描述:


分别输出第5次落地时，共经过多少米第5次反弹多高




示例1






输入




1








输出




2.875
0.03125














import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            double n = sc.nextDouble();
            double tmp = n;
            double sum = 2*n;
           // ArrayList<Double> list = new ArrayList<Double>();
            for(int i=1;i<4;i++){
                tmp = tmp*1.0/2;
                //list.add(tmp);
                sum+=tmp;
            }
            System.out.println(sum);
            System.out.println(tmp*1.0/2);
        }
        sc.close();
        
    }
}





题目描述






首先输入要输入的整数个数n，然后输入n个整数。输出为n个整数中负数的个数，和所有正整数的平均值，结果保留一位小数。




输入描述:


首先输入一个正整数n，
然后输入n个整数。


输出描述:


输出负数的个数，和所有正整数的平均值。




示例1






输入




5
1
2
3
4
5








输出




0 3














import java.util.Scanner;
 
public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextInt()){
         int n = sc.nextInt();
          int[] arr=new int[n];
          for(int i=0;i<arr.length;i++){
             arr[i]=sc.nextInt();
          };
          cal(arr);
               
        }   
    }
    public static void cal(int[] arr){
        int count1 =0;
        float sum=0,count2=0,avg=0;
        for(int i=0;i<arr.length;i++){
            if(arr[i]<0){
                count1++;
            }else if(arr[i]>0){
               count2++;
                sum+=arr[i];
            }
        }
        if(count2!=0){
            avg=sum/count2;
        }
        //最后要换行，保留一位小数
        System.out.print(count1+" ");
        System.out.printf("%.1f
",avg);   ///负数的输出应该这么输出
    }
}





题目描述






在命令行输入如下命令：


xcopy /s c: d:，


各个参数如下： 


参数1：命令字xcopy 


参数2：字符串/s


参数3：字符串c:


参数4: 字符串d:


请编写一个参数解析程序，实现将命令行各个参数解析出来。



解析规则： 


1.参数分隔符为空格 
2.对于用“”包含起来的参数，如果中间有空格，不能解析为多个参数。比如在命令行输入xcopy /s “C:program files” “d:”时，参数仍然是4个，第3个参数应该是字符串C:program files，而不是C:program，注意输出参数时，需要将“”去掉，引号不存在嵌套情况。
3.参数不定长 
4.输入由用例保证，不会出现不符合要求的输入 
 















输入描述:


输入一行字符串，可以有空格


输出描述:


输出参数个数，分解后的参数，每个参数都独占一行




示例1






输入




xcopy /s c:\ d:\









输出




4
xcopy
/s
c:\
d:\




/*
PS:找到字符串中的数字
*/

import java.util.ArrayList;
import java.util.Scanner;
/**
 * 1.对截取次数进行处理
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
       
        while(sc.hasNext())
        {
            ArrayList<Integer> list = new ArrayList<Integer>();
           String str = sc.nextLine();
           char[] arr = str.toCharArray();
           for(int i=0;i<arr.length;i++){
               if(arr[i]=='"'){
                   list.add(i);
               }
           }
           for(int i=0;i<list.size()/2;i++){
                // 0    get 0      1    2i   2i+1
               for(int j=list.get(2*i);j<list.get(2*i+1);j++){
                   if(arr[j]==' '){
                       arr[j]='#';
                   }
               }
           }
          // System.out.println(arr); 以上是对字符串中“ ”部分进行处理 有“ ”编程#
           String []subs = new String(arr).split(" ");
           // String result="";
           ArrayList<String> list2 = new ArrayList<String>();
           for(int i=0;i<subs.length;i++){
               if(subs[i].contains(""")){
                   String substring = subs[i].substring(1, subs[i].length()-1);
                   if(subs[i].contains("#")){
                       String replace = substring.replace("#", " ");
                       //result+=replace+" ";
                       list2.add(replace);
                   }else{
                      // result+=substring+" ";
                       list2.add(substring);
                   }
               }else{
                  // result+=subs[i]+" ";
                   list2.add(subs[i]);
               }
           }
           System.out.println(list2.size());
           for(int i=0;i<list2.size();i++){
               System.out.println(list2.get(i));
           }
        }
        sc.close();
        
    }
 
}















题目描述






验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。


例如：


1^3=1 


2^3=3+5 


3^3=7+9+11 


4^3=13+15+17+19 



接口说明


原型：



 /*
 功能: 验证尼科彻斯定理，即：任何一个整数m的立方都可以写成m个连续奇数之和。
 原型：
     int GetSequeOddNum(int m,char * pcSequeOddNum);
 输入参数：
     int m：整数(取值范围：1～100)
    
 返回值：
     m个连续奇数(格式：“7+9+11”);
 */


 public String GetSequeOddNum(int m)
 {
     /*在这里实现功能*/


     return null;
 }

















输入描述:


输入一个int整数


输出描述:


输出分解后的string




示例1






输入




6









输出




31+33+35+37+39+41














/*
PS:找到字符串中的数字
*/

import java.util.ArrayList;
import java.util.Scanner;
/**
 * 1.对截取次数进行处理
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
       
        while(sc.hasNext())
        {
            ArrayList<Integer> list = new ArrayList<Integer>();
            int num = sc.nextInt();
            int lifang = num*num*num;
            for(int i=1;i<lifang;i++){
                if(i%2!=0){//奇数
                    int tmp = 0;
                    for(int j=0;j<num;j++){
                        tmp+=i+2*j;
                    }
                    if(tmp==lifang){
                        list.add(i);
                        break;
                    }
                }
            }
            for(int i=1;i<num;i++){
                list.add(list.get(0)+2*i);
            }
            String result ="";
            for(int i=0;i<list.size();i++){
                result+=list.get(i)+"+";
            }
            System.out.println(result.substring(0,result.length()-1));
            
        }
        sc.close();
        
    }
 
}





题目描述






将一个字符中所有出现的数字前后加上符号“*”，其他字符保持不变
 public static String MarkNum(String pInStr)
 {
     
  return null;
 }
















输入描述:


输入一个字符串


输出描述:


字符中所有出现的数字前后加上符号“*”，其他字符保持不变




示例1






输入




Jkdi234klowe90a3








输出




Jkdi*234*klowe*90*a*3*














/*
PS:找到字符串中的数字
*/

import java.util.*;

/**
 * 1.对截取次数进行处理
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
       
        while(sc.hasNext())
        {
            
            String str = sc.nextLine();
            char arr[] = str.toCharArray();
            StringBuilder sb = new StringBuilder();
            for(int i=0;i<arr.length;i++){
                if(Character.isDigit(arr[i])){
                    sb.append("*"+arr[i]+"*");
                }else{
                    sb.append(arr[i]);
                }
            }
            String result = sb.toString().replace("**", "");
            System.out.println(result);
        }
        sc.close();
        
    }
 
}





题目描述






正整数A和正整数B 的最小公倍数是指 能被A和B整除的最小的正整数值，设计一个算法，求输入A和B的最小公倍数。




输入描述:


输入两个正整数A和B。


输出描述:


输出A和B的最小公倍数。




示例1






输入




5 
7









输出




35














import java.util.*;
import java.util.Scanner;

/**
两个数的乘积除以最大公约数，就是最小公倍数
*/
public class Main {
   
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
         
         while(sc.hasNext())
         {
             int n1 = sc.nextInt();
             int n2 = sc.nextInt();
             int max = Math.max(n1, n2);
             List<Integer> list = new ArrayList<Integer>();
             for(int i=1;i<max;i++)
             {
                 if(n1%i==0&&n2%i==0)
                 {
                     list.add(i);
                 }
             }
            // int maxYue=list.get(list.size()-1);
             int maxYue=Collections.max(list);
             System.out.println((n1*n2)/maxYue);
         }
         
    }

}





题目描述






从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值




输入描述:


输入任意个整数


输出描述:


输出负数个数以及所有非负数的平均值




示例1






输入




-13
-4
-7









输出




3
0.0




import java.util.Scanner;

public class Main {
    
    

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
         int fcount = 0;
         float sum =0;///!!!!注意要进行，浮点运算的时候，都是浮点数比较好，否则会除出现错误
         int zcount = 0;
         while(sc.hasNext())
         {
             int num = sc.nextInt();
             if(num<0)
             {    
                fcount ++;
             }
             else
             {
                 zcount++;
                 sum += num;
             }
         }
         float average = sum/zcount;
         System.out.println(fcount);
         System.out.printf("%.1f
", average);
    }

    
    
}

















/**
     * 判断一个数是不是质数
     * @param i
     * @return
     */
    private static boolean isSu(int num) {
        for(int j=2;j<num;j++)
        {
            if(num%j==0)
            {
                return false;
            }
        }
        return true;
    }








/*
1.输入一个偶数
2.从1到这个数，
  判断这个数是不是素数，如果是，就记录下来，用这个数减去记录下来的数，看看这个是不是素数（如果是，在比较是不是最小）；不是就ps
*/
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
/**
 * 
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        List<Integer> list = new ArrayList<Integer>();
        while(sc.hasNext())
        {
            int arr[]={};
            int n = sc.nextInt();
            for(int i=2;i<n;i++)
            {
                if(isSu(i))
                {
                    list.add(i);
                }
            }
            List<Integer> list1 = new ArrayList<Integer>();
            //System.out.println(list.toString());
            for(int i=0;i<list.size();i++)//i代表数组中的数
            {
                for(int j=i+1;j<list.size();j++)
                {
                    if((list.get(i)+list.get(j)==n))
                    {    
                        //System.out.println("123i:"+list.get(i)+",j:"+list.get(j)+" ");
                        list1.add(list.get(i));
                        list1.add(list.get(j));
                    }else if(list.get(i)+list.get(i)==n){
                        list1.add(list.get(i));
                        list1.add(list.get(i));
                    }else if(list.get(j)+list.get(j)==n){
                        list1.add(list.get(j));
                        list1.add(list.get(j));
                    }
                }
            }
            
            /*for(int i=0;i<list1.size();i++){
                System.out.println(list1.get(i));
            }*/
            System.out.println(list1.get(list1.size()-2));//因为要差值最小，所以取最后两位
            System.out.println(list1.get(list1.size()-1));
        }
        sc.close();
    }
  
    /**
     * 判断一个数是不是质数
     * @param i
     * @return
     */
    private static boolean isSu(int i) {
        // 从1增加到i
        int count =0;
        for(int j=1;j<=i;j++)
        {
            if(i%j==0)
            {
                count++;
            }
        }
        return count>2?false:true;
    }

    
    


    
}







根据输入的日期，计算是这一年的第几天。。


详细描述：


输入某年某月某日，判断这一天是这一年的第几天？。




接口设计及说明：


 /*****************************************************************************
 Description   : 数据转换
 Input Param   : year 输入年份
                Month 输入月份
                Day 输入天
                    
 Output Param  :
 Return Value  : 成功返回0，失败返回-1（如：数据错误）
 *****************************************************************************/
 public static int iConverDateToDay(int year, int month, int day)
 {
     /* 在这里实现功能，将结果填入输入数组中*/ 
     return 0;
 }
 
 /*****************************************************************************
 Description   : 
 Input Param   :
                    
 Output Param  :
 Return Value  : 成功:返回outDay输出计算后的第几天;
                                           失败:返回-1
 *****************************************************************************/
 public static int getOutDay()
 {
  return 0;
 }




















输入描述:


输入三行，分别是年，月，日


输出描述:


成功:返回outDay输出计算后的第几天;
                                           失败:返回-1




示例1






输入




2012

12

31








输出




366












/*
1.输入年份
先判断这个一年是366还是365，二月是366
2.输入月份
对之前的数进行累加
3.输入日直接+日
*/
import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            System.out.println(getDayOfYear(sc.nextInt(), sc.nextInt(), sc.nextInt()));
        }
        sc.close();
    }

    private static int getDayOfYear(int year, int month, int day) {
        // TODO Auto-generated method stub
        Calendar calendar = new GregorianCalendar(year, month - 1, day);
        return calendar.get(Calendar.DAY_OF_YEAR);
    }

    
}





题目描述






    

  • 

    如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘，其结果将是另一个x行z列的矩阵C。这个矩阵的每个元素是由下面的公式决定的：
    

    • 




原型：


voidmatrix_multiply(int *m1,int *m2,int *r, int x, int y, int z);


输入参数：


    int *m1：x行y列的矩阵(array1[x][y])


    int *m2：y行z列的矩阵(array2[y][z])


    int x：矩阵m1的行数


    int y：矩阵m1的列数/矩阵m2的行数


    int z：矩阵m2的列数



输出参数：


    int *r：矩阵m1, m2相乘的结果(array3[x][z])



返回值：


        void






输入描述:


输入说明：
1、第一个矩阵的行数
2、第一个矩阵的列数和第二个矩阵的行数
3、第二个矩阵的列数
4、第一个矩阵的值
5、第二个矩阵的值


输出描述:


输出两个矩阵相乘的结果




示例1






输入




2
2
2
3 8
8 0
9 0
18 9








输出




171 72
72 0




import java.util.*;

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

            
            Scanner sc = new Scanner(System.in);
            while(sc.hasNext()){
                int m1 = sc.nextInt();
                int n1m2 = sc.nextInt();
                int n2 = sc.nextInt();
                int [][] result = new int[m1][n2];
                int [][] mat1 = new int[m1][n1m2];
                int [][] mat2 = new int[n1m2][n2];
                //初始化数据
                for(int i=0;i<m1;i++){
                    for(int j=0;j<n1m2;j++){
                        mat1[i][j] = sc.nextInt();
                        //System.out.println(mat1[i][j]);
                    }
                }
                for(int i=0;i<n1m2;i++){
                    for(int j=0;j<n2;j++){
                        mat2[i][j] = sc.nextInt();
                    //    System.out.println(mat2[i][j]);
                    }
                }
            /*    System.out.println(mat2[1][0]);
                System.out.println(mat2[1][1]);*/
                for(int i=0;i<mat1.length;i++){
                    for(int j=0;j<mat2[0].length;j++){
                        for(int h=0;h<mat2.length;h++){
                            result[i][j] += mat1[i][h]*mat2[h][j];
                        }
                    }
                }
                 for(int i=0;i<m1;i++){
                     for(int j=0;j<n2;j++){
                         System.out.print(result[i][j]);
                             if(j!=n2-1){
                                 System.out.print(" ");
                             }
                     }
                     System.out.println();
                 }
            }
            
           
 
}















题目描述






找出给定字符串中大写字符(即'A'-'Z')的个数


接口说明


    原型：int CalcCapital(String str);


    返回值：int






输入描述:


输入一个String数据


输出描述:


输出string中大写字母的个数




示例1






输入




add123#$%#%#O









输出




1














import java.math.BigInteger;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            
            String str = sc.nextLine();
            
            int count =0;
            for(int i=0;i<str.length();i++)
            {
                String regex = "[A-Z]";
                
                Pattern p=Pattern.compile(regex);
                Matcher matcher = p.matcher(String.valueOf(str.charAt(i)));
                if(matcher.find())
                {
                    count++;
                }
            }
            
            System.out.println(count);
        }
        sc.close();
    }

    
    
}




import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            String str = sc.nextLine();
            int num = 0;
            for(int i=0;i<str.length();i++){
                if(Character.isUpperCase(str.charAt(i))){
                    num++;
                }
            }
            System.out.println(num);
        }
        sc.close();
    
    }
}












题目描述






Catcher 是MCA国的情报员，他工作时发现敌国会用一些对称的密码进行通信，比如像这些ABBA，ABA，A，123321，但是他们有时会在开始或结束时加入一些无关的字符以防止别国破解。比如进行下列变化 ABBA->12ABBA,ABA->ABAKK,123321->51233214　。因为截获的串太长了，而且存在多种可能的情况（abaaab可看作是aba,或baaab的加密形式），Cathcer的工作量实在是太大了，他只能向电脑高手求助，你能帮Catcher找出最长的有效密码串吗？





输入描述:


输入一个字符串


输出描述:


返回有效密码串的最大长度




示例1






输入




ABBA








输出




4




PS:重要回文数
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            String str = sc.nextLine();
            Dispose(str);
        }
        sc.close();
    }

    
    //回文串只有两种类型：偶数型为ABBA型，奇数型为ABA型。。
    //依次向后以每个字符为中心，向两侧扩展，判断是偶数型还是奇数型，然后比较偶数型和奇数型回文串的最大长度。。
    public static void Dispose(String str){
        int len = str.length();
        if(len==1){
            System.out.println("1");
            return;
        }
        int num = 1;//回文数最小为1
        for(int i=1;i<len-1;i++){//从第二个字符开始，依次选为中心字符向向两侧扩展
            if(str.charAt(i)==str.charAt(i+1)){//这是  ABBA的模式
                 int cur = 0;  //当成为回文串的最大长度,初始化置为0
                 int start = i; //左侧起始位
                 int end = i+1; //右侧起始位
                 while(start>=0&&end<len&&str.charAt(start) == str.charAt(end)){//向两侧拓展
                     start--;
                     end++;
                     cur+=2;
                 }
                 if(cur>=num){
                     num = cur;
                 }
            }
            if(str.charAt(i-1)==str.charAt(i+1)){//ABA
                int cur = 0;
                int start = i-1;//左侧
                int end = i+1;
                while(start>=0&&end<len&&str.charAt(start)==str.charAt(end)){
                    start--;
                    end++;
                    cur+=2;
                }
                ///System.out.println(start+" "+end);
                ///System.out.println(str.substring(start+1,end));
                if(cur>=num){
                    num = cur+1;//注意此处加1是为了算上中心字符；
                }
            }
        }
        System.out.println(num);
    }
}















1.计算字符串最后一个单词的长度，单词以空格隔开。 


输入描述:


一行字符串，非空，长度小于5000。


输出描述:


整数N，最后一个单词的长度。




示例1






输入




hello world








输出




5




import java.util.*;

public class Main {
    
    public static void main(String [] args){
        //System.out.println("hello world");
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            String[] subStrs = str.split(" ");
            System.out.println(subStrs[subStrs.length-1].length());
        }
        sc.close();
    }

}




 2.


题目描述






写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。




输入描述:


输入一个有字母和数字以及空格组成的字符串，和一个字符。


输出描述:


输出输入字符串中含有该字符的个数。




示例1






输入




ABCDEF
A








输出




1




import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            String c = sc.nextLine();
            char c1 = c.toCharArray()[0];
            int num = 0;
            for(int i=0;i<str.length();i++){
                if(str.charAt(i)==c1 || str.charAt(i)==Character.toUpperCase(c1)|| str.charAt(i)==Character.toLowerCase(c1)){
                    num++;
                }
            }
            System.out.println(num);
        }
        sc.close();
    }

}




PS:输入无关，无需判断


3. 核心：去重和排序--Tree排序，Set去掉重复


题目描述






明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。



Input Param 


     n               输入随机数的个数     


 inputArray      n个随机整数组成的数组 


     


Return Value


     OutputArray    输出处理后的随机整数




注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。























输入描述:


输入多行，先输入随机整数的个数，再输入相应个数的整数


输出描述:


返回多行，处理后的结果




示例1






输入




11
10
20
40
32
67
40
20
89
300
400
15









输出




10
15
20
32
40
67
89
300
400




import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            int n = sc.nextInt();
            //nt arr[] = new int[n];
            TreeSet<Integer> set = new TreeSet<Integer>();
            for(int i = 0;i<n;i++){
                set.add(sc.nextInt());
            }
            Iterator<Integer> it = set.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
            
        }
        sc.close();
    }

}




PS:TreeSet,还有Set的遍历


4.


题目描述






•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 























输入描述:


连续输入字符串(输入2次,每个字符串长度小于100)


输出描述:


输出到长度为8的新字符串数组




示例1






输入




abc
123456789








输出




abc00000
12345678
90000000





import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            String str = sc.nextLine();
            if(str==null){
                return;
            }else{
                if(str.length()<8&&str.length()>0){
                    //System.out.println("<8");
                    int addLength = 8-str.length();
                    for(int i=0;i<addLength;i++){
                        str+="0";
                    }
                    System.out.println(str);
                }else if(str.length()==8){
                    System.out.println(str);
                }else{
                    //System.out.println(">8");
                    if(str.length()%8==0){
                        int part = str.length()/8;//分成的段数
                        for(int i=0;i<part;i++){
                            System.out.println(str.substring(i*8,i*8+8));
                        }
                    }else{
                        int part = str.length()/8;//分成的段数
                        int leave = str.length()%8;
                        for(int i=0;i<part;i++){
                            System.out.println(str.substring(i*8,i*8+8));
                        }
                        String tmp = str.substring(part*8);
                        for(int i=0;i<8-leave;i++){    
                            tmp+="0";
                        }
                        System.out.println(tmp);
                    }
                }
            }
        }
        sc.close();
    }

}
/****************思路二**********************/




import java.util.*;
/**
 * 思想：先补充8的整数，再删除
 * @author bee
 *
 */
public class Main {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            String str = sc.nextLine();
            if(str.length()%8!=0){
                int addlength=8-str.length()%8;
                for(int i=0;i<addlength;i++){
                    str+="0";
                }
            }
            StringBuilder sb = new StringBuilder(str);
            int part = str.length()/8;
            for(int i=0;i<part;i++){
                
                System.out.println(sb.substring(0, 8));
                sb.delete(0, 8);
            }
        }
        sc.close();
    }

}







 




PS:在分类讨论>8的情况的时候，少讨论了一种情况，然后一直报错通过90%；再次出现这种情况要注意


PS:在思路二中用到了delete方法，下面简单介绍StringBuilder的用法


一个可变的字符序列。该类提供与之兼容的API StringBuffer，但不保证同步。该类被设计为在StringBuffer单个线程使用字符串缓冲区的地方（作为一般情况）用作替换替换 。在可能的情况下，建议使用这个类， StringBuffer因为它在大多数实现中会更快。


上的主要操作StringBuilder是 append和insert方法，其被重载，以便接受任何类型的数据。每个都有效地将给定的数据转换为字符串，然后将该字符串的字符附加或插入字符串构建器。该 append方法总是在构建器的末尾添加这些字符; 该insert方法将字符添加到指定点。



例如，如果z引用当前内容为“ start” 的字符串构建器对象，则方法调用z.append("le")将导致字符串构建器包含“ startle”，而 z.insert(4, "le")将字符串构建器更改为包含“ starlet”。



一般来说，如果sb指的是a的一个实例StringBuilder，则sb.append(x)具有相同的效果 sb.insert(sb.length(), x)。



每个字符串构建器都具有容量。只要字符串构建器中包含的字符序列的长度不超过容量，则不需要分配新的内部缓冲区。如果内部缓冲区溢出，则会自动变大。



StringBuilder多线程使用的实例不安全。如果需要同步，那么建议StringBuffer使用它。



除非另有说明，否则将null参数传递给此类中的构造函数或方法将导致NullPointerException抛出。





PS:replace方法 ，是以开头为主的，不论任何方法，删除都一样；



5.



题目描述







写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）




输入描述:


输入一个十六进制的数值字符串。


输出描述:


输出该数值的十进制字符串。




示例1






输入




0xA








输出




10
















import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            String str = sc.nextLine();
            String sub = str.substring(2);
            int result = Integer.parseInt(sub, 16);//任何进制转10进制
            //Integer.toBinary().....十进制转其他进制
            System.out.println(result);
        }
        sc.close();
    }

}




import java.util.Scanner;
 
//十六进制转十进制
public class Change {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String oxs=new String(sc.nextLine());
            String s=oxs.substring(2);
             System.out.println(Change.change3(s));
        }
         
    }
     
    public static int change1(String s){
         int ten=Integer.parseInt(s, 16);
         return ten;
    }
     
    public static int change2(String s){
        char[]chars=s.toCharArray();
        int result=0;
        for(int i=0;i<chars.length;i++){
            int n;
            //字符可以直接参与算数运算，其值为ASSIC码
            if(chars[i]>='A'&&chars[i]<='F'){
                n=chars[i]-55;
            }else{
                n=chars[i]-48;
            }
            //理解数学公式
            result+=n*Math.pow(16, (chars.length-1-i));
        }
        return result;
    }
     
    public static int change3(String s){
        char[] chars=s.toCharArray();
        int result=0;
        for(int i=0;i<chars.length;i++){
            int n=0;
            switch (chars[i]){
            case 'A':
                n=10;
                break;
            case 'B':
                n=11;
                break;
            case 'C':
                n=12;
                break;
            case 'D':
                n=13;
                break;
            case 'E':
                n=14;
                break;
            case 'F':
                n=15;
                break;
            default:
            }
            result+=n*Math.pow(16, (chars.length-1-i));
        }
        return result;
    }
}







PS: 这里主要是


Math.pow(x,y) ; x的y次方




n*Math.pow(16, (chars.length-1-i))；每一位都进行一定的处理






6.


题目描述






功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）


最后一个数后面也要有空格


 


详细描述：



函数接口说明：


public String getResult(long ulDataInput)


输入参数：


long ulDataInput：输入的正整数


返回值：


String






















输入描述:


输入一个long型整数


输出描述:


按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
























import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            long num = sc.nextLong();//num 是全局，多次循环
            while(num!=1){
                 for(int i=2;i<=num;i++){
                     if(num%i==0){
                         num=num/i;
                         System.out.print(i+" ");
                         break;
                     }
                 } 
            }
        }
        sc.close();
    }
}




7.


题目描述






数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。




输入描述:


先输入键值对的个数
然后输入成对的index和value值，以空格隔开


输出描述:


输出合并后的键值对（多行）
























示例1






输入




4
0 1
0 2
1 2
3 4









输出




0 3
1 2
3 4













import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            int num = sc.nextInt();
            HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
            for(int i=0;i<num;i++){
                int key = sc.nextInt();
                int value =sc.nextInt();
                if(map.containsKey(key)){
                    map.put(key, map.get(key)+value);
                }else{
                    map.put(key, value);
                }
            }
            //遍历map
            Set<Integer> keys = map.keySet();
            Iterator<Integer> it = keys.iterator();
            while(it.hasNext()){
                int key = it.next();
                System.out.println(key+" "+map.get(key));
            }
        }
        sc.close();
    }
}




8.


题目描述






输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。




输入描述:


输入一个int型整数


输出描述:


按照从右向左的阅读顺序，返回一个不含重复数字的新的整数




示例1






输入




9876673









输出




37689




import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
/**
 * 用一个hashset过，再调转
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            StringBuilder sb =new StringBuilder();
            
            char[] arr = str.toCharArray();
        
            Set set =new LinkedHashSet();
            for(int i=arr.length-1;i>=0;i--){
                set.add(arr[i]);
            }
            Iterator it = set.iterator();
            while(it.hasNext()){
                System.out.print(it.next());
            }
            
        }
    }
}




 9.


题目描述






编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。




输入描述:


输入N个字符，字符在ACSII码范围内。


输出描述:


输出范围在(0~127)字符的个数。




示例1






输入




abc









输出




3




import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;

public class Main 
{
    
         //1.用set过滤，然后倒着打印出来
         public static void main(String[] args)
         {
                Scanner sc = new Scanner(System.in);
                while(sc.hasNext()){
                    String str = sc.nextLine();
                    char[] arr = str.toCharArray();
                    //获取 字符串中含有的不同字符的个数
                    System.out.println(getCount(arr));
                }
               sc.close();
         }

        private static int getCount(char[] arr) {
            // TODO Auto-generated method stub
            HashSet set = new HashSet();
            //获取 字符串中含有的不同字符的个数
            for(int i=0;i<arr.length;i++)
            {
                set.add(arr[i]);
            }
            return set.size();
        }
}
    




10.


题目描述




给定n个字符串，请对n个字符串按照字典序排列。


输入描述:


输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。


输出描述:


数据输出n行，输出结果为按照字典序排列的字符串。




示例1






输入




9
cap
to
cat
card
two
too
up
boat
boot








输出




boat
boot
cap
card
cat
to
too
two
up




import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
/**
 *
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        
        while(sc.hasNext()){
             int n = Integer.parseInt(sc.nextLine());///这个很重要，要是int就是少一个
            String [] arr=new String[n];
            //初始化数组
            for(int i=0;i<n;i++){
                 arr[i]=sc.nextLine();
            }
            Arrays.sort(arr);//排序
            for(int i=0;i<arr.length;i++){
                System.out.println(arr[i]);
            }
        }
    }
}









11.


题目描述








开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。



输入：



合法坐标为A(或者D或者W或者S) + 数字（两位以内）



坐标之间以;分隔。



非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。



下面是一个简单的例子 如：



A10;S20;W10;D30;X;A1A;B10A11;;A10;



处理过程：



起点（0,0）



+   A10   =  （-10,0）



+   S20   =  (-10,-20)



+   W10  =  (-10,-10)



+   D30  =  (20,-10)



+   x    =  无效



+   A1A   =  无效



+   B10A11   =  无效



+  一个空 不影响



+   A10  =  (10,-10)








import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            String str= sc.nextLine();
            String[] subs = str.split(";");
            //判断字符
            int x = 0,y=0;
            for(int i=0;i<subs.length;i++){
                if(subs[i].matches("[WASD][0-9]{1,2}")){
                    //System.out.println("ok"+subs[i]);
                    String direction = subs[i].substring(0, 1);
                    int value = Integer.parseInt(subs[i].substring(1));
                    switch (direction) {
                    case "W":
                        y+=value;
                        break;
                    case "S":
                        y-=value;
                        break;
                    case "A":
                        x-=value;
                        break;
                    case "D":
                        x+=value;
                        break;
                    default:
                        break;
                    }
                }else{
                    //System.out.println("lose"+subs[i]);
                }
            }
            System.out.println(x+","+y);
        }
        sc.close();
    }
}

PS:这个题目这次写的很快，有一个 很重要就是正则 的应用




12.


题目描述






开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。



处理： 



1、 记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加；



2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；



3、 输入的文件可能带路径，记录文件名称不能带路径。





输入描述:


一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。


输出描述:


将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开，如：




示例1






输入




E:V1R2productfpgadrive.c   1325









输出




fpgadrive.c 1325 1




//需要排序故使用HashMap，根据题意是要循环输出，而且提交一次会有测试用例提示，需要按照输入顺序输出，故使用LinkedHashMap
//在输出的时候，题目的意思是循环八个，但问题是必须记录全部错误个数，否则刚记录完后弹出了，错误数就对不上了，跟操作系统里的缺页有那么点相似。
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
 
public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Map<String, Integer> map=new LinkedHashMap<String, Integer>();
        while(sc.hasNext()){
            String str=sc.next();
            int linenum=sc.nextInt();
            String[] arr=str.split("\\");  //根据切割
            String s=arr[arr.length-1];
            if(s.length()>16)  //截取
                s=s.substring(s.length()-16);
            String key=s+" "+linenum;
            int value=1;
            if(map.containsKey(key))
                map.put(key, map.get(key)+1);
            else {
                map.put(key, value);
            }
        }
        int count=0;
        for(String string:map.keySet()){
            count++;
            if(count>(map.keySet().size()-8)) //输出最后八个记录
                System.out.println(string+" "+map.get(string));
        }
    }
}




13.


题目描述






密码要求:



1.长度超过8位


2.包括大小写字母.数字.其它符号,以上四种至少三种


3.不能有相同长度超2的子串重复



说明:长度超过2的子串





输入描述:


一组或多组长度超过2的子符串。每组占一行


输出描述:


如果符合要求输出：OK，否则输出NG




示例1






输入




021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000









输出




OK
NG
NG
OK




/*题目描述
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
 
说明:长度超过2的子串

输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG

输入例子:
021Abc9000
021Abc9Abc1
021ABC9000
021$bc9000

输出例子:
OK
NG
NG
OK*/
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class Main{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String psw=sc.nextLine();
            if(checkLength(psw)&&checkCharKinds1(psw)&&checkCharRepeat(psw))
            {
                System.out.println("OK");
            }
            else
            {
                System.out.println("NG");
            }
        }
    }

    private static boolean checkCharRepeat(String psw) {
        for(int i=0;i<psw.length()-3;i++)//因为前三个不用比较
        {
            if(psw.substring(i+3).contains(psw.substring(i, i+3)))
            {
                return false;
            }
        }
        return true;
    }
    
////2.包括大小写字母.数字.其它符号,以上四种至少三种
    private static boolean checkCharKinds1(String psw) {
        String []regex={"[a-z]","[A-Z]","[0-9]","[^a-zA-Z0-9]"};
        int count = 0;
        for(int i=0;i<regex.length;i++)
        {
            Pattern pattern = Pattern.compile(regex[i]);//这个pattern就是针对正则
            Matcher matcher = pattern.matcher(psw);//匹配数据
            if(matcher.find())
            {
                count++;
            }
        }
        return count>=3?true:false;
    }
    //// 2.包括大小写字母.数字.其它符号,以上四种至少三种
    private static boolean checkCharKinds(String psw) {
        char[] arr = psw.toCharArray();
        int digit=0,lowercase=0,uppercase=0,others=0;
        for(int i=0;i<arr.length;i++)
        {
            if(arr[i]>'a'&&arr[i]<'z')
            {
                lowercase =1;
                continue;
            }
            else if(arr[i]>'A'&&arr[i]<'Z')
            {
                uppercase=1;
                continue;
            }
            else if(arr[i]>'1'&&arr[i]<'9')
            {
                digit=1;
                continue;
            }
            else 
            {
                others=1;
                continue;
            }
        }
        int total = digit+lowercase+uppercase+others;
        return total>=3?true:false;
    }

    private static boolean checkLength(String psw) {
        if(psw==null||psw.length()<=8)
        {
            return false;
        }
        return true;
    }
}




 14.          这个不会


题目描述






王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：






主件
附件




电脑
打印机，扫描仪




书柜
图书




书桌
台灯，文具




工作椅
无






如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第 5 等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。


    设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：


v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）


    请你帮助王强设计一个满足要求的购物单。






输入描述:


输入的第 1 行，为两个正整数，用一个空格隔开：N m


（其中 N （ <32000 ）表示总钱数， m （ <60 ）为希望购买物品的个数。）



从第 2 行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q



（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）




输出描述:


 输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（ <200000 ）。




示例1






输入




1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0









输出




2200




链接：https://www.nowcoder.com/questionTerminal/f9c6f980eeec43ef85be20755ddbeaf4
来源：牛客网

import java.util.Scanner;
 
//加了限制条件的背包问题
public class Main {
    public static int getMaxValue(int[] val, int[] weight, int[] q, int n, int w) {
        int[][] dp = new int[n + 1][w + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= w; j++) {
                if (q[i-1] == 0) {  // 主件
                    if (weight[i - 1] <= j) // 用j这么多钱去买 i 件商品 可以获得最大价值 
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j- weight[i - 1]]+ val[i - 1]);
                } 
                else { //附件
                    if (weight[i - 1] + weight[q[i - 1]] <= j) //附件的话 加上主件一起算
                        dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j- weight[i - 1]]+ val[i - 1]);
                }
            }
        }
        return dp[n][w];
    }
 
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        while (input.hasNextInt()) {
            int n = input.nextInt(); // 总钱数
            int m = input.nextInt(); // 商品个数
            int[] p = new int[m];
            int[] v = new int[m];
            int[] q = new int[m];
            for (int i = 0; i < m; i++) {
                p[i] = input.nextInt();        // 价格
                v[i] = input.nextInt() * p[i]; // 价值
                q[i] = input.nextInt();        // 主or附件
            }
            System.out.println(getMaxValue(v, p, q, m, n));
        }
    }
}




15.


题目描述






密码是我们生活中非常重要的东东，我们的那么一点不能说的秘密就全靠它了。哇哈哈. 接下来渊子要在密码之上再加一套密码，虽然简单但也安全。



假设渊子原来一个BBS上的密码为zvbo9441987,为了方便记忆，他通过一种算法把这个密码变换成YUANzhi1987，这个密码是他的名字和出生年份，怎么忘都忘不了，而且可以明目张胆地放在显眼的地方而不被别人知道真正的密码。



他是这么变换的，大家都知道手机上的字母： 1--1， abc--2, def--3, ghi--4, jkl--5, mno--6, pqrs--7, tuv--8 wxyz--9, 0--0,就这么简单，渊子把密码中出现的小写字母都变成对应的数字，数字和其他的符号都不做变换，



声明：密码中没有空格，而密码中出现的大写字母则变成小写之后往后移一位，如：X，先变成小写，再往后移一位，不就是y了嘛，简单吧。记住，z往后移是a哦。





输入描述:


输入包括多个测试数据。输入是一个明文，密码长度不超过100个字符，输入直到文件结尾


输出描述:


输出渊子真正的密文




示例1






输入




YUANzhi1987








输出




zvbo9441987




import java.util.*;

public class Main {
    
    public static void main(String [] args){
        //System.out.println("hello world");
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            String result ="";
            for(int i=0;i<str.length();i++){
                if(Character.isLowerCase(str.charAt(i))){
                    result+=change1(str.charAt(i));
                }else if(Character.isUpperCase(str.charAt(i))){
                    result+=change2(str.charAt(i));
                }else if(Character.isDigit(str.charAt(i))){
                    result+=str.charAt(i);
                }
            }
            System.out.println(result);
        }
        sc.close();
    }
    public static String change2(char c){
        char c1 = Character.toLowerCase(c);//大写变小写
        if(c1=='z'){
            c1 = 'a';
        }else{
            c1 = (char) (c1+1);
        }
        return c1+"";
    }
    public static int change1(char c){
        int result = 0;
        switch(c){
         case 'a':
         case 'b':
         case 'c':
             result = 2;
             break;
         case 'd':
         case 'e':
         case 'f':
             result = 3;
             break;
         case 'g':
         case 'h':
         case 'i':
             result = 4;
             break;
         case 'j':
         case 'k':
         case 'l':
             result = 5;
             break;
         case 'm':
         case 'n':
         case 'o':
             result = 6;
             break;
         case 'p':
         case 'q':
         case 'r':
         case 's':
             result = 7;
             break;
         case 't':
         case 'u':
         case 'v':
             result = 8;
             break;
         case 'w':
         case 'x':
         case 'y':
         case 'z':
             result = 9;
             break;
         default:
             break;
        }
        return result;
    }
}
//思路2：这种思路简单，但是比较写密码的时候要细心




import java.util.*;

public class Main {
    
    public static void main(String [] args){
        //System.out.println("hello world");
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            String result ="";
            String str1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz1234567890";
            String str2 = "bcdefghijklmnopqrstuvwxyza222333444555666777788899991234567890";
            for(int i=0;i<str.length();i++){
                for(int j=0;j<str1.length();j++){
                    if((str.charAt(i)+"").equals(str1.charAt(j)+"")){
                        result+=str2.charAt(j);
                    }
                }
            }
            System.out.println(result);
        }
        sc.close();
    }
    
}

















16.


题目描述








实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。 




输入描述:


字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。


输出描述:


删除字符串中出现次数最少的字符后的字符串。




示例1






输入




abcdd








输出




dd














import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
         while(sc.hasNext())//键相加+
         {
            
             String str = sc.nextLine();
             Map<Character, Integer> map = new LinkedHashMap<>();
             for(int i=0;i<str.length();i++){
                 if(map.containsKey(str.charAt(i))){//包含值
                     map.put(str.charAt(i), map.get(str.charAt(i))+1);
                 }else{//没包含
                     map.put(str.charAt(i), 1);
                 }
             }
             Collection<Integer> values = map.values();
             Integer index = Collections.min(values);
             StringBuffer sb = new StringBuffer();
             for(int i=0;i<str.length();i++){
                 if(map.get(str.charAt(i))!=index){//如果map中没有包含最小值，就删除
                     sb.append(str.charAt(i));
                 }
             }
             System.out.println(sb.toString());
        
         }
    }

    


}




PS：自己的错误答案，离答案差一点，但是还是不对
import java.util.*;

public class Main {
    
    public static void main(String [] args){
        //System.out.println("hello world");
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            LinkedHashMap<Character,Integer> map = new LinkedHashMap<Character,Integer>(); 
            for(int i=0;i<str.length();i++){
                if(map.containsKey(str.charAt(i))){
                    map.put(str.charAt(i), 1+map.get(str.charAt(i)));
                }else{
                    map.put(str.charAt(i), 1);
                }
            }
            //Collection<Integer> values = map.values();
            int min = Collections.min(map.values());
            System.out.println("min:"+min);
            ArrayList<Character> ids = new ArrayList<Character>();
            //根据值得到健
            Set<Character> keys = map.keySet();
            Iterator<Character> it = keys.iterator();
            while(it.hasNext()){//根据值拿到健
                char key = it.next();
                int value = map.get(key);
                if(value == min){
                    ids.add(key);
                    //map.remove(key);
                }
            }
            for(int i=0;i<ids.size();i++){
                map.remove(ids.get(i));
            }
            //System.out.println(map.size());
            Set<Character> keys1 = map.keySet();
            Iterator<Character> it1 = keys1.iterator();
            String result = "";
            while(it1.hasNext()){
                char key = it1.next();//注意打印的时候只能这样，书写
                int value = map.get(key);
                //System.out.println(key+" "+value);
                for(int i=0;i<value;i++){
                    result+=key;
                }
            }
            System.out.println(result);
        }
        sc.close();
    }
    
}





PS:map遍历的时候，注意按这样的格式写




Set<Character> keys1 = map.keySet();
            Iterator<Character> it1 = keys1.iterator();
            String result = "";
            while(it1.hasNext()){
                char key = it1.next();//注意打印的时候只能这样，书写
                int value = map.get(key);
                System.out.println(key+" "+value);
                
            }







 




17.


题目描述






编写一个程序，将输入字符串中的字符按如下规则排序。


规则 1 ：英文字母从 A 到 Z 排列，不区分大小写。


       如，输入： Type   输出： epTy


规则 2 ：同一个英文字母的大小写同时存在时，按照输入顺序排列。


     如，输入： BabA   输出： aABb


规则 3 ：非英文字母的其它字符保持原来的位置。


     如，输入： By?e   输出： Be?y


样例：


    输入：


   A Famous Saying: Much Ado About Nothing(2012/8).


    输出：


   A  aaAAbc   dFgghh :  iimM   nNn  oooos   Sttuuuy  (2012/8).





输入描述:



输出描述:





示例1






输入




A Famous Saying: Much Ado About Nothing (2012/8).









输出




A aaAAbc dFgghh: iimM nNn oooos Sttuuuy (2012/8).















import java.util.*;

public class Main {
    
    public static void main(String [] args){
        //System.out.println("hello world");
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            System.out.println(getResult(str));
        }
        sc.close();
    }
    
    public static char[] getResult(String str){
        //1.先把所有的字符装起来，
        //2.原来的不是字符的留下来
        char[] arr = str.toCharArray();
        List<Character> chars = new ArrayList<Character>();
        for(int i=0;i<str.length();i++){
            if(Character.isLetter(str.charAt(i))){
                chars.add(str.charAt(i));
            }
        }
        Collections.sort(chars, new Comparator<Character>(){

            @Override
            public int compare(Character o1, Character o2) {
                // 解决了a-z，忽略大小写；按输入顺序排列
                return Character.toLowerCase(o1)-Character.toLowerCase(o2);
            }
            
        });
        int count =0;
        for(int i=0;i<arr.length;i++){
            if(Character.isLetter(arr[i])){//保留字符，
                arr[i] = chars.get(count);/////////////////这个思想很重要；用一个东西先保存待修改的东西，然后再去修改园原来的东西
                count++;
            }
        }
        return arr;
    
    }
}




18.


题目描述






对字符串中的所有单词进行倒排。


说明：


1、每个单词是以26个大写或小写英文字母构成；


2、非构成单词的字符均视为单词间隔符；


3、要求倒排后的单词间隔符以一个空格表示；如果原字符串中相邻单词间有多个间隔符时，倒排转换后也只允许出现一个空格间隔符；


4、每个单词最长20个字母；




输入描述:


输入一行以空格来分隔的句子


输出描述:


输出句子的逆序




示例1






输入




I am a student








输出




student a am I




import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.nextLine();
      String []strArray=str.split("[^a-zA-Z]+");       //以非字符进行分割
      for(int i=strArray.length-1;i>=2;i--){
        System.out.print(strArray[i]+' ');
      }
      if(strArray[0].length()==0)//如果字符串数组的第一个元素是空串，那么下标为1的元素就是最后一个要输出的元素，末尾不要再加空格
        System.out.println(strArray[1]);
      else
        System.out.println(strArray[1]+' '+strArray[0]);
    }
  }
}




 19.


题目描述






输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。



    /**
     * 统计出英文字母字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getEnglishCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出空格字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 空格的个数
     */
    public static int getBlankCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出数字字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getNumberCharCount(String str)
    {
        return 0;
    }
    
    /**
     * 统计出其它字符的个数。
     * 
     * @param str 需要输入的字符串
     * @return 英文字母的个数
     */
    public static int getOtherCharCount(String str)
    {
        return 0;
    }





















输入描述:


输入一行字符串，可以有空格


输出描述:


统计其中英文字符，空格字符，数字字符，其他字符的个数




示例1






输入




1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\/;p0-=\][









输出




26
3
10
12














import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            String str= sc.nextLine();
            int wordCount = 0,spaceCount = 0,digitCount = 0,otherCount = 0;
            for(int i=0;i<str.length();i++){
                if(Character.isLetter(str.charAt(i))){
                    wordCount++;
                }else if(Character.isWhitespace(str.charAt(i))){//注意空白字符使用这个，不要再使用isSpace()了
                    spaceCount++;
                }else if(Character.isDigit(str.charAt(i))){
                    digitCount++;
                }else{
                    otherCount++;
                }
            }
            System.out.println(wordCount);
            System.out.println(spaceCount);
            System.out.println(digitCount);
            System.out.println(otherCount);
        }
        sc.close();
    }
    

}




20.题目描述






有一种技巧可以对数据进行加密，它使用一个单词作为它的密匙。下面是它的工作原理：首先，选择一个单词作为密匙，如TRAILBLAZERS。如果单词中包含有重复的字母，只保留第1个，其余几个丢弃。现在，修改过的那个单词属于字母表的下面，如下所示：


A B C D E F G H I J K L M N O P Q R S T U V W X Y Z


T R A I L B Z E S C D F G H J K M N O P Q U V W X Y


上面其他用字母表中剩余的字母填充完整。在对信息进行加密时，信息中的每个字母被固定于顶上那行，并用下面那行的对应字母一一取代原文的字母(字母字符的大小写状态应该保留)。因此，使用这个密匙，Attack AT DAWN(黎明时攻击)就会被加密为Tpptad TP ITVH。


请实现下述接口，通过指定的密匙和明文得到密文。


详细描述：


接口说明


原型：


voidencrypt(char * key,char * data,char * encrypt);


输入参数：


char * key：密匙


char * data：明文


输出参数：


char * encrypt：密文


返回值：


void






输入描述:


先输入key和要加密的字符串


输出描述:


返回加密后的字符串




示例1






输入




nihao
ni









输出




le














PS: 这不是正确答案
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            String key= sc.nextLine();
            String name = sc.nextLine();
            System.out.println(name.length());
            String str1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
            char[] arr = str1.toCharArray();
            LinkedHashSet<Character> set = new LinkedHashSet<Character>();
            for(int i=0;i<key.length();i++){
                set.add(Character.toUpperCase(key.charAt(i)));
            }
            Iterator<Character> it = set.iterator();
            int num = 0;
            while(it.hasNext()){
                Character value = it.next();
                //System.out.println(value);    //这里有个思路是学习上面的，这是
                for(int i=0;i<arr.length;i++){
                    if(value == arr[i]){
                        char tmp = arr[i];
                        arr[i] = arr[num];
                        arr[num] = tmp;
                    }    
                }
                num++;
                //System.out.println(value);
            }
            String str2 = String.valueOf(arr);
            char[] lastArr = str2.substring(set.size()).toCharArray();
            Arrays.sort(lastArr);
            String str3 = str2.substring(0,set.size())+String.valueOf(lastArr);
            System.out.println(str3);
            System.out.println(str1);
            String result = "";
            for(int i=0;i<name.length();i++){
                for(int j=0;i<str1.length();j++){
                    if(!Character.isLetter(name.charAt(i))){
                        result += name.charAt(i);
                        break;
                    }else{
                        if(Character.toUpperCase(name.charAt(i))==str1.charAt(j)){
                            if(Character.isUpperCase(name.charAt(i))){
                                result+=str3.charAt(j);
                                break;
                            }else{
                                result+=Character.toLowerCase(str3.charAt(j));
                                break;
                            }
                        }
                    }
                    
                }
            }
            System.out.println(result);
            System.out.println(result.length());
            //System.out.println(tmp1);*/
            //System.out.println(str1.length());
        }
        sc.close();
    }
    

}




21.



题目描述






有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？



    /**
     * 统计出兔子总数。
     * 
     * @param monthCount 第几个月
     * @return 兔子总数
     */
    public static int getTotalCount(int monthCount)
    {
        return 0;
    }





import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            int n = sc.nextInt();
            System.out.println(getResult(n));
        }
        sc.close();
    }

    private static int getResult(int n) {
        if(n==1||n==2){
            return 1;
        }
        return getResult(n-1)+getResult(n-2);
    }
    

}




题目描述






Lily上课时使用字母数字图片教小朋友们学习英语单词，每次都需要把这些图片按照大小（ASCII码值从小到大）排列收好。请大家给Lily帮忙，通过C语言解决。






输入描述:


Lily使用的图片包括"A"到"Z"、"a"到"z"、"0"到"9"。输入字母或数字个数不超过1024。


输出描述:


Lily的所有图片按照从小到大的顺序输出




示例1






输入




Ihave1nose2hands10fingers









输出




0112Iaadeeefghhinnnorsssv




//我觉得这是原理性的东西
import java.util.Scanner;


public class Main {
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        while(sc.hasNext()){
            String str = sc.nextLine();
            byte[] arr = str.getBytes();
               /* AdadDDd123 
            65,100,97,100,68,68,100,49,50,51,*/
            for(int i=0;i<arr.length;i++)//控制的仑数
            {
                for(int j=i+1;j<arr.length;j++)
                {
                    if(arr[i]>arr[j])
                    {
                        byte temp=arr[j];
                        arr[j]=arr[i];
                        arr[i]= temp;
                    }
                }
            }
            String str2 = new String(arr);
              System.out.println(str2);
        
            
        }
    }

}




链接：https://www.nowcoder.com/questionTerminal/2de4127fda5e46858aa85d254af43941
来源：牛客网

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();
            char[] cs = str.toCharArray();
            Arrays.sort(cs);
            System.out.println(cs);
        }
        sc.close();
    }     
}







 


















输入描述:


输入int型表示month


输出描述:


输出兔子总数int型




示例1






输入




9








输出




34




import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            int n = sc.nextInt();
            System.out.println(getResult(n));
        }
        sc.close();
    }

    private static int getResult(int n) {
        if(n==1||n==2){
            return 1;
        }
        return getResult(n-1)+getResult(n-2);
    }
    

}




题目描述






请实现如下接口


     public   static   int findNumberOf1( int num)


    {


         /*  请实现  */


         return  0;


    } 譬如：输入5 ，5的二进制为101，输出2



涉及知识点：




输入描述:


输入一个整数


输出描述:


计算整数二进制中1的个数




示例1






输入




5









输出




2




import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
/**
 * 
 * @author bee
 *
 */
public class Main{
    
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            int n = sc.nextInt();
            String binaryString = Integer.toBinaryString(n);
            System.out.println(findNumberOf1(binaryString));
        }
        sc.close();
    }
  
    
   public static int findNumberOf1(String num)
    {
       int count = 0;
       for(int i =0 ;i<num.length();i++)
       {
           if(num.charAt(i)=='1')
           {
               count++;
           }
       }
       return count;
    
    }


    
}




题目描述






请设计一个算法完成两个超长正整数的加法。



接口说明



 


 /*
 请设计一个算法完成两个超长正整数的加法。
 输入参数：
 String addend：加数
 String augend：被加数
 返回值：加法结果
 */


 public String AddLongInteger(String addend, String augend)
 {
     /*在这里实现功能*/
  


  return null;     
 }



 





















输入描述:


输入两个字符串数字


输出描述:


输出相加后的结果，string型




示例1






输入




99999999999999999999999999999999999999999999999999
1









输出




100000000000000000000000000000000000000000000000000




import java.math.BigInteger;
import java.util.*;

public class Main
{
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext())
        {
            System.out.println(AddLongInteger(sc.nextLine(), sc.nextLine()));
        }
        sc.close();
    }

    public static String AddLongInteger(String num1, String num2)
     {
         /*在这里实现功能*/
        //long result=Long.parseLong(num1)+Long.parseLong(num2);
        BigInteger a = new BigInteger(num1);
        BigInteger b = new BigInteger(num2);
        BigInteger result = a.add(b);
        return String.valueOf(result);     
     }

    
}






    




题目描述






功能: 求一个byte数字对应的二进制数字中1的最大连续数，例如3的二进制为00000011，最大连续2个1
    
输入: 一个byte型的数字
    
输出: 无
     
返回: 对应的二进制数字中1的最大连续数



















输入描述:


输入一个byte数字


输出描述:


输出转成二进制之后连续1的个数




示例1






输入




3









输出




2














import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);    
        while(sc.hasNext()){
            int n = sc.nextInt();
            String binaryString = Integer.toBinaryString(n);
            //System.out.println(binaryString);
            int addLength = 8-binaryString.length();
            String tmp0 = "";
            for(int i=0;i<addLength;i++){
                tmp0+="0";
            }
            String result = tmp0+binaryString;
        //    System.out.println(result);
            String[] sub = result.split("[0]+");//关键是对字符串的分类，正则
            
            ArrayList<Integer> list = new ArrayList<Integer>();
            for(int i=0;i<sub.length;i++){
                
                if(sub[i].contains("1")){
                    list.add(sub[i].length());
                }
            }
            System.out.println(Collections.max(list));
        }
        sc.close();
    }

    
}





题目描述






找出字符串中第一个只出现一次的字符





输入描述:


输入一个非空字符串


输出描述:


输出第一个只出现一次的字符，如果不存在输出-1




示例1






输入




asdfasdfo









输出




o














PS:这是牛客的思想很好
//通过判断一个字符在字符串中的第一个索引和最后一个索引是否相同
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            String str = in.nextLine();
            char[] chs = str.toCharArray();
            String result = "-1";
            for(int i = 0; i < chs.length; i++){ 
                if(str.indexOf(chs[i]) == str.lastIndexOf(chs[i])){             //这个需要掌握
                    result = chs[i] + "";
                    break;
                }
            }
            System.out.println(result);
        }
        in.close();
    }
}




//1.按照顺序放入map中，然后遍历，
   2.如果value==1；放入列表中
   3.找出第一个等于1的
import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
      String str=sc.nextLine();
      LinkedHashMap<Character,Integer> set = new  LinkedHashMap<Character,Integer>();
      for(int i=0;i<str.length();i++){
          if(set.containsKey(str.charAt(i))){
              set.put(str.charAt(i), 1+set.get(str.charAt(i)));
          }else{
              set.put(str.charAt(i), 1);
          }
      }
      ArrayList<String> list = new ArrayList<String>();
      Set<Character> set2 = set.keySet();
      Iterator<Character> it = set2.iterator();
      while(it.hasNext()){
          char key = it.next();
          int value = set.get(key);
          if(value==1){
              list.add(key+"");
          }
      }
      if(list.size()==0){
          System.out.println("-1"); 
      }else{
          System.out.println(list.get(0));
      }
      
    }
  }
}







 










输入n个整数，输出其中最小的k个。


详细描述：


接口说明


原型：


bool GetMinK(unsignedint uiInputNum, int * pInputArray, unsignedint uiK, int * pOutputArray);


输入参数：


     unsignedint uiInputNum //输入整数个数


int * pInputArray  //输入整数数组


unsignedint uiK   //需输出uiK个整数


输出参数（指针指向的内存区域保证有效）：


    int * pOutputArray //最小的uiK个整数


返回值：


        false 异常失败


          true  输出成功








输入描述:




输入说明 
1 输入两个整数 
2 输入一个整数数组




输出描述:




输出一个整数数组






示例1






输入




5 2
1 3 5 7 2









输出




1 2












import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
        int n = sc.nextInt();
        int need = sc.nextInt();
        int arr[] = new int[n];
        ArrayList<Integer> list = new ArrayList<Integer>();
        for(int i=0;i<n;i++){
            arr[i] = sc.nextInt();
            list.add(arr[i]);
        }
        Collections.sort(list);
        String result = "";
        for(int i=0;i<need;i++){
            if(i!=need-1){
                //System.out.print(list.get(i)+" ");
                result +=list.get(i)+" ";
            }else{
                //System.out.print(list.get(i));
                result +=list.get(i);
            }
            
        }
        System.out.println(result);
    }
  }
}




题目描述






题目标题：


计算两个字符串的最大公共字串的长度，字符不区分大小写


详细描述：


接口说明


原型：


int getCommonStrLength(char * pFirstStr, char * pSecondStr);


输入参数：


     char * pFirstStr //第一个字符串


     char * pSecondStr//第二个字符串





输入描述:


输入两个字符串


输出描述:


输出一个整数




示例1






输入




asdfas werasdfaswer








输出




6














import java.util.*;
public class Main{
  public static void main(String args[]){
    Scanner sc=new Scanner(System.in);
    while(sc.hasNext()){
        ArrayList<String> list = new ArrayList<String>();
        String str = sc.nextLine();
        String content = sc.nextLine();
        /*
         * 0   截取：0 6    长度 6
         * 1   截取：0 5；1 6    长度5
         * 2   截取：0 4 ；1 5 ； 2  6长度4
         * 3   截取：0 6    长度3
         * 4   截取：0 6    长度2
         * 5   截取：0 6    长度1
         * */
        for(int i=str.length();i>0;i--){
            for(int j = 0;j<str.length()-i+1;j++){
                String substring = str.substring(j, j+i);
                if(content.contains(substring)){ 
                    list.add(substring); 
                    //System.out.println(substring);
                    break;
                }
            }
        }
        System.out.println(list.get(0).length());
    }
  }
}




 
来源：牛客网



Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：


如22：twenty two，123：one hundred and twenty three。



说明：


数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写；


输出格式为twenty two；


非法数据请返回“error”；


关键字提示：and，billion，million，thousand，hundred。



方法原型：public static String parse(long num) 




import java.util.Scanner;
 
public class Main{
 
    public static String[] num1 = {"zero", "one", "two", "three", "four"
                        , "five", "six", "seven", "eight", "nine"};
    public static String[] num2 = {"ten","eleven","twelve","thirteen","fourteen"
                    ,"fifteen","sixteen","seventeen","eighteen","nighteen"};
    public static String[] num3 = {"twenty","thirty","forty","fifty"
                    ,"sixty","seventy","eighty","ninety"};
     
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long num = 0;
        while(sc.hasNext()){
            num = sc.nextLong();
            System.out.println(parse(num));
        }
    }
     
    public static String parse(long num){
        if(num < 0 )
            return "error";
        StringBuilder sb = new StringBuilder();
        long billion = num / 1000000000;
                //十亿部分
        if(billion != 0){
            sb.append(thranslate(billion) + " billion ");//翻译十亿部分
        }
        num = num % 1000000000;
                //百万部分
        long million = num / 1000000;
        if(million != 0){
            sb.append(thranslate(million) + " million ");//翻译百万部分
        }
        num = num % 1000000;
                //千部分
        long thousand = num / 1000;
        if(thousand != 0){
            sb.append(thranslate(thousand) + " thousand ");//翻译千部分
        }
                //百部分
        num = num % 1000;
        if(num != 0){
            sb.append(thranslate(num));//翻译百部分
        }
        return sb.toString().trim();//别忘了去除字符串后面的空格
    }
     
        //翻译方法
    public static String thranslate(long num){
        StringBuilder sb = new StringBuilder();
                //百位处理
        long h = num / 100;
        if(h != 0){
                        //若不为0，翻译，否则不翻译
            sb.append(num1[(int) h] + " hundred");
        }
        num = num % 100;
                //十位部分
        long k = num / 10;
        if(k != 0){
            if(h != 0)//如果有百位别忘了加and
                sb.append(" and ");
            if(k == 1){//若十位为1，连同个位一起翻译
                long t = num % 10;
                sb.append(num2[(int)t]);
            }
            else{//否则，十位和个位分别单独翻译
                sb.append(num3[(int)k - 2] + " ");
                if(num % 10 != 0)
                    sb.append(num1[(int)(num % 10)]);
            }
        }
        else if(num % 10 != 0){//如果没有十位部分，直接翻译个位部分
            if(h != 0)
                sb.append(" and ");
            sb.append(num1[(int)(num % 10)]);
        }
        return sb.toString();//别忘了去除字符串后面的空格 }
 
}
}




























































































































































        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/bee-home/p/7366134.html