（1）---字符串最后一个单词的长度
计算字符串最后一个单词的长度，单词以空格隔开。
输入描述:
一行字符串，非空，长度小于5000。
输出描述:
整数N，最后一个单词的长度。
输入
hello world
输出
5
import java.util.*;
public class Main{
public static int lengthOfLast(String str) {
String[] s =str.split(" ");
return s[s.length-1].length();
}
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
String str = scan.nextLine();
System.out.println(lengthOfLast(str));
}
}
}
《2》计算字符个数
写出一个程序，接受一个有字母和数字以及空格组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。
输入描述:
输入一个有字母和数字以及空格组成的字符串，和一个字符。
输出描述:
输出输入字符串中含有该字符的个数。
输入
ABCDEF A
输出
1
链接：https://www.nowcoder.com/questionTerminal/a35ce98431874e3a820dbe4b2d0508b1
来源：牛客网
import java.util.*;
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner s=new Scanner(System.in);
String all="";
String one="";
char[] ac;
char temp;
int num=0;
while(s.hasNext())
{
//s.toUpperCase(),String 转化为大写
//s.toLowerCase(),String 转化为小写
//String字符转换，s.toCharArray()与s.charAt(index)
//char字符转换，String.valueOf(c)转化为String
all=s.nextLine();
one=s.nextLine();
//存放原来所有的
ac=all.toCharArray();
//存放要的字符
//temp=one.charAt(0);
for(int i=0;i<ac.length;i++)
{
if(one.equalsIgnoreCase(String.valueOf(ac[i])))
num++;
}
System.out.println(num);
}
}
}3---- 字符串分隔
链接：https://www.nowcoder.com/questionTerminal/d9162298cb5a437aad722fccccaae8a7
来源：牛客网
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组；
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
输入描述:
连续输入字符串(输入2次,每个字符串长度小于100)
输出描述:
输出到长度为8的新字符串数组
输入
abc 123456789
输出
abc00000 12345678 90000000
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.nextLine();
StringBuffer sb=new StringBuffer(s);
if(s.length()%8!=0){
int n=8-s.length()%8;
for(int i=0;i<n;i++){
sb.append("0");
}
}
while(sb.length()>=8){
System.out.println(sb.substring(0, 8));
sb=sb.delete(0, 8);
}
}
}
}4--- 字符个数统计
链接：https://www.nowcoder.com/questionTerminal/eb94f6a5b2ba49c6ac72d40b5ce95f50
来源：牛客网
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
输入
abc
输出
3
import java.util.Scanner;
import java.util.HashSet;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.next();
char ch[] = str.toCharArray();
HashSet<Character> set = new HashSet<Character>();
for (int i = 0; i < ch.length; i++) {
set.add(ch[i]);
}
System.out.println(set.size());
}
}《5》 字符串反转
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：
输入描述:
输入N个字符
输出描述:
输出该字符串反转后的字符串
输入
abcd
输出
dcba
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.nextLine();
for(int i=s.length()-1;i>=0;i--){
System.out.print(s.charAt(i));
}
}
}
}6---字串的连接最长路径查找
链接：https://www.nowcoder.com/questionTerminal/5af18ba2eb45443aa91a11e848aa6723
来源：牛客网
给定n个字符串，请对n个字符串按照字典序排列。
输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。
输出描述:
数据输出n行，输出结果为按照字典序排列的字符串。
输入
9 cap to cat card two too up boat boot
输出
boat boot cap card cat to too two up
链接：https://www.nowcoder.com/questionTerminal/5af18ba2eb45443aa91a11e848aa6723
来源：牛客网
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
String [] ss = new String[num];
for (int i = 0; i < num; i++) {
ss[i]=sc.next();
}
Arrays.sort(ss);
for (int i = 0; i < ss.length; i++) {
System.out.println(ss[i]);
}
}
}
7---句子逆序
链接：https://www.nowcoder.com/questionTerminal/48b3cb4e3c694d9da5526e6255bb73c3
来源：牛客网
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符
接口说明
/**
* 反转句子
*
* @param sentence 原句子
* @return 反转后的句子
*/
public String reverse(String sentence);
输入描述:
将一个英文语句以单词为单位逆序排放。
输出描述:
得到逆序的句子
输入
I am a boy
输出
boy a am I
import java.util.Scanner;
/**
* i am a boy=>boy a am i
* @author Administrator
*
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str = sc.nextLine();
int len = str.length();
String[] s=str.split(" ");
StringBuilder sb = new StringBuilder();
for (int i = s.length-1; i >=0; i--) {
sb.append(s[i]+" ");
}
System.out.println(sb.substring(0, len));
}
}
}
链接：https://www.nowcoder.com/questionTerminal/184edec193864f0985ad2684fbc86841
来源：牛客网
密码要求:
1.长度超过8位
2.包括大小写字母.数字.其它符号,以上四种至少三种
3.不能有相同长度超2的子串重复
说明:长度超过2的子串
输入描述:
一组或多组长度超过2的子符串。每组占一行
输出描述:
如果符合要求输出：OK，否则输出NG
输入
021Abc9000 021Abc9Abc1 021ABC9000 021$bc9000
输出
OK NG NG OK
import java.util.*;
public class Main {
// 1.长度超过8位
public static boolean checkLength(String password){
if (password==null || password.length()<=8)
return false;
return true;
}
// 2.包括大小写字母.数字.其它符号,以上四种至少三种
public static boolean checkCharKinds(String password){
int Digit=0 , lowercase=0,uppercase=0,others=0;
char[] ch = password.toCharArray();
for (int i = 0; i < ch.length; i++) {
if (ch[i]>='0'&&ch[i]<='9') {
Digit=1;
continue;
}
else if (ch[i]>='a'&&ch[i]<='z') {
lowercase=1;
continue;
}
else if (ch[i]>='A'&&ch[i]<='Z') {
uppercase=1;
continue;
}else {
others=1;
continue;
}
}
int total = Digit+lowercase+uppercase+others;
return total>=3 ? true : false;
}
// 3.不能有相同长度超2的子串重复
public static boolean checkCharRepeat(String password){
for(int i=0 ;i<password.length()-2 ;i++){
String substr1 =password.substring(i, i+3);
if (password.substring(i+1).contains(substr1))
return false;
}
return true;
}
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
while (cin.hasNextLine()) {
String psw = cin.nextLine();
if (checkLength(psw)&&checkCharKinds(psw)&&checkCharRepeat(psw))
System.out.println("OK");
else
System.out.println("NG");
}
}
}9--- 输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数
链接：https://www.nowcoder.com/questionTerminal/539054b4c33b4776bc350155f7abd8f5
来源：牛客网
输入一行字符，分别统计出包含英文字母、空格、数字和其它字符的个数。
/**
* 统计出英文字母字符的个数。
*
* @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;
}
输入描述:
输入一行字符串，可以有空格
输出描述:
统计其中英文字符，空格字符，数字字符，其他字符的个数
输入
1qazxsw23 edcvfr45tgbn hy67uj m,ki89ol.\\/;p0-=\\][
输出
26 3 10 12
链接：https://www.nowcoder.com/questionTerminal/539054b4c33b4776bc350155f7abd8f5
来源：牛客网
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while(scanner.hasNext()){
String line = scanner.nextLine();
System.out.println(getEnglishCharCount(line));
System.out.println(getBlankCharCount(line));
System.out.println(getNumberCharCount(line));
System.out.println(getOtherCharCount(line));
}
scanner.close();
}
public static int getEnglishCharCount(String str) {
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if((ch[i]>='a'&&ch[i]<='z')||(ch[i]>='A'&&ch[i]<='Z')){
count++;
}
}
return count;
}
public static int getNumberCharCount(String str){
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if(ch[i]>='0'&&ch[i]<='9'){
count++;
}
}
return count;
}
public static int getBlankCharCount(String str){
char[] ch = str.toCharArray();
int count =0;
for(int i=0;i<ch.length;i++){
if(ch[i]==' '){
count++;
}
}
return count;
}
public static int getOtherCharCount(String str) {
int count =0;
for(int i=0;i<str.length();i++){
if(getBlankCharCount(""+str.charAt(i))==0&&getEnglishCharCount(""+str.charAt(i))==0&&getNumberCharCount(""+str.charAt(i))==0){
count++;
}
}
return count;
}
}10---- 删除字符串中出现次数最少的字符
链接：https://www.nowcoder.com/questionTerminal/05182d328eb848dda7fdd5e029a56da9
来源：牛客网
实现删除字符串中出现次数最少的字符，若多个字符出现次数一样，则都删除。输出删除这些单词后的字符串，字符串中其它字符保持原来的顺序。
输入描述:
字符串只包含小写英文字母, 不考虑非法输入，输入的字符串长度小于等于20个字节。
输出描述:
删除字符串中出现次数最少的字符后的字符串。
输入
abcdd
输出
dd
链接：https://www.nowcoder.com/questionTerminal/05182d328eb848dda7fdd5e029a56da9
来源：牛客网
/**
思路：
1.借助LinkedHashMap保持顺序且不重复，遍历map，统计各个字符的次数
2.map.values()获取集合，求出集合最小值index =Collection.min(List a);
3.遍历map，StringBuilder sb对象来串接值不是index的字符。
4.输出结果。
*/
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保持顺序且不重复
Map<Character,Integer> map = new LinkedHashMap<Character,Integer>();
char[] A =str.toCharArray();
for(int i=0;i<A.length;i++)
{
char ch = str.charAt(i);
//统计各字符的数量
if(map.containsKey(ch))
{
map.put(ch,map.get(ch)+1);
}
else
{
map.put(ch,1);
}
}
int min =1;
for(char ch:A)
{
if(map.get(ch)<=1)
{
min = map.get(ch);
}
}
//获取map所有值
Collection<Integer> a = map.values();
//找到集合中最小值index
int index = Collections.min(a);
StringBuilder sb= new StringBuilder();
for(char ch:A)//不用用keyset()它会将重复的删除
{
if(map.get(ch)!=index)
sb.append(ch);
}
System.out.println(sb.toString());
}
}
}方法二
链接：https://www.nowcoder.com/questionTerminal/05182d328eb848dda7fdd5e029a56da9
来源：牛客网
先用map统计出字符出现的次数
找出最少出现的次数
若某一字符出现的次数不为最少次数则输出
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
Map<Character, Integer> map =
new LinkedHashMap<Character, Integer>();
String str = sc.next();
char[] ch = str.toCharArray();
for(int i = 0; i < ch.length; i++){
if(map.containsKey(ch[i])){
map.put(ch[i],map.get(ch[i]) + 1);
}else{
map.put(ch[i], 1);
}
}
//找出最小值
int min = map.get(ch[0]);
for(int count : map.values()){
if(count < min){
min = count;
}
}
//删除与最小值相同的元素
for(int i = 0; i < ch.length; i++){
if(map.get(ch[i]) != min){
System.out.print(ch[i]);
}
}
System.out.println();
}
sc.close();
}
}9.8
11---字符串排序
链接：https://www.nowcoder.com/questionTerminal/5190a1db6f4f4ddb92fd9c365c944584
来源：牛客网
编写一个程序，将输入字符串中的字符按如下规则排序。
规则 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).
输入描述:
输出描述:
输入
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)
{
Scanner sca = new Scanner(System.in);
while (sca.hasNext())
{
String str = sca.nextLine();
char [] cha = str.toCharArray();
StringBuffer sb = new StringBuffer();
for (int i = 0; i<26; i++)
{
char c = (char)(i + 'A');
for (int j = 0; j<str.length(); j++)
{
if (cha[j] == c || cha[j] == (char)(c + 32))
sb.append(cha[j]);
}
}
for (int k = 0; k<str.length(); k++)
{
if (!(cha[k] >= 'A' && cha[k] <= 'Z' || cha[k] >= 'a' && cha[k] <= 'z'))
sb.insert(k, cha[k]);
}
System.out.println(sb.toString());
}
}
}12---- 找出字符串中第一个只出现一次的字符(题面已经更新)
找出字符串中第一个只出现一次的字符
输入描述:
输入一个非空字符串
输出描述:
输出第一个只出现一次的字符，如果不存在输出-1
输入
asdfasdfo
输出
o
//通过判断一个字符在字符串中的第一个索引和最后一个索引是否相同
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();
}
}
var str="This is my frist js code and this is my second js";
document.write("my第一次出现的位置："+str.indexOf("is")+" <br >");
document.write("my最后一次出现的位置："+str.lastIndexOf("is"));
结果都是从左到右的算的,只是找的是第一个和最后一个,如果只有一个就相同了.
13----查找两个字符串a,b中的最长公共子串
链接：https://www.nowcoder.com/questionTerminal/181a1a71c7574266ad07f9739f791506
来源：牛客网
查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
输入描述:
输入两个字符串
输出描述:
返回重复出现的字符
输入
abcdefghijklmnop abcsafjklmnopqrstuvw
输出
jklmnop
import java.util.Scanner;
/* 查找两个字符串a,b中的最长公共子串,若有多个，输出在较短串中最先出现的那个(就是长度为val的子串不止一个，输出先出现的)
*
* 动态规划解决字符串的最长公共子串 “状态矩阵”
* 动态规划关键在于建立dp[x][y]矩阵，A的前x个xx和B的前y个xx最大或者最小的xx值
* 1、在求解字符串的编辑距离的时候，dp[x][y]表示将字符串A的前x个字符编辑为字符串B的前y个字符的最小代价，
* dp[x][y]代表这个最小代价值
* 2、在求解字符串的最长公共子串的时候，dp[x][y]表示字符串A的前x个字符和字符串B的前y个字符最大子串长度的值
* dp[x][y]代表最大的子串长度的值
* 对于字符串A、B，dp[x][y]表示字符串A的前x个字符和字符串B的前y个字符的最大子串长度的值，
* 若A[x-1] == B[x-1](A的第x个字符和B的第y个字符相同) dp[x][y] = dp[x-1][y-1] + 1 子串长度的值加一
* 若A[x-1] ！= B[x-1](A的第x个字符和B的第y个字符不同) dp[x][y] = 0
* 因为A的前x个字符和字符串B的前y个字符没有连续公共部分
* 用变量记录dp[][]的最大值以及index，对应就是A和B公共子串长度的最大值以及最长公共子串的结束的位置(从下标1开始遍历)
* */
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
while(in.hasNext()){
String str1 = in.next();
String str2 = in.next();
String result2 = lccs(str1, str2);
System.out.println(result2);
}
in.close();
}
//动态规划的解法
public static String lccs(String str1, String str2){
String strlong = str1.length() > str2.length() ? str1 : str2;
String strshort = str1.length() <= str2.length() ? str1 : str2;
int len1 = strshort.length();
int len2 = strlong.length();
int dp[][] = new int[len1 + 1][len2 + 1];
// for (int i = 1; i <= len1; i++)
// dp[i][0] = 0; // A的前i个字符和B的前0个字符最长公共子串的长度值，当然为0
// for (int i = 1; i <= len2; i++)
// dp[0][i] = 0; // A的前0个字符和B的前i个字符最长公共子串的长度值，当然为0
//以上两个for可以省略，因为这里dp矩阵的初始化较为特殊，即使不执行两个for,dp[][]中的元素之依旧为0
int maxlong = 0; //记录最长公共子串的长度
int endIndex = 0; //记录最长公共子串的结束位置
for (int i = 1; i <= len1; i++) {
for (int j = 1; j <= len2; j++) {
if(strshort.charAt(i-1) == strlong.charAt(j-1))
dp[i][j] = dp[i-1][j-1] + 1;
else
dp[i][j] = 0;//此处不同，不必返回动态序列情况，else 分支可以注释掉，因为dp[][]默认值为0
if(maxlong < dp[i][j]){
maxlong = dp[i][j];
endIndex = i; //i 此处是以端字符串为参照
}
}
}
return strshort.substring(endIndex-maxlong, endIndex);
}
}14----查找输入整数二进制中1的个数
链接：https://www.nowcoder.com/questionTerminal/1b46eb4cf3fa49b9965ac3c2c1caf5ad
来源：牛客网
请实现如下接口
public static int findNumberOf1(intnum)
{
/* 请实现 */
return 0;
} 譬如：输入5 ，5的二进制为101，输出2
涉及知识点：
输入描述:
输入一个整数
输出描述:
计算整数二进制中1的个数
输入
5
输出
2
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
while (in.hasNext()) {
int a=in.nextInt();
int count=0;
while (a != 0) {
a&=a-1;
count++;
}
System.out.println(count);
}
}
}方法二
链接：https://www.nowcoder.com/questionTerminal/1b46eb4cf3fa49b9965ac3c2c1caf5ad
来源：牛客网
import java.util.Scanner;
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
while(scan.hasNext()){
int n = scan.nextInt();
int count = 0;
String str = Integer.toBinaryString(n);
char[] cha = str.toCharArray();
for(char c :cha){
if(c=='1'){
count++;
}
}
System.out.println(count);
}
}
}
15---百钱买百鸡问题
链接：https://www.nowcoder.com/questionTerminal/74c493f094304ea2bda37d0dc40dc85b
来源：牛客网
公元前五世纪，我国古代数学家张丘建在《算经》一书中提出了“百鸡问题”：鸡翁一值钱五，鸡母一值钱三，鸡雏三值钱一。百钱买百鸡，问鸡翁、鸡母、鸡雏各几何？
详细描述：
接口说明
原型：
int GetResult(vector &list)
输入参数：
无
输出参数（指针指向的内存区域保证有效）：
list 鸡翁、鸡母、鸡雏组合的列表
返回值：
-1 失败
0 成功
输入描述:
输入任何一个整数，即可运行程序。
输出描述:
输入
1
输出
0 25 75 4 18 78 8 11 81 12 4 84
//鸡翁、鸡母、鸡雏分别为x, y, z 三个变量。
//x+y+z=100
//5x+3y+z/3=100
//确定x即可算出y和z，若y和z为非负整数，则为有效结果，输出。
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();
int n1 = 0; // 鸡翁个数
int n2 = 0; // 鸡母个数
int n3 = 3; // 鸡雏个数
for(n1 = 0; n1 < 20; n1++){
for(n2 = 0; n2 < 33; n2++){
for(n3 = 0; n3 < 100; n3 = n3 + 3){
if(n1 + n2 + n3 == 100 && 5*n1 + 3*n2 + n3/3 == 100){
System.out.println(n1 + " " + n2 + " " + n3);
}
}
}
}
}
sc.close();
}
}16---- 汽水瓶
链接：https://www.nowcoder.com/questionTerminal/fe298c55694f4ed39e256170ff2c205f
来源：牛客网
有这样一道智力题：“某商店规定：三个空汽水瓶可以换一瓶汽水。小张手上有十个空汽水瓶，她最多可以换多少瓶汽水喝？”答案是5瓶，方法如下：先用9个空瓶子换3瓶汽水，喝掉3瓶满的，喝完以后4个空瓶子，用3个再换一瓶，喝掉这瓶满的，这时候剩2个空瓶子。然后你让老板先借给你一瓶汽水，喝掉这瓶满的，喝完以后用3个空瓶子换一瓶满的还给老板。如果小张手上有n个空汽水瓶，最多可以换多少瓶汽水喝？
输入描述:
输入文件最多包含10组测试数据，每个数据占一行，仅包含一个正整数n（1<=n<=100），表示小张手上的空汽水瓶数。n=0表示输入结束，你的程序不应当处理这一行。
输出描述:
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。
输入
3 10 81 0
输出
1 5 40
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
while(n!=0)
{
System.out.println(drink(n));
n=sc.nextInt();
}
sc.close();
}
public static int drink(int n)
{
if(n<2)
return 0;
if(n==2)
return 1;
return n/3+drink(n/3+n%3); }
}
17--- 数字颠倒
链接：https://www.nowcoder.com/questionTerminal/ae809795fca34687a48b172186e3dafe
来源：牛客网
描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
输入描述:
输入一个int整数
输出描述:
将这个整数以字符串的形式逆序输出
输入
1516000
输出
0006151
import java.util.*;
public class Main {
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
String str = scan.nextLine();
StringBuffer sb = new StringBuffer(str);
sb.reverse();
System.out.println(sb.toString());
}
}18--- 进制转换
链接：https://www.nowcoder.com/questionTerminal/8f3df50d2b9043208c5eed283d1d4da6
来源：牛客网
写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）
输入描述:
输入一个十六进制的数值字符串。
输出描述:
输出该数值的十进制字符串。
输入
0xA
输出
10
import java.util.Scanner;
public class Main{
public static void main(String[]args){
Scanner in = new Scanner(System.in);
while(in.hasNextLine()){
String str = in.nextLine();
System.out.println(Integer.parseInt(str.substring(2),16));//str.substring(2)表示去除0x
}
}
}19--提取不重复的整数
链接：https://www.nowcoder.com/questionTerminal/253986e66d114d378ae8de2e6c4577c1
来源：牛客网
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。
输入描述:
输入一个int型整数
输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数
输入
9876673
输出
37689
//利用set不包含重复元素实现
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()){
String str = sc.nextLine();
char[] nums = str.toCharArray();
Set<Character> st = new LinkedHashSet<Character>();
for (int i = nums.length -1; i >= 0; i--) {
st.add(nums[i]);
}
String result = "";
for (Character c : st) {
result += c + "";
}
System.out.println(result);
}
}
}20--- 统计每个月兔子的总数
链接：https://www.nowcoder.com/questionTerminal/1221ec77125d4370833fd3ad5ba72395
来源：牛客网
有一只兔子，从出生后第3个月起每个月都生一只兔子，小兔子长到第三个月后每个月又生一只兔子，假如兔子都不死，问每个月的兔子总数为多少？
/**
* 统计出兔子总数。
*
* @param monthCount 第几个月
* @return 兔子总数
*/
public static int getTotalCount(int monthCount)
{
return 0;
}
输入描述:
输入int型表示month
输出描述:
输出兔子总数int型
输入
9
输出
34
链接：https://www.nowcoder.com/questionTerminal/1221ec77125d4370833fd3ad5ba72395
来源：牛客网
import java.util.*;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
while(in.hasNext()){
int monthCount = in.nextInt();
System.out.println(getTotalCount(monthCount));
}
in.close();
}
public static int getTotalCount(int monthCount){
if(monthCount==1 || monthCount==2){
return 1;
}
return getTotalCount(monthCount-1)+getTotalCount(monthCount-2);
}
}21--- 公共字串计算
来源：牛客网
题目标题：
计算两个字符串的最大公共字串的长度，字符不区分大小写
详细描述：
接口说明
原型：
int getCommonStrLength(char * pFirstStr, char * pSecondStr);
输入参数：
char * pFirstStr //第一个字符串
char * pSecondStr//第二个字符串
输入描述:
输入两个字符串
输出描述:
输出一个整数
输入
asdfas werasdfaswer
输出
6
链接：https://www.nowcoder.com/questionTerminal/98dc82c094e043ccb7e0570e5342dd1b
来源：牛客网
最长公共子串和最长公共子序列。。。傻傻烦不清楚
举个栗子：
str1="123ABCD456" str2 = "ABE12345D"
最长公共子串是：123
最长公共子序列是：12345
这两个都可以用动态规划，只是状态转移方程有点区别
最长公共子序列是：
dp[i][j] -- 表示子串str1[0...i]和子串str[0...j]的最长公共子序列
当str1[i] == str2[j]时，dp[i][j] = dp[i-1][j-1] + 1;
否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
最优解为dp[len1-1][len2-1];
最长公共子串是： dp[i][j] -- 表示以str1[i]和str2[j]为结尾的最长公共子串 当str1[i] == str2[j]时，dp[i][j] = dp[i-1][j-1] + 1; 否则，dp[i][j] = 0;
最优解为max(dp[i][j]),其中0<=i<len1, 0<=j<len2;
so，代码如下： //求最长公共子串
import java.util.Scanner;
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String str1 = "";
String str2 = "";
while(sc.hasNext()){
str1 = sc.next();
str2 = sc.next();
System.out.println(getCommonStrLength(str1, str2));
}
}
public static int getCommonStrLength(String str1, String str2){
int len1 = str1.length();
int len2 = str2.length();
int[][] dp = new int[len1+1][len2+1];
for(int i=0;i<=len1;i++){
for(int j=0;j<=len2;j++){
dp[i][j] = 0;
}
}
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(str1.charAt(i-1) == str2.charAt(j-1)){
dp[i][j] = dp[i-1][j-1] + 1;
}else{
dp[i][j] = 0; //区别在这儿
}
}
}
int max = 0;
for(int i=0;i<=len1;i++){
for(int j=0;j<=len2;j++){
if(max < dp[i][j])
max = dp[i][j];
}
}
return max;
}
}
//求最长公共子序列 import java.util.Scanner;
public class Main{
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String str1 = "";
String str2 = "";
while(sc.hasNext()){
str1 = sc.next();
str2 = sc.next();
System.out.println(getCommonStrLength(str1, str2));
}
}
public static int getCommonStrLength(String str1, String str2){
int len1 = str1.length();
int len2 = str2.length();
int[][] dp = new int[len1+1][len2+1];
for(int i=0;i<=len1;i++){
for(int j=0;j<=len2;j++){
dp[i][j] = 0;
}
}
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(str1.charAt(i-1) == str2.charAt(j-1)){
dp[i][j] = dp[i-1][j-1] + 1;
}else{
dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]); //区别在这儿
}
}
}
return dp[len1][len2];
}
}
8374
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
