- 计算字符个数
(1)大小写字母和数字的ascii码值:
65~90为26个大写英文字母,97~122号为26个小写英文字母,48~57为0到9十个阿拉伯数字。大小写字母之间正好相差32。
(2)字符串的大小写转换:
toLowerCase()方法将String转换为小写。如果字符串中没有应该被转换的字符,则将原字符串返回,否则返回一个新的字符串。
语法:str.toLowerCase()
toUpperCase()方法将Srtring转换为大写。如果字符串中没有应该转换的字符,则将原字符串返回,否则返回一个新的字符串。
语法:str.toUpperCase()
说明:使用toLowerCase()方法和toUpperCase()方法进行大小写转换时,数字或非字符不受影响。
(3)单个字符的大小写转换
根据 Character 类提供的大小写转换方法。
Character.toUpperCase(char):小写字符char转成大写字符。
Character.toLowerCase(char):大写转小写。
//主要是不区分大小写
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine().toUpperCase();
char char1 = Character.toUpperCase(sc.nextLine().charAt(0));
int result = solution(str,char1);
System.out.println(result);
}
public static int solution(String str,char char1) {
int count = 0;
for(int i=0;i<str.length();i++) {
if(char1 == str.charAt(i)) {
count++;
}
}
return count;
}
}
(1)
import java.util.*;
import java.util.ArrayList;
public class Solution {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<>();
//这个while循环会陷入死循环,程序会一直等待你的输入,while循环后面的语句都不会执行
while(sc.hasNextInt()) {
list.add(sc.nextInt());
}
for(int i=0;i<list.size();i++) {
System.out.println(list.get(i));
}
}
}
(2)
//这种方法好像没有排序的过程,竟然都能通过
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
/*
像这种虽然也是while循环,但是输出语句在循环内部已经完成了输出,
但是程序也是一直在等待输入
*/
while (sc.hasNextInt()) {
int n = sc.nextInt();
Integer[] arr = new Integer[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
ArrayList<Integer> list = new ArrayList<>(arr.length);
Collections.addAll(list, arr);
TreeSet<Integer> set = new TreeSet<>(list);
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
}
//增加了一个排序的过程
import java.util.*;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int n = sc.nextInt();
Integer[] arr = new Integer[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = sc.nextInt();
}
for(int i=0;i<arr.length;i++) {
for(int j=i+1;j<arr.length;j++) {
if(arr[i]>arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
ArrayList<Integer> list = new ArrayList<>(arr.length);
Collections.addAll(list, arr);
TreeSet<Integer> set = new TreeSet<>(list);
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
}
所以这种先接收所有数据再进行处理的想法是错误的。
import java.util.Scanner;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
ArrayList<Integer> list = new ArrayList<>();
//先接受所有数据在一个list中,然后再对数据进行处理
//(这种想法是错误的,不可能接收所有数据)
while(sc.hasNextInt()) {
list.add(sc.nextInt());
}
ArrayList<Integer> list1 = Main.solution(list);
for(int i=0;i<list1.size();i++) {
System.out.println(list1.get(i));
}
}
public static ArrayList<Integer> solution(ArrayList<Integer> list) {
int flag = 0;
ArrayList<Integer> result = new ArrayList<Integer>();
ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
while(flag < list.size()) {
ArrayList<Integer> temp = new ArrayList<Integer>();
for(int i=flag+1;i<=flag+list.get(flag);i++) {
temp.add(list.get(i));
}
res.add(temp);
flag = flag+list.get(flag)+1;
}
//去重
for(int j=0;j<res.size();j++) {
for(int m=0;m<res.get(j).size();m++) {
for(int n=m+1;n<res.get(j).size();n++) {
if(res.get(j).get(m) == res.get(j).get(n)) {
res.get(j).remove(n);
}
}
}
}
//排序
for(int j=0;j<res.size();j++) {
for(int m=0;m<res.get(j).size();m++) {
for(int n=m+1;n<res.get(j).size();n++) {
if(res.get(j).get(m) > res.get(j).get(n)) {
int amount = res.get(j).get(m);
res.get(j).set(m, res.get(j).get(n));
res.get(j).set(n, amount);
}
}
}
}
for(int j=0;j<res.size();j++) {
for(int m=0;m<res.get(j).size();m++) {
result.add(res.get(j).get(m));
}
}
return result;
}
}
- 字符串分隔
(1)采用while循环逐行读取输入
(2)str.substring:(左闭右开)
String str = “123”;
str.substring(int beginIndex)或者str.substring(int beginIndex, int endIndex)
参数:beginIndex – 起始索引(包括), 索引从 0 开始。endIndex – 结束索引(不包括)。
import java.util.*;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()) {
String str1 = sc.nextLine();
if(str1.length()> 0) {
if(str1.length()<8) {
for(int j=1;str1.length()<8;j++) {
str1 = str1 + "0";
}
System.out.println(str1);
}
else if(str1.length() == 8) {
System.out.println(str1);
}
else {
int n1 = str1.length()%8;
if(n1 > 0) {
for(int m=1;m<=8-n1;m++) {
str1 = str1 + "0";
}
}
for(int i=0;i<str1.length();i+=8) {
System.out.println(str1.substring(i,i+8));
}
}
}
}
}
}
- 进制转换
本文提供两种Java实现任意进制转换的方法:
方法一:利用 Integer 实现进制转换
1、 Integer类的方法toBinaryString(),Integer.toOctalString(), Integer.toHexString()可实现十进制分别转换成二进制、八进制和十六进制
2、Integer.valueOf(s, radix) 将第一个参数解释为用第二个参数指定的基数表示的有符号整数,换句话说就是将 s 以 radix 进制的形式转换为十进制。
public class ArbitraryConversion
{
public static void main(String[] args) {
System.out.println("==========十进制776转换到其它进制:==========");
int sjz = 776;
System.out.println("十进制转二进制: " + Integer.toBinaryString(sjz));
System.out.println("十进制转八进制: " + Integer.toOctalString(sjz));
System.out.println("十进制转十六进制: " + Integer.toHexString(sjz));
System.out.println("==========八进制1410转换到其它进制:==========");
String bjz = "1410";
System.out.println("八进制转十进制: " + Integer.valueOf(bjz, 8));
System.out.println("八进制转二进制: " + Integer.toBinaryString(Integer.valueOf(bjz , 8))); //八进制转十进制,十进制转二进制
System.out.println("八进制转十六进制: " + Integer.toHexString(Integer.valueOf(bjz, 8))); //八进制转十进制,十进制转十六进制
System.out.println("==========十六进制308转换到其它进制:==========");
String sljz = "308";
System.out.println("十六进制转十进制: " + Integer.valueOf(sljz , 16));
System.out.println("十六进制转二进制: " + Integer.toBinaryString(Integer.valueOf(sljz , 16))); //十六进制转十进制,十进制转二进制
System.out.println("十六进制转八进制: "+ Integer.toOctalString(Integer.valueOf(sljz, 16))); //十六进制转十进制,十进制转八进制
System.out.println("==========二进制1100001000转换到其它进制:==========");
String ejz = "1100001000";
System.out.println("二进制转十进制: " + Integer.valueOf(ejz, 2));
System.out.println("二进制转八进制: " + Integer.toOctalString(Integer.valueOf(ejz , 2))); //二进制转十进制,十进制转八进制
System.out.println("二进制转十六进制: "+ Integer.toHexString(Integer.valueOf(ejz, 2))); //二进制转十进制,十进制转十六进制
}
}
方法二:利用 BigInteger 实现进制转换。
利用BigInteger 实现进制转换比较简单,注释很详细。
//一定要导入这个包,注意不是Math,m是小写的!!!
import java.math.BigInteger;
/*
* BigIntegerArbitraryConversion
*/
public class BigIntegerArbitraryConversion {
public static void main(String[] args) {
System.out.println(change("1410", 8, 2)); // 八进制转二进制
System.out.println(change("1410", 8, 10)); // 八进制转十进制
System.out.println(change("1410", 8, 16)); // 八进制转十六进制
}
/**
* number 要转换的数//注意,要转换的数是String类型的
* from 原数的进制
* to 要转换成的进制
*/
private static String change(String number, int from, int to) {
/*
这个形式就是这样的,返回的是一个字符串
String str = new BigInteger("15", 10).toString(16);
System.out.println(str);
*/
return new BigInteger(number, from).toString(to);
}
}
题目代码:
//1. 注意这个math的m是小写的,不是大写的
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNextLine()) {
//一定要把前两个字符截掉
String str1 = sc.nextLine().substring(2);
String str2 = new BigInteger(str1,16).toString(10);
System.out.println(str2);
}
}
}
- 质数因子
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long n = sc.nextLong();
for(int i=2;i<=n;i++){
while(n%i == 0){
n = n/i;
System.out.print(i + " ");
}
}
}
}
- 提取不重复的整数
在使用ArrayList去除重复的元素时要注意下面两点:
(1) i<res.size()-1:i不能取到res.size()-1,因为i = res.size()-1时j=i+1,则j = res.size(),越界了,而且i都是最后一个了,后面没有元素与其比较了,所以i = res.size()-1也没必要。
(2)res.remove(j);j–;
res.remove(j)后,后面的元素会补上来,如果没有j–直接进入下次循环进行j++的后会漏掉现在索引为j的元素,也就是原来索引为j+1的元素。
ArrayList<Integer> res = new ArrayList<Integer>();
for(int i=0;i<res.size()-1;i++){
for(int j=i+1;j<res.size();j++){
if(res.get(j) == res.get(i)){
res.remove(j);
j--;
}
}
}
翻转字符串的方法:
String str1 = “123”;
String str2 = new StringBuffer(str1).reverse().toString();
StringBuffer类才有实例方法reverse(),String类没有,所以先将字符串变成StringBuffer,翻转后再变成String。
23.删除字符串中出现次数最少的字符
StringBuilder类的常用方法:
StringBuilder strB = new StringBuilder();
1、append(String str)/append(char c):字符串连接
System.out.println(“StringBuilder:”+strB.append(“ch”).append(“111”).append(‘c’));
//return “StringBuilder:ch111c”
2、toString():返回一个与构建起或缓冲器内容相同的字符串
System.out.println(“String:”+strB.toString());
//return “String:ch111c”
3. charAt(int index):返回索引为index的字符
4. insert(int index,String str/char c):在索引为index处插入String str/char c)
5、setCharAt(int index, char c):将索引为index的元素设置为 c(可以理解为替换)
strB.setCharAt(2, ‘d’);
System.out.println(“StringBuilder.setCharAt:” + strB);
//return “StringBuilder.setCharAt:chd11c”
6、delete(int startIndex,int endIndex):删除起始位置(含)到结尾位置(不含)之间的字符串
System.out.println(“StringBuilder.delete:”+ strB.delete(2, 4));
//return “StringBuilder.delete:chSd11c”
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
String str = sc.next();
char[] ch = str.toCharArray();
HashMap<Character,Integer> map = new HashMap<Character,Integer>();
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);
}
}
ArrayList<Integer> list = new ArrayList<Integer>(map.values());
int num = Collections.min(list);
StringBuilder res = new StringBuilder();
for(int i=0;i<ch.length;i++){
if(map.get(ch[i])!=num){
res.append(ch[i]);
}
}
System.out.println(res.toString());
}
}
}
25.数据分类处理
判断一个字符串是不是另一个字符串的子串:
(1)parentStr.indexOf(sunStr):如果包含,返回的值是包含该子字符串在父类字符串中起始位置;如果不包含返回值为-1。
(2)parentStr.contains(sunStr):如果包含则返回true,不包含则返回false。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String I = sc.nextLine();
String R = sc.nextLine();
String[] I_str = I.split(" ");
String[] R_str = R.split(" ");
ArrayList<Integer> I_list = new ArrayList<Integer>();
ArrayList<Integer> R_list = new ArrayList<Integer>();
for(int i=1;i<I_str.length;i++){
I_list.add(Integer.parseInt(I_str[i]));
}
for(int i=1;i<R_str.length;i++){
R_list.add(Integer.parseInt(R_str[i]));
}
//R序列去重排序
TreeSet R_set = new TreeSet(R_list);
ArrayList<Integer> Rlist = new ArrayList<Integer>(R_set);
Collections.sort(Rlist);
ArrayList<Integer> res = new ArrayList<Integer>();
for(int i=0;i<Rlist.size();i++){
ArrayList<Integer> temp = isContains(Rlist.get(i),I_list);
if(temp.size()!=0&&temp!=null){
res.add(Rlist.get(i));
res.addAll(temp);
}
}
int num = res.size();
res.add(0,num);
for(int i=0;i<res.size()-1;i++){
System.out.print(res.get(i)+" ");
}
System.out.println(res.get(res.size()-1));
}
}
public static ArrayList<Integer> isContains(int R_i,ArrayList<Integer> list){
ArrayList<Integer> con = new ArrayList<Integer>();
int count = 0;
for(int i=0;i<list.size();i++){
if(String.valueOf(list.get(i)).contains( String.valueOf(R_i))){
count++;
con.add(i);
con.add(list.get(i));
}
}
if(count!=0){
con.add(0,count);
}
return con;
}
}
27.查找兄弟单词
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str1 = sc.nextLine();
String[] str = str1.split(" ");
int num = Integer.parseInt(str[0]);
String key = str[num+1];
int index = Integer.parseInt(str[num+2]);
ArrayList<String> brolist = new ArrayList<String>();
for(int i=1;i<str.length-2;i++){
if(isBroStr(str[i],key)){
brolist.add(str[i]);
}
}
System.out.println(brolist.size());
Collections.sort(brolist);
if(brolist.size()>=index){
System.out.println(brolist.get(index-1));
}
}
}
//判断是否是兄弟单词的方法不错
public static boolean isBroStr(String resource,String key){
if(resource.equals(key)||resource.length()!=key.length()){
return false;
}
for(int i='a';i<='z';i++){
char c = (char)(i);
if(getCharNum(resource,c)!=getCharNum(key,c)){
return false;
}
}
return true;
}
public static int getCharNum(String input,char ch){
char[] inputchar = input.toCharArray();
int count = 0;
for(int i=0;i<inputchar.length;i++){
if(ch == inputchar[i]){
count++;
}
}
return count;
}
}
33.整数与ip地址间的转换
import java.util.*;
/*
Long.toBinaryString(num):将long型整数num转化为无符号的二进制数,转化成的二进制数是字符串的形式
Long.parseLong(String str,int n):n表示str是n进制的,n不写默认为10
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String ipStr = sc.nextLine();
String tenStr = sc.nextLine();
ipToTen(ipStr);
tenToIp(tenStr);
}
}
public static void ipToTen(String ipStr){
String[] ip = ipStr.split("\\.");
StringBuilder sbAll = new StringBuilder();
//将ip地址每段整数转化成八位二进制并结合在一起
for(int i=0;i<ip.length;i++){
StringBuilder sb = new StringBuilder();
String temp = Long.toBinaryString(Long.parseLong(ip[i]));
sb.append(temp);
while(sb.length()<8){
sb.insert(0, "0");
}
sbAll.append(sb);
}
//将32位二进制数转化为long型整数
System.out.println(Long.parseLong(sbAll.toString(),2));
}
public static void tenToIp(String tenStr){
StringBuilder str = new StringBuilder(Long.toBinaryString(Long.parseLong(tenStr)));
while(str.length()<32){
str.insert(0,"0");
}
ArrayList<Long> list = new ArrayList<Long>();
for(int i=0;i<str.length();i+=8){
String substr = str.substring(i,i+8);
list.add(Long.parseLong(substr,2));
}
for(int i=0;i<list.size()-1;i++){
System.out.print(list.get(i));
System.out.print(".");
}
System.out.println(list.get(list.size()-1));
}
}
37.统计每个月兔子的总数
递归问题,每个月的兔子总数等于上个月的兔子数加上这个月出生的兔子数,f(n)=f(n-1)+f(n-2),
f(n-1)是上个月的兔子数,f(n-2)为两个月前就有的兔子数,到这个月刚好是第三个月,可以生兔子了。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int month = sc.nextInt();
System.out.println(count(month));
}
}
public static int count(int month){
if(month == 1){
return 1;
}
else if(month == 2){
return 1;
}
else{
return count(month-1)+count(month-2);
}
}
}
61.放苹果
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时,所有苹果都必须放在一个盘子里,所以返回1;
当没有苹果可放时,定义为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&&M<=10&&N>=1&&N<=10){
System.out.println(applePlace(M,N));
}
else{
System.out.println(-1);
}
}
}
public static int applePlace(int M,int N){
if(M==0||N==1) return 1;
else if(M<N) return applePlace(M,M);
else return applePlace(M-N,N)+applePlace(M,N-1);
}
}
65.查找两个字符串a,b中的最长公共子串
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str1 = sc.next();
String str2 = sc.next();
String shortstr = str1.length()>str2.length() ? str2:str1;
String longstr = str1.length()>str2.length() ? str1:str2;
int max = 0;
String substr = "";
for(int i=0;i<shortstr.length();i++){
for(int j=i+1;j<=shortstr.length();j++){
if(longstr.contains(shortstr.substring(i,j))&&(j-i)>max){
substr = shortstr.substring(i,j);
max = j-i;
}
}
}
System.out.println(substr);
}
}
}
92.在字符串中找出连续最长的数字串
//注意处理输出即可,要求多个字符串挨着输出,不用空格,字符串和最后的数字之间有个逗号
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String str = sc.next();
ArrayList<String> list = new ArrayList<String>();
int max = 1;
if(str.length()!=0){
for(int i=0;i<str.length();i++){
int num = i;
String substr = "";
while((str.charAt(num)>='0')&&(str.charAt(num)<='9')){
substr = substr + str.charAt(num);
num++;
if(num>=str.length()){
break;
}
}
if(substr.length()>=max){
list.add(substr);
max = substr.length();
}
}
if(list.size()!=0&&list!=null){
for(int i=0;i<list.size();i++){
if(list.get(i).length() == max){
System.out.print(list.get(i));
}
}
System.out.print(",");
System.out.println(max);
}
else{
System.out.println("");
}
}
else{
System.out.println("");
}
}
}
}
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 sum1 = 0,sum2 = 0;
int index = 0;
int[] rest = new int[num];
for(int i=0;i<num;i++){
int temp = sc.nextInt();
if(temp % 5 == 0){
sum1 += temp;
}
else if(temp % 3 == 0){
sum2 += temp;
}
else{
rest[index++] = temp;
}
}
System.out.println(isEqual(sum1,sum2,rest,0));
}
}
public static boolean isEqual(int sum1,int sum2,int[] rest,int index){
//一定要找好递归基
if(index == rest.length && sum1 == sum2){
return true;
}
else if(index == rest.length && sum1 != sum2){
return false;
}
else{
//剩余数字要么放在sum1中,要么放在sum2中
return (isEqual(sum1+rest[index],sum2,rest,index+1))||
(isEqual(sum1,sum2+rest[index],rest,index+1));
}
}
}
99.自守数
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 count = 0;
//0和1也是自守数
for(int i=0;i<=num;i++){
String i_str = String.valueOf(i);
String sqr = String.valueOf(i*i);
//必须是在尾部出现,所以不能用contains()方法
if(sqr.indexOf(i_str) == sqr.length()-i_str.length()){
count++;
}
}
System.out.println(count);
}
}
}
104.字符串分割
/*
2
abc
123456789
注意,上面那只是一组完整的输入,包括一个整数和几行字符串,所以不能用只一个for循环获取输入,那样得到的只是一个输入
*/
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//换成sc.hasNextLine()就不对了,不知道为啥
while(sc.hasNext()) {
int num = sc.nextInt();
for(int n=0;n<num;n++) {
String str1 = sc.next();
if (str1.length() > 0) {
if (str1.length() < 8) {
for (int j = 1; str1.length() < 8; j++) {
str1 = str1 + "0";
}
System.out.println(str1);
} else if (str1.length() == 8) {
System.out.println(str1);
} else {
int n1 = str1.length() % 8;
if (n1 > 0) {
for (int m = 1; m <= 8 - n1; m++) {
str1 = str1 + "0";
}
}
for (int i = 0; i < str1.length(); i += 8) {
System.out.println(str1.substring(i, i + 8));
}
}
}
}
}
}
}
看看别人的答案多么简洁
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();
for(int i=0; i<n; i++) {
String temp = sc.next();
while(temp.length()%8!=0) {
temp += "0";
}
for(int j=0; j<temp.length(); j+=8) {
System.out.println(temp.substring(j, j+8));
}
}
}
}
}
108.求最小公倍数
import java.util.Scanner;
public class Main {
/**
求最大公约数可以用辗转相除法,
先取两数之中较大的数作为被除数,较小的数作为除数,
以除数和余数反复做除法运算,当余数为0时,取当前算式除数为最大公约数。
*/
public static int getResult(int m ,int n){
if(m<n){
int temp=m;
m=n;
n=temp;
}
int k=0;
while(n!=0){
k=m%n;
m=n;
n=k;
}
return m;
}
public static void main(String[] args) {
Scanner reader = new Scanner(System.in);
while(reader.hasNext()){
int m = reader.nextInt();
int n = reader.nextInt();
//最小公倍数等于两数乘积除以最大公约数
System.out.println(m*n/getResult(m, n));
}
}
}
46.按字节截取字符串
```java
/**
* 判断一个字符是否是汉字
* PS:中文汉字的编码范围:[\u4e00-\u9fa5]
*
* @param c 需要判断的字符
* @return 是汉字(true), 不是汉字(false)
*/
public static boolean isChineseChar(char c) {
return String.valueOf(c).matches("[\u4e00-\u9fa5]");
}
import java.util.*;
/**
汉字占两个字节
*/
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(sc.hasNext()) {
String str = sc.next();
char[] ch = str.toCharArray();
int num = sc.nextInt();
int count = 0;
StringBuilder res = new StringBuilder();
for(int i=0;i<ch.length;i++){
if((ch[i]>='a'&&ch[i]<='z')||(ch[i]>='A'&&ch[i]<='Z')){
if(count >= num){
break;
}
else{
res.append(ch[i]);
count++;
}
}
else{
if(count == num){
break;
}
//count > num,则删除上一个添加进去的汉字
else if(count > num){
res.deleteCharAt(res.length()-1);
}
else{
res.append(ch[i]);
count += 2;
}
}
}
System.out.println(res.toString());
}
}
}