java简单算法题

---

1. 计算字符串最后一个单词的长度

import java.util.Scanner;

/**
 * @Auther  liaoping
 *
 * 计算字符串最后一个单词的长度
 *
 */
/*
next()方法读取到空白符就结束l；
nextLine()读取到回车结束也就是“\r”；

而“\s+”则表示匹配任意多个上面的字符。另因为反斜杠在Java里是转义字符，所以在Java里，我们要这么用“\\s+”
[\s]表示，只要出现空白就匹配
*/
public class demo {
    public static void main(String[] args) {
        Scanner scaner = new Scanner(System.in);
        String str=scaner.nextLine();
        String s[]=str.split("\\s+");
        int length=s[s.length-1].length();
        System.out.println(length);
    }
}

2. 计算字符的个数

import java.util.Scanner;

/**
 * @Auther  liaoping
 * 写出一个程序，接受一个由字母、数字和空格组成的字符串，和一个字母。
 * 然后输出输入字符串中，该字母的出现次数。不区分大小写。字符串长度小于500
 */
public class demo2 {
    public static void main(String[] args) {
        System.out.println("请输入一串字母");
        Scanner scanner = new Scanner(System.in);
        String first=scanner.next();
        System.out.println("请输入要测试的字母");
        Scanner scanner1 = new Scanner(System.in);
        String index=scanner1.next();
            char[] firstChars=first.toCharArray();
            int num=0;
            for(int i=0;i<firstChars.length;i++){
                if (String.valueOf(firstChars[i]).equalsIgnoreCase(index)){
                    num++;
                }
            }
            System.out.println(num);


    }
}

3. 字符串分隔

import java.util.Scanner;

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

/**
 *  public String substring(int beginIndex)
 返回一个新字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。
 */

public class demo04 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);

        while(scanner.hasNext()){
            String str =scanner.nextLine();
            StringBuffer sb = new StringBuffer();
            sb.append(str);
            int size=str.length();
            int addzero=8-size%8;
            while(addzero>0 && addzero<8){
                sb.append("0");
                addzero--;
            }
            String str1=sb.toString();
            while (str1.length()>0){
                System.out.println(str1.substring(0,8));
                str1=str1.substring(8);
            }
        }
    }
}

4. 进制转换

import java.util.Scanner;

/**
 * @Auther  liaoping
 * 
 * 写出一个程序，接受一个十六进制的数，输出该数值的十进制表示
 */
public class demo05 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            String str=scanner.nextLine();
            System.out.println(Integer.valueOf(str.substring(2),16).toString());
        }
    }
}

5. 质数因子

import java.util.Scanner;

/**
 * 
 * @Auther  liaoping
 * 
 * 描述

 功能:输入一个正整数，按照从小到大的顺序输出它的所有质因子（重复的也要列举）（如180的质因子为2 2 3 3 5 ）
 最后一个数后面也要有空格

 输入描述：

 输入一个long型整数
 输出描述：

 按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
 */
public class demo06 {
    public static void main(String[] args) {
        //1.定义一个输入函数，获取输入的值
        Scanner scanner = new Scanner(System.in);
        long num = scanner.nextLong();
        //2.for循坏定义质数因子值的范围
        for (long i = 2; i <= num; ++i) {
            while (num % i == 0) {
                System.out.print(i + " ");
                num /= i;
            }
        }
        System.out.println();
    }
}

6. 取近似值

import java.util.Scanner;

/**
 * @Auther  liaoping
 *
 * 描述

 写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。
 输入描述：

 输入一个正浮点数值
 输出描述：

 输出该数值的近似整数值
 *
 */


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

        Scanner in = new Scanner(System.in);
        //输入参数
        double a = in.nextDouble();
        //取整数部分
        int b = (int)a;
        //判断
        if((a - b) >= 0.5){
            b=(int)(a + 0.5);
        }
        System.out.println(b);

    }

    public static void paixun(){
        int arr[]={6,3,5,4,9,7,3,1,8};

        /*  选择排序算法
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                int temp=0;
                if(arr[i]>arr[j]){
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }*/
        /*
         * 冒泡排序算法
         *
         * */
        for (int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
                int temp=0;
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

        for(int s :arr){
            System.out.print(s+",");
        }
    }
}

7. 合并表记录

import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;

/**
 * 
 *  @Auther  liaoping
 * 描述

 数据表记录包含表索引和数值（int范围的正整数），请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。
 输入描述：

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

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

 示例：
 4
 0 1
 0 2
 1 2
 3 4

 0 3
 1 2
 3 4

 */
public class demo08 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        while (sc.hasNext()){
            int next = sc.nextInt();
            TreeMap<Integer,Integer> map = new TreeMap<>();
            for (int i = 0; i < next; 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);
                }
            }
            for (Map.Entry<Integer, Integer> integerIntegerEntry : map.entrySet()) {
                System.out.println(integerIntegerEntry.getKey()+" "+integerIntegerEntry.getValue());
            }
        }
    }
}

8. 提取不重复的整数

import java.util.Scanner;

/**
 * @Auther  liaoping
 * 
 * 描述
 输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
 保证输入的整数最后一位不是0。
 输入描述：

 输入一个int型整数
 输出描述：

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

 9876673

 输出：

 37689
 */
public class demo09 {
    public static void main(String[] args) {
        /*Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        char[] chars= (num+"").toCharArray();
        String str ="";
        for(int i= chars.length-1; i>= 0;i--){
            if(!str.contains(chars[i]+"")){
                str +=chars[i];
            }
        }
        System.out.println(Integer.valueOf(str));*/
        test();
    }

    public  static void test(){
        Scanner scanner = new Scanner(System.in);
        int i = scanner.nextInt();
        //数字类型转成字符串类型进行操作
        String s = String.valueOf(i);
        //在将字符串类型转换成字符类型数组
        char[] chars = s.toCharArray();
        String str="";//用来记录取出的数据
        for(int x=chars.length-1;x>=0;x--){
            if(!str.contains(chars[x]+"")){
                str=str+chars[x];
            }
        }
        System.out.println(str);
    }

}

9. 字符个数统计

import java.util.Scanner;

/**
 * @Auther  liaoping
 *  编写一个函数，计算字符串中含有的不同字符的个数。字符在ASCII码范围内(0~127，包括0和127)，换行表示结束符，不算在字符里。不在范围内的不作统计。多个相同的字符只计算一次
 例如，对于字符串abaca而言，有a、b、c三种不同的字符，因此输出3。
 输入描述：

 输入一行没有空格的字符串。
 输出描述：

 输出 输入字符串 中范围在(0~127，包括0和127)字符的种数。
 示例1
 输入：

 abc

 输出：

 3
 */
public class demo10 {
    public static void main(String[] args) {
        /*Scanner scanner=new Scanner(System.in);
        String next=scanner.nextLine();
        //将这行字符串变成字符数组
        char[] chars = next.toCharArray();
        //定义计数器
        int count=0;
        //定义一个字符串来统计已检查的字串
        String str="";
        for(int i=0;i<chars.length;i++){
            if(!str.contains(chars[i]+"")){
                count++;
                str=str+(chars[i]+"");
            }
        }
        System.out.println(count);*/
    }
}

10. 句子逆序

import java.util.Scanner;

/**
 * @Auther  liaoping
 * 
 * 描述

 将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
 所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
 输入描述：

 输入一个英文语句，每个单词用空格隔开。保证输入只包含空格和字母。
 输出描述：

 得到逆序的句子
 示例1
 输入：

 I am a boy

 输出：

 boy a am I

 *
 */
public class demo13 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while (scanner.hasNext()){
            String s1=scanner.next();
        }
    }
}