输出该字符串反转后的字符串

最新推荐文章于 2022-01-05 21:43:15 发布

可持续化发展

最新推荐文章于 2022-01-05 21:43:15 发布

阅读量2.1k

点赞数

分类专栏：牛客网的算法题

本文链接：https://blog.csdn.net/qq_37905259/article/details/108676409

版权

牛客网的算法题专栏收录该内容

27 篇文章 4 订阅

订阅专栏

1、写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述:
输入N个字符

输出描述:
输出该字符串反转后的字符串
示例1
输入
abcd
输出
dcba


import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Scanner s=new Scanner(System.in);
        String b="";
        String str=s.nextLine();
        for(int i=str.length()-1;i>=0;i--){
            b+=str.charAt(i);
        }
        System.out.println(b);
    }
}

2、写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）

输入描述:
输入N个字符

输出描述:
输出该字符串反转后的字符串

示例1
输入
abcd
输出
dcba

import java.io.*;
public class Main {
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while((str=br.readLine())!=null){
            StringBuilder sb = new StringBuilder(str);
            System.out.println(sb.reverse());
        }
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Scanner s=new Scanner(System.in);
        String b="";
        String str=s.nextLine();
        for(int i=str.length()-1;i>=0;i--){
            b+=str.charAt(i);
        }
        System.out.println(b);
    }
}

3、有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？

输入描述:
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。

输出描述:
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

示例1
输入
3
10
81
0
输出
1
5
40

import java.io.*;
 
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while((str = br.readLine()) != null){
            int n = Integer.parseInt(str);
            int sum = 0;
            while (n > 2){
                int temp = n / 3;
                sum += temp;
                n = temp + n % 3;
            }
            if(n == 2){
                System.out.println(sum+1);
            }else{
                System.out.println(sum);
            }
        }
    }
}

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

/**

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

本题有多组数据，请使用while (cin>>)读取

输入描述:
输入int型表示month

输出描述:
输出兔子总数int型

示例1
输入
9
输出
34
思路：
一个兔子（第一个月无仔，第二个月无仔，第三个月一个仔）
写数字，找规律

import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader cin = new BufferedReader(new InputStreamReader(System.in));
        String str = null;
        while ((str = cin.readLine()) != null) {
            int n = Integer.parseInt(str);
            System.out.println(count(n));
        }
    }
    public static int count(int n){
        int[] f = new int[n + 1];
        f[0] = 0;
        f[1] = 1;
        for (int i = 2; i <= n; i++) {
            f[i] = f[i-2] + f[i-1];
        }
        return f[n];
    }
}

5、请实现如下接口

/* 功能：四则运算

 * 输入：strExpression：字符串格式的算术表达式，如: "3+2*{1+2*[-4/(8-6)+7]}"

     * 返回：算术表达式的计算结果

 */

public static int calculate(String strExpression)

{

    /* 请实现*/

    return 0;

}

约束：

pucExpression字符串中的有效字符包括[‘0’-‘9’],‘+’,‘-’, ‘*’,‘/’ ,‘(’， ‘)’,‘[’, ‘]’,‘{’ ,‘}’。

pucExpression算术表达式的有效性由调用者保证;

输入描述:
输入一个算术表达式

输出描述:
得到计算结果

示例1
输入
3+2*{1+2*[-4/(8-6)+7]}
输出
25

在这里插入代码片

6、杨辉三角的变形

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)
本题有多组输入数据，输入到文件末尾，请使用while(cin>>)等方式读入
输入描述:
输入一个int整数

输出描述:
输出返回的int值

示例1
输入
4
输出
3
思路：
1
1 1 1
1 2 3 2 1
1 3 6 763 1

1 41016 19

1 515 30 …

再看每一行的第三个数据，1 3 6 10 15…这些都是1 1+2 1+2+3 1+2+3+4 1+2+3+4+5…递增相加，所以它的奇偶也是逐渐变化的，所以在偶数行中，第4 8 12 …行的第三位都是偶数；而第6 10 14…也的第四位成功的因为前面一行的偶数成为了偶数；<暂时找不到好的规律的说，不过可以参考一下下面>
好吧，从第一行开始向下看，从左往右看四个数据，到中间为止（够四个的就看过来）

1 奇
2 奇奇
3 奇偶奇
4 奇奇偶奇
5 奇偶偶偶
6奇奇奇偶
7 奇偶奇偶
8奇奇偶奇

前面两行我就不说了，3 5 7 行也都是很明显的，第二位是偶数

由第4行到第7行，分别是奇奇偶奇奇偶偶偶奇奇奇偶奇偶奇偶，而在第8行，又和第4行一样了奇奇偶奇，所以，后面的行前面4个数据也会按照这个规律下去;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    //  iNOC产品部-杨辉三角的变形
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String line = "";
        while ((line = br.readLine()) != null) {
            System.out.println(getResult(line));
        }
    }
    public static int getResult(String str) {
        int i = Integer.valueOf(str);
        if (i <= 2) {
            return -1;
        } else if (i % 2 == 1) {
            return 2;
        } else {
            if (i % 4 == 0) {
                return 3;
            } else {
                return 4;
            }
        }
    }
}

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

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

输入描述:
输入算术表达式

输出描述:
计算出结果值

示例1
输入
400+5
输出
405

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
 
/**
 * @author caozb
 * @date 2020/7/16 4:48 下午
 */
public class Main {
    // 中缀转后缀
    //具体转换方式:
    // 1.从左到右进行遍历
    // 2.运算数,直接输出.
    // 3.左括号,直接压入堆栈,(括号是最高优先级,无需比较)(入栈后优先级降到最低,确保其他符号正常入栈)
    // 4.右括号,(意味着括号已结束)不断弹出栈顶运算符并输出直到遇到左括号(弹出但不输出)
    // 5.运算符,将该运算符与栈顶运算符进行比较,
    // 如果优先级高于栈顶运算符则压入堆栈(该部分运算还不能进行),
    // 如果优先级低于等于栈顶运算符则将栈顶运算符弹出并输出,然后比较新的栈顶运算符.
    // (低于弹出意味着前面部分可以运算,先输出的一定是高优先级运算符,等于弹出是因为同等优先级,从左到右运算)
    // 直到优先级大于栈顶运算符或者栈空,再将该运算符入栈.
    // 6.如果对象处理完毕,则按顺序弹出并输出栈中所有运算符.
    // 测试用 3-10+(0+(10+5+3)-10)
    // 5-3+9*6*(6-10-2)
    // -4*(8+100-98)+3
    // 3*(-4*3+13)/(2-1)
    // 2+(4*5+1)*8+7*4+10-9+3+1*9-(6-0*4*4)
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String s;
        while ((s = reader.readLine()) != null) {
        	// List 存放后缀表达式
            List<String> list = new ArrayList<>();
            // 定义操作符栈stack，用于存放操作符 + - * / ( {
            Stack<Character> stack = new Stack();
            for (int i = 0; i < s.length(); i++) {
            	// 定义一个字符，记录字符串当年循环的变量
                char c = s.charAt(i);
//                System.out.println("c = "+ c);
                if (isNum(c)) {
                    int start = i;                    
                    if (i == s.length() - 1) {
                        i++;
                    } else {
                    	
                        while (isNum(s.charAt(++i))) {    
	                        if(i == s.length()-1) {
	                        		i++;
	                        		break;
	                        	}                    	
                        }
                    }
//                    System.out.println(s.substring(start, i));
                    list.add(s.substring(start, i));
                    i--;
                } else if (c == '(' || c == '[' || c == '{') {
                    stack.push(c);
//                    System.out.println(stack.toString());
                } else if (c == ')' || c == ']' || c == '}') {
                    //  一直出栈直到遇到左括号
                    while (stack.peek() != '(' && stack.peek() != '[' && stack.peek() != '{') {
                        list.add(String.valueOf(stack.pop()));
                    }
                    stack.pop();
//                    System.out.println(stack.toString());
                } else if (c == '-') {
                    if ((i != 0 && (isNum(s.charAt(i - 1)) && isNum(s.charAt(i + 1)))) || (s.charAt(i - 1) == ')' || s.charAt(i - 1) == ']' || s.charAt(i - 1) == '}') || (s.charAt(i + 1) == '(' || s.charAt(i + 1) == '[') || s.charAt(i + 1) == '{') {
                        // 减号
                        while (!greaterThan(c, stack)) {
                            list.add(String.valueOf(stack.pop()));
                        }
                        stack.push(c);
//                        System.out.println(stack.toString());
                    } else {
                        // 负号
                        int start = i;
                        while (isNum(s.charAt(++i))) {
                        }
                        list.add(s.substring(start, i));
                        i--;
                    }
                } else if (c == '+') {
                    while (!greaterThan(c, stack)) {
                        list.add(String.valueOf(stack.pop()));
                    }
                    stack.push(c);
//                    System.out.println(stack.toString());
                } else if (c == '*' || c == '/') {
                    while (!greaterThan(c, stack)) {
                        list.add(String.valueOf(stack.pop()));
                    }
                    stack.push(c);
//                    System.out.println(stack.toString());
                }
            }
//            System.out.println(stack.toString());
            while (!stack.isEmpty()) {
                list.add(String.valueOf(stack.pop()));
            }
//            System.out.println("list  "+ list.toString());
            System.out.println(calculate(list));
        }
    }
 
    public static boolean isNum(char c) {
        return c >= '0' && c <= '9';
    }
 
    // 比较运算符与栈顶运算符的优先级
    public static boolean greaterThan(char c, Stack<Character> stack) {
        if (stack.isEmpty()) {
            return true;
        } else {
            char c1 = stack.peek();
            if (c == '*' || c == '/') {
                return !(c1 == '*' || c1 == '/');
            } else {
                return c1 == '(' || c1 == '{' || c1 == '[';
            }
        }
    }
 
    public static int calculate(List<String> list) {
        Stack<Integer> stack = new Stack<>();
        for (int i = 0; i < list.size(); i++) {
            String s = list.get(i);
            int n1;
            int n2;
            switch (s) {
                case "*":
                    n1 = stack.pop();
                    n2 = stack.pop();
//                    System.out.println(" n1*n2  "+n1*n2);
                    stack.push(n1 * n2);
                    break;
                case "/":
                    n1 = stack.pop();
                    n2 = stack.pop();
//                    System.out.println("n1/n2  "+n1/n2);
                    stack.push(n2 / n1);
                    break;
                case "+":
                    stack.push(stack.pop() + stack.pop());
                    break;
                case "-":
                    n1 = stack.pop();
                    n2 = stack.pop();
//                    System.out.println("n1-n2  "+(n1-n2));
                    stack.push(n2 - n1);
                    break;
                default:
//                	System.out.println("Integer.parseInt(s)  "+Integer.parseInt(s));
                    stack.push(Integer.parseInt(s));
            }
        }
        return stack.pop();
    }
 
}

8、完全数（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

import java.io.*;
 
public class Main{
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str = "";
        while((str = br.readLine())!=null){
            System.out.println(count(Integer.valueOf(str)));
        }
    }
     
    public static int conut2(int n){
        if(n<6){
            return 0;
        } else if(n<28){
            return 1;
        }else if(n<496){
            return 2;
        } else if(n<8128){
            return 3;
        } else if(n<33550336){
            return 4;
        } else {
            return -1;
        }
    }
     
    public static int count(int n){
        int result = 0;
        /**
         * 从1开始遍历，两层for循环，一层遍历，二层计算当前数的所有真因子的和。
         * 一个完美数除了自身以外最大的约数=自身的一半。比如28除了自身以外，最大的约数为14。
         * 
         */
        for(int i =1;i<n;i++){
            int sum = 0;
            
            for(int j=1;j<=i/2;j++){
                if(i%j==0){
                    sum += j;
                }
            }
            if(sum == i){
                result ++;
                System.out.println(i);
            }
        }
        return result;
    }
}

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

输入

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

样例输入

7 3

样例输出

/**

计算放苹果方法数目
输入值非法时返回-1
1 <= m,n <= 10
@param m 苹果数目
@param n 盘子数目数
@return 放置方法总数

public static int count(int m, int n)

输入描述:
输入两个int整数

输出描述:
输出结果，int型

示例1
输入
7 3
输出
8

import java.io.*;
/*
放苹果分为两种情况，一种是有盘子为空，一种是每个盘子上都有苹果。
令(m,n)表示将m个苹果放入n个盘子中的摆放方法总数。
1.假设有一个盘子为空，则(m,n)问题转化为将m个苹果放在n-1个盘子上，即求得(m,n-1)即可
2.假设所有盘子都装有苹果，则每个盘子上至少有一个苹果，即最多剩下m-n个苹果，问题转化为将m-n个苹果放到n个盘子上
即求(m-n,n)
*/
public class Main{
    public static void main(String[] arg) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str; 
        while((str=br.readLine())!=null){
            int M = Integer.parseInt(str.split(" ")[0]);
            int N = Integer.parseInt(str.split(" ")[1]);
            int num = fun(M,N);
            System.out.println(num);
        }

    }
    private static int fun(int m,int n){
        if(m==0||n==1){//一个盘子或者0个苹果的情况下，只有一种分法
            return 1;
        }else if(m<n){//盘子比苹果多的情况，
            return fun(m,m);
        }else{
        	//有1个盘子为空的情况下，m个苹果在n-1个盘子中的放法；
            //没有盘子为空，所以每个盘子中至少有一个苹果，所以是m-n个苹果，在n个盘子中的放法
            return fun(m-n,n)+fun(m,n-1);
        }
    }
}

10、请实现如下接口

public static int findNumberOf1( int num)

{

/* 请实现 */

return 0;

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

涉及知识点：

注意多组输入输出！！！！！！
输入描述:
输入一个整数

输出描述:
计算整数二进制中1的个数

示例1
输入
5
输出
2

import java.io.*;
public class Main{
    static public void main(String [] args)throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String str =null;
        while((str=br.readLine())!=null){
            Integer num = Integer.parseInt(str);
            String s = Integer.toBinaryString(num);
            int x=0;
            for(char c : s.toCharArray()){
                if(c=='1')
                    x++;
            }
            System.out.println(x);
        }
        
    }
}

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

命令	执行
reset	reset what
reset board	board fault
board add	where to add
board delete	no board at all
reboot backplane	impossible
backplane abort	install first
he he	unknown command

注意：he he不是命令。

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

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

可持续化发展

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
输出该字符串反转后的字符串

1、写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。（字符串长度不超过1000）输入描述:输入N个字符输出描述:输出该字符串反转后的字符串示例1输入abcd输出dcbaimport java.util.*;public class Main { public static void main(String[] args) throws Exception { Scanner s=new Scanner(System.in);
复制链接

扫一扫