1.给我一个字符串，例如I love java,输出： java love Ipublic class StringReverse {
public void swap(char[] arr, int begin, int end) {
while(begin < end) {
char temp = arr[begin];
arr[begin] = arr[end];
arr[end] = temp;
begin++;
end--;
}
}
//I love java
public String swapWords(String str) {
char[] arr = str.toCharArray();
swap(arr, 0, arr.length - 1);
int begin = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] == ' ') {
swap(arr, begin, i - 1);
begin = i + 1;
}
}
swap(arr, begin, arr.length-1);
return new String(arr);
}
public static void main(String[] args) {
String str = "I love java";
System.out.println(new StringReverse().swapWords(str));
}
}
1.输入一个正数n，输出所有和为n的连续正数序列。
分析：设定两个指针，min指向和为n的连续正数序列的最小值，max指向和为n的连续正数序列最大值。sum表示真正的和。
初始情况下,min、max和sum 都指向1.
当sum小于n时，max++；
当sum大于n时，min++;
当sum等于n时，输出整个序列。public class a {
public static void getAns(int n) {
int min = 1;
int sum = 1;
int max = 1;
while(min <= n/2+1) {
if(sum == n) {
for(int k = min; k<=max; k++) {
System.out.println(k+"");
}
System.out.println();
sum = sum - min;
min ++;
max ++;
sum = sum+max;
}
if(sum > n) {
sum = sum - min;
min ++;
} else {
max ++;
sum = sum + max;
}
}
}
public static void main(String[] args) {
getAns(15);
}}
2.给定一个排好序的链表，删除链表中重复的结点，返回链表头指针。
分析：(1)链表中重复的结点不需要保留一个，要全部删除。
(2)因为相同的结点全部要删除，所以我们设定三个指针，node指向当前节点,prev指向前驱，还有一个指向后继结点。一旦遇到node和后继结点相等，就node++,知道没有重复的再移动prev.
(3)注意：头结点也可能有重复，所以也可能被删除，所以需要定义一个root指向头结点。public class a {
// 结点定义，包括当前结点的值和next指向
private static class ListNode {
private int val;
private ListNode next;
public ListNode() {
}
public ListNode(int val) {
this.val = val;
}
public String toString() {
return val + "";
}
}
// 删除节点的函数
public static ListNode delete(ListNode head) {
if (head == null)
return null;
if (head.next == null)
return head;
// 定义一个临时的头结点，因为头结点也可能被删除
ListNode root = new ListNode();
root.next = head;
ListNode prev = root;
ListNode node = head;
while (node != null && node.next != null) {
if (node.val == node.next.val) {
//若有连续相同的结点，则node要一直++
while (node.next != null && node.next.val == node.val)
node = node.next;
prev.next = node.next;
} else {
prev.next = node;
prev = prev.next;
}
node = node.next;
}
return root.next;
}
//打印出来删除后的结果
private static void print(ListNode head) {
while (head != null) {
System.out.print(head + "->");
head = head.next;
}
System.out.println("null");
}
public static void main(String[] args) {
// 按照结点的定义新建一个链表
ListNode n1 = new ListNode(1);
ListNode n2 = new ListNode(1);
ListNode n3 = new ListNode(2);
ListNode n4 = new ListNode(2);
ListNode n5 = new ListNode(2);
ListNode n6 = new ListNode(3);
ListNode n7 = new ListNode(5);
n1.next = n2;
n2.next = n3;
n3.next = n4;
n4.next = n5;
n5.next = n6;
n6.next = n7;
n7.next = null;
//调用delete函数，传入n1的值，当成头结点
ListNode result = delete(n1);
print(result);
}
}
3.对于一个有序数组，我们通常采用二分查找的方式来定位某一元素，请编写二分查找的算法，在数组中查找指定元素。
给定一个整数数组A及它的大小n，同时给定要查找的元素val，请返回它在数组中的位置(从0开始)，若不存在该元素，返回-1。若该元素出现多次，请返回第一次出现的位置。
分析：重点在返回第一次出现的位置。public class c {
public static int getPos(int[] A, int n, int val) {
int low = 0, high = n - 1, mid;
if (n == 0 || A == null)
return -1;
while (low <= high) {
mid = (low + high) / 2;
//当第一次找出相等的位置后需要继续向前查找，最后返回第一次出现的位置
if (val == A[mid]) {
for(int j = mid; j >= 0; j--) {
if(A[j] != A[mid]) {
mid = j + 1;
break;
}
else if(A[j] == A[mid]) {
mid = j;
continue;
}
}
return mid;
} else if (val < A[mid])
high = mid - 1;
else
low = mid + 1;
}
return -1;
}
public static void main(String[] args) {
int A[] = { 4, 4, 5, 5, 5, 5 };
int val = 4;
int n = A.length;
int result = getPos(A, n, val);
System.out.println(result);
}
}
4.对于一个字符串，请设计一个高效算法，找到第一次重复出现的字符。
给定一个字符串(不一定全为字母)A及它的长度n。请返回第一个重复出现的字符。保证字符串中有重复字符，字符串的长度小于等于500。
方法1：这是前辈给出的算法，利用HashSet的特性，即不允许重复放入元素，所以一旦检测到重复元素就返回false。对于本道题来说，这种方法简洁且容易理解，能高效实现功能，但是这种方法普适性较差。import java.util.HashSet;
public class g {
public static char findFirstRepeat(String A, int n) {
HashSet hs=new HashSet();
int length=A.length();
//利用toCharArray()将String类型转化为char类型
char[] a=A.toCharArray();
for(int i=0;i < length;i++)
{
boolean b=hs.add(a[i]);//通过往hashset塞值(hashset不准有重复元素)，判断当前一段数据中是否有重复元素，一但有，立刻返回
if(b==false)
{
return a[i];
}
}
return'0';
}
public static void main(String[] args) {
String A = "qywyer23tdd";
int n = A.length();
char b = findFirstRepeat(A, n);
System.out.println(b);
}
}
方法2：利用了哈希存储，将给定字符串以键值对形式存储在哈希Map中，key就是每一个字符，value就是每个字符出现的次数。存好后再按顺序遍历Map，找出第一次出现次数不为1的即可。返回。
注意：基于hash的存储是很高效的一种方式，存储键值对方便查找，可以根据key查找value,或者根据value查找key，或者查找特殊的字符等。
延伸：返回第一个只出现一次的字符，返回最后一个出现次数不为1的字符，返回所有出现次数为1的字符或者出现次数不为1的字符，返回给定出现次数的字符等等。import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
public class g {
private static void findFirstRepeat(String A, int n) {
int sum = 1;//新插入的key-value给value赋初始值都为1
//用LinkedHashMap来存储键值对
//HashMap插入和输出顺序不一样
//但LinkedHashMap插入和输出顺序相同，即先存的先显示，也就是尾插
//HashSet要求不能存重复元素，但HashMap和LinkedHashMap可以存重复元素。
Map hashMap = new LinkedHashMap
();
for (int i = 0; i < n; i++) {
//将main中传过来的String类型参数一个字符一个字符的转化为char类型，方便处理。
char item = A.charAt(i);
//再将每一个char类型的字符转化为String类型。这一步操作和上一步操作作用是分离出每一个字符。
String item2 = String.valueOf(item);
String key = item2;
// 判断是否包含指定的键值
boolean contains = hashMap.containsKey(key);
if (contains) { // 如果条件为真
sum++;
hashMap.put(item2, sum);// 输出信息
} else {
sum = 1;
hashMap.put(item2, sum);
}
}
//输出存进哈希表中的所有键值对
System.out.println(hashMap);
//以下是通过给定的value值反查key的过程
//将所有的键值对存在一个entrySet中
//遍历entrySet,若找到value等于给定的value值，则将其对应key值存在keyList中。
List keyList = new ArrayList();
for (Entry e : hashMap.entrySet()) {
if (e.getValue().equals(2)) {
keyList.add(e.getKey());
}
}
//最后遍历keyList，输出第一次出现的key即可。
for (String i : keyList) {
System.out.println(i);
break;
}
}
public static void main(String[]args) {
String A = "qywyer2333333333tdd";
int n = A.length();
findFirstRepeat(A, n);
}
}
关于类型转化问题：(1)String---------》char / char[ ]
String str = "ab";
char str1 = str.charAt(0); //得到a
char str2 = str.charAt(1); //得到b
char[ ] str3 = str.toCharArray();
System.out.println (Arrays.toString(str3));
(2)char / char[]-----------》String
char m = 'a';
String str = String.valueOf(m);
String str2 = m + " ";
char[] m = {'a','b'};
String str3 = String.copyValueOf(m);
String str4 = new String(m);
(3)int -----------》 String
int i;
String s = String.valueOf(i);
String s = Integer.toString(i);
String s = "" + i;
(4)String ----------》 int
int i = Integer.parseInt([String]);
i = Integer.parseInt([String],[int radix]);
int i = Integer.valueOf(my_str).intValue();
关于哈希存储的处理方案(本人亲试！) ：(1)根据key来查找，判断是否包含给定的key。
boolean contains = hashMap.containsKey(key);
if (contains) { // 如果条件为真
System.out.println("存在"+key);
} else {
System.out.println("不存在" + key);
}
(2)根据value来查找，判断是否包含给定的value.
boolean contains = hashMap.containsValue(Value);
if (contains) { // 如果条件为真
System.out.println("存在"+value);
} else {
System.out.println("不存在" +value);
}
(3)利用keySet遍历所有的key值。
for (Object key : hashMap.keySet()) {
System.out.println("key= " + key + " value " + hashMap.get(key));
}
1.合并两个排序的链表
思路：定义两个指针，一个指向list1,一个指向List2,定义一个新链表，List1和list2中哪个小就复制到新链表中。注意判断list1和list2是否为空！！！
本题是利用递归来实现的。/*
public class ListNode {
int val;
ListNode next = null;
ListNode(int val) {
this.val = val;
}
}*/
public class Solution {
public ListNode Merge(ListNode list1,ListNode list2) {
if(list1 == null) {
return list2;
}
if(list2 == null) {
return list1;
}
ListNode s = null;
if(list1.val < list2.val) {
s = list1;
s.next = Merge(list1.next, list2);
} else if(list1.val >= list2.val) {
s = list2;
s.next = Merge(list1, list2.next);
}
return s;
}
}
处理二进制问题：
两个int32整数m和n的二进制表达，有多少个位(bit)不同么？
(1)m^n后，将结果赋值给一个String类型的变量，循环遍历变量的每一位，看是否等于1.
(2)m^n后，将二进制结果的最后一位&1,然后将二进制右移。public class Solution {
/**
* 获得两个整形二进制表达位数不同的数量
*
*@param m 整数m
*@param n 整数n
*@return 整型
*/
public int countBitDiff(int m, int n) {
int x = m^n;
int y = 0;
while(x>0) {
if((x&1) == 1) {
y+=1;
}
x= x>>1;
}
return y;
}
}
水仙花问题：水仙花，即给定一个三位数，每一位的数字立方加起来等于这个数本身。
解析：import java.util.Scanner;
public class Solution {
public static void main(String[] args) {
Scanner san = new Scanner(System.in);
//从键盘输入最小值
int min = san.nextInt();
//从键盘输入最大值
int max = san.nextInt();
for(int mid = min; mid < max; mid++) {
int a = mid/100;
int b = mid%10;
int c = mid%100/10;
int sum = a*a*a + b*b*b + c*c*c;
if(sum == mid) {
System.out.println(mid);
}
}
}
}
题目：从键盘输入m和n，定义n是第一个数，之后的每个数都是前一个的平方根
，一共有m个数，计算总和。import java.lang.Math;
import java.util.Scanner;
public class a {
public static void main(String[] args) {
//求平方根
Scanner scan = new Scanner(System.in);
float n = scan.nextFloat();
int m = scan.nextInt();
float sum = n;
for(int i=2;i<=m;i++) {
sum += Math.sqrt(n);
n = (float) Math.sqrt(n);
}
System.out.println("sum=" +sum);
}
}
题目：Java的一维数组在不知道长度的情况下怎样声明？(1) 不知道长度，所以不能直接声明大小
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class a {
public static void main(String[] args) {
//用ArrayList来实现添加数据
List list = new ArrayList();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数组");
//给定一个while循环
//保证输入一串数字，直接接收，并添加到list中，当输入0时结束输入
while(true) {
int a = scanner.nextInt();
if(a==0) {
break;
} else {
list.add(a) ;
}
}
int size = list.size();
//将list转成int型数组
Integer[] array = (Integer[])list.toArray(new Integer[size]);
//输出int型数组。
for(int i=0;i
System.out.print(array[i]+" ");
}
}
}
这样就得到一个从键盘输入的Int型数组，接下来就可以对数组进行各种操作。
符合一般情况下的需要多组测试用例的情况。
题目：给定一个正整数，编写程序计算有多少对质数的和等于这个输入的正整数，并输出结果，输出值小于1000.
测试用例：
输入：10
输出：2 ((3,7) 和(5，5))。import java.util.Scanner;
public class cc {
private static int cout(int number) {
int count = 0;
for (int i = 2; i < number; i++) {
for (int j = 2; j <= number / 2; j++) {
if (isPrime(i) && isPrime(j) && (i + j) == number) {
count++;
}
}
}
return count;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入给定的数字");
int a = scanner.nextInt();
int count = cout(a);
System.out.println("count=" + count);
}
public static boolean isPrime(int number) {
if (number < 2) {
return false;
}
for (int i = 2; i < number; i++) {
if (number % i == 0) {
return false;
} else {
continue;
}
}
return true;
}
}
2 . 题目：二分查找，在左区间输出0，右区间输出1.
逐渐逼近，保留6位。
注意特殊输入：
(1) key值小于输入临界最小值或者大于临界最大值。
(2) 临界最小值大于临界最大值。
(3) 两个临界值都为0，输出0。import java.util.Scanner;
public class cc {
public static int comp(int key, int num) {
if (key >= num) {
return 1;
} else {
return 0;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入最小临界值");
int a = scanner.nextInt();
System.out.println("请输入最大临界值");
int b = scanner.nextInt();
System.out.println("请输入需要比较的值");
int key = scanner.nextInt();
if (key < a || key > b) {
System.out.println("error");
} else if (key == 0 && a == 0 && b == 0) {
System.out.println("error");
} else {
while (a <= b) {
for (int i = 0; i < 6; i++) {
int num;
num = (a + b) / 2;
System.out.println("num=" + num);
int s = comp(key, num);
if (s == 0) {
b = num;
System.out.println("0");
} else {
a = num;
System.out.println("1");
}
}
break;
}
}
}
}
题目：镜像字符串，给定两个字符串，判断第二个是否为第一个的镜像字符串，是返回yes，否返回no.import java.util.Scanner;
public class b {
public static Boolean count(String str1, String str2) {
int p1 = 0;
int p2 = 0;
char[] st1 = str1.toCharArray();
char[] st2 = str2.toCharArray();
for (int i = 0; i < st1.length; i++) {
if (st1[i] == st2[0]) {
p1 = i;
}
}
while (p1 < st1.length && p2 < st2.length) {
if (st1[p1] == st2[p2]) {
if (p1 == st1.length) {
p1 = -1;
}
p1++;
p2++;
continue;
} else {
return false;
}
}
return true;
}
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入字符串");
String str1 = scanner.next();
String str2 = scanner.next();
if(str1.length()-str2.length()!=0) {
System.out.println("no");
return;
}
if (str1 == null || str1.length() <= 0 || str2 == null
|| str2.length() <= 0) {
System.out.println("error");
}
Boolean num = count(str1, str2);
if (num.equals(true)) {
System.out.println("yes");
} else {
System.out.println("no");
}
}
}
1、编写程序实现对给定的 4 个整数从大到小的顺序排列。package HomeWork01;
import java.util.Scanner;
public class HomeWork01 {
static int number=4; //输入4个数存放在数组中
static int[] t1 = new int[number];
public static void main(String[] args) {
HomeWork01 jiejie=new HomeWork01();
jiejie.shunxun();
}
void shunxun(){
System.out.println("请输入4个数：");
Scanner in_t1 = new Scanner(System.in);//循环输入数组
for(int i=0;i
t1[i]=in_t1.nextInt();}
for (int i = 0; i < t1.length; i++) {
int pos = i;
for (int j = i + 1; j < t1.length; j++) {
if (t1[pos] > t1[j])
pos = j;
}
if (pos != i) {
t1[i] = t1[i] + t1[pos];
t1[pos] = t1[i] - t1[pos];
t1[i] = t1[i] - t1[pos];
}
}
for (int i = t1.length - 1; i >= 0; i--)
System.out.print(t1[i] + "\t");
}
}
2、编写程序求一元二次方程的根。package HomeWork02;
import java.util.Scanner;
public class HomeWork02
//△=b^2-4ac的值,若△小于0,一元二次方程无根.若△等于0,一元二次方程有两个相等的根.若△大于0,一元二次方程有两个不相等的实数根
{
public static void main(String [] args){
Scanner sc = new Scanner(System.in);
System.out.println("输入2次方的系数");
int a = sc.nextInt();
System.out.println("输入1次方的系数");
int b = sc.nextInt();
System.out.println("输入0次方的系数");
int c = sc.nextInt();
if((b*b - 4*a*c)<0){//判断方程是否有解
System.out.println("方程无解！");
return;
}
else{
System.out.println("方程有解！");
}
double x1 = (-b + Math.sqrt(b*b - 4*a*c))/2*a;
double x2 = (-b - Math.sqrt(b*b - 4*a*c))/2*a;
System.out.println("根分别是 " + x1 + "\t" + x2);
}
}
3、编写程序，输入一个字符，判断它是否为小写字母，如果是，将它转换成大
写字母，否则，不转换。package HomeWork03;
import java.util.Scanner;
public class HomeWork03 {
public static void main(String[] args) {
//小写字母的ascll值为97-122
//大写字母的ascll值为65-90
System.out.println("请输入一个字母：\n");
Scanner input = new Scanner(System.in);
char zimu=input.next().charAt(0);
if (zimu>=97&&zimu<=122){//判断是否是小写字母
System.err.println("该字母是小写字母");
zimu=(char) (zimu-32);//如果是小写字母则 将其转换成大写字母
System.err.println("转换之后的大写字母是："+zimu);
}
else{
System.out.println("该字母不是小写字母！");
}
}
}
4、输入 3 个正数，判断能否构成一个三角形。package HomeWork04;
import java.util.Scanner;
public class HomeWork04 {
public static void main(String [] args){
int a;
int b;
int c;
System.out.println("请输入三个正整数：");
Scanner in=new Scanner(System.in);
a=in.nextInt();
b=in.nextInt();
c=in.nextInt();
if(a<=0||b<=0||c<=0)
{
System.out.println("输入的必须是正整数！");
}
if((a+b)>c&&(a+c)>b&&(b+c)>a)
{
System.out.println("能构成三角形！");
}
else{
System.out.println("不能构成三角形！");
}
}
}
5、编写程序，对输入的年、月、日，给出该天是该年的第多少天？package HomeWork05;
import java.util.Scanner;
public class HomeWork05 {
public static void main(String[]args){
Scanner sc =new Scanner(System.in);
System.out.print("年");
int year=sc.nextInt();
System.out.print("月");
int month=sc.nextInt();
System.out.print("日");
int day=sc.nextInt();
int days=0;
switch(month){
case 12:days+=30;
case 11:days+=31;
case 10:days+=30;
case 9:days+=31;
case 8:days+=31;
case 7:days+=30;
case 6:days+=31;
case 5:days+=30;
case 4:days+=31;
case 3:
if((year%4==0&&year%100!=0)||(year%400==0)){
days+=29;
}
else{
days+=28;
}
case 2:days+=31;
case 1:days+=day;
}
System.out.print("第" + days + "天");
}
}
6、编写程序，从键盘输入一个 0~99999 之间的任意数，判断输入的数是几位
数？package HomeWork06;
import java.util.Scanner;
public class HomeWork06 {
public static void main(String[]args){
Scanner sc =new Scanner(System.in);
System.out.print("请输入一个0~99999 之间的任意数");
int number=sc.nextInt();
if(number/10000>=1&&number/10000<10){
System.out.println(number+"\t是5位数");
}
else if(number/1000>=1){
System.out.println(number+"\t是4位数");
}
else if(number/100>=1){
System.out.println(number+"\t是3位数");
}
else if(number/10>=1){
System.out.println(number+"\t是2位数");
}
else if(number/1>=1){
System.out.println(number+"\t是1位数");
}
}
}
7、编写程序，给定一个学生成绩，给出相应等级：
90~100 优秀
80~89 良好
70~79 中等
60~69 及格
0~59 不及格package HomeWork07;
import java.util.Scanner;
public class HomeWork07 {
public static void main(String[] args) {
HomeWork07 jiejie=new HomeWork07();
jiejie.chengjie();
}
void chengjie(){
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生成绩：");
int a = sc.nextInt();
if(a>=90&&a<=100){
System.out.println("该学生的成绩是"+a+"\t成绩优秀");
}
else if(a>=80&&a<90){
System.out.println("该学生的成绩是"+a+"\t成绩良好");
}
else if(a>=70&&a<80){
System.out.println("该学生的成绩是"+a+"\t成绩中等");
}
else if(a>=60&&a<70){
System.out.println("该学生的成绩是"+a+"\t成绩及格");
}
else{
System.out.println("该学生的成绩是"+a+"\t成绩不及格");
}
}
}
8、编写程序，对输入的一个整数，按相反顺序输出该数。例如，输入为 3578，
输出为 8753。package HomeWork08;
import java.util.Scanner;
public class HomeWork08 {
public static void main(String[]args){
Scanner sc =new Scanner(System.in);
System.out.println("请输入一个整数：");
int read = sc.nextInt();
//方法一 reverse()API
System.out.println("方法一：");
StringBuilder sb = new StringBuilder(String.valueOf(read));
System.out.println(sb.reverse());
//方法二 将字符串转换成字符数组，反序输出
String str= read +"";
char fuzu[]=str.toCharArray();
String temp="";
for(int a=fuzu.length-1;a>=0;a--){
temp=temp+fuzu[a];
}
System.out.println("方法二：");
System.out.println(temp);
}
}
9、用 while 循环，计算 1~200 之间所有 3 的倍数之和。package HomeWork09;
public class HomeWork09 {
public static void main(String[] args) {
// 用while循环，计算1~200之间所有3的倍数之和。
int a=1;
int sum=0;
while(a<=200){
if(a%3==0){
sum=sum+a;
}
a++;
}
System.out.println("1~200之间所有3的倍数之和为:"+sum);
}
}
10、编写程序，输出 200~500 之间的所有素数。package HomeWork10;
public class HomeWork10 {
public static void main(String[] args) {
int num=200;
while (num<=500) {
boolean tag=true;//素数标记
for(int d=2;d<=num-1;d++){
if(num % d==0){
tag=false;
break;
}
}
if(tag){//如果是素数
System.out.println(num);
}
num++;
}
}
}
11、编写程序解决“百钱买百鸡”问题。公鸡五钱一只，母鸡三钱一只，小鸡
一钱三只，现有百钱欲买百鸡，共有多少种买法？package HomeWork11;
public class HomeWork11 {
public static void main(String[] args) {
/* 、编写程序解决“百钱买百鸡”问题。
* 公鸡五钱一只，母鸡三钱一只，
* 小鸡 一钱三只，
* 现有百钱欲买百鸡，共有多少种买法？ */
for(int g=0;g<=20;g++){
for(int m=0;m<=33;m++){
for(int x=0;x<=100-g-m;x++){
if(x % 3==0 && 5*g+m*3+x/3 == 100 && g+m+x ==100){
System.out.println("公鸡"+g+"只母鸡"+m+"只小鸡"+x+"只");
}
}
}
}
}
}
12、使用循环语句输出下面的图形。
#
# # #
# # # # #
# # # # # # #
# # # # # # # # #package HomeWork12;
public class HomeWork12 {
public static void main(String[] args) {
int aa=-1;
for( int a=0;a<5;a++){
aa+=2;
for(int b=1;b<=aa;b++){
System.out.print( "#" );
}
System.out.println();}
}
}
13、验证“鬼谷猜想”：对任意自然数，若是奇数，就对它乘以 3 再加 1；若是
偶数，就对它除以 2，这样得到一个新数，再按上述计算规则进行计算，一直进
行下去，最终必然得到 1。package HomeWork13;
import java.util.Random;;
public class HomeWork13 {
public static void main(String[] args) {
/*
* 验证“鬼谷猜想”：对任意自然数，若是奇数，
* 就对它乘以3再加1；若是 偶数，就对它除以2，
* 这样得到一个新数，
* 再按上述计算规则进行计算，
* 一直进 行下去，最终必然得到1。 */
int num;
Random rd=new Random();
//Integer.MAX_VALUE为最大的整数
num=1+rd.nextInt(Integer.MAX_VALUE);//产生数的范围-2[31]----2[31]-1
//System.err.println(rd.nextInt(100));//产生数>=0且<100
System.out.println("原本的数为"+num);
while(num!=1){
System.out.println("产生的新数是"+num);
if(num%2==0){
//偶数
num=num/2;
}
else{
num=num*3+1;
}
}
System.out.println(num);
}
}
14、编程求 1~10000 之间的所有“完全数”，完全数是该数的所有因子之和等于该数的数。例如，6 的因子有 1、2、3，且 6=1+2+3，所以 6 是完全数。package HomeWork14;
public class HomeWork14 {
public static boolean isyinzi(int num ){
int sum=0;
//判断一个整数是不是一个完全数
for(int d=num-1;d>=1;d--){
if(num%d==0){
sum+=d;
}
}
return sum==num;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
/*
* 编程求1~10000之间的所有“完全数”，
* 完全数是该数的所有因子之和等
* 于该数的数。例如，6的因子有1、2、3，
* 且6=1+2+3，所以6是完全数*/
for(int a=1;a<=1000;a++){
int num=a;
if(isyinzi(num)){
System.out.println(num);
}
}
}
}
15、一个整数的各位数字之和能被 9 整除，则该数也能被 9 整除。编程验证给
定的整数能否被 9 整除。package HomeWork15;
import java.util.Random;
public class HomeWork15 {
public static void panduan(int num){
int b=num/100;//百位数
int s=num%100/10;//十位数
int g=num%10;//个位数
if(num%9==0){
System.out.println(num+"能被9整除");
if((b+s+g)%9==0){
System.out.println("同时"+num+"的各个位数之和也能被9整除");
}
else{
System.out.println("但是"+num+"的各个位数之和不能被9整除");
}
}
else
System.out.println("next test!");
}
public static void main(String[] args) {
Random rd=new Random();
int shu=10+rd.nextInt(90);
shu =shu *9;
panduan(shu);
}
}
16、猴子吃桃问题。猴子第一天摘下若干个桃子，当时就吃了一半，还不过瘾，
就又吃了一个。第二天又将剩下的桃子吃掉一半，又多吃了一个。以后每天都吃
前一天剩下的一半零一个。到第 10 天在想吃的时候就剩一个桃子了,求第一天共
摘下来多少个桃子？package HomeWork16;
public class HomeWork16 {
public static void main(String[] args) {
int total=1;
int day=10;
for (int i = 10; i >0; i--) {
System.out.println("第"+day+"天，有桃子"+total+"颗");
total=(total+1)*2;
day--;
}
}
}
17、水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等
于它本身。(例如：1^3 + 5^3 + 3^3 = 153)。编程求出所有三位的水仙花数。package HomeWork17;
public class HomeWork17 {
public static void main(String[] args) {
for(int num=100;num<1000;num++){
if(isshuixian(num)){
System.out.println(num);
}
}
}
//判断一个数是不是水仙花数
public static boolean isshuixian(int num){
int b=num/100;
int s=num%100/10;
int g=num%10;
return Math.pow(b, 3)
+Math.pow(s, 3)
+Math.pow(g, 3)==num?true:false;
}
}
18、已知 XYZ+YZZ=532，其中，X、Y、Z 为数字，编程求出 X、Y 和 Z 的值。
19、古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔
子长到第三个月后每个月又生一对兔子，假如兔子都不***，问每个月的兔子总数
为多少？package HomeWork19;
import java.util.Scanner;
public class HomeWork19 {
/*
* 古典问题：有一对兔子，
* 从出生后第3 个月起每个月都生一对兔子，
* 小兔 子长到第三个月后每个月又生一对兔子，
* 假如兔子都不***，
* 问每个月的兔子总数 为多少？ */
public int rubbit(int mon){
if(mon<=2){
return 1;
}
else{
return rubbit(mon-1)+rubbit(mon-2);
}
}
public static void main(String[] args) {
int r=1;
int rr=1;
int rrr=1;
System.out.println("方法一：");
for(int a=1;a<=12;a++){
//12个月
if(a<=2){
r=1;
}
else{
//当前月等于前两个月之和
r=rr+rrr;
rrr=rr;
rr=r;
}
System.out.println(r*2);
}
System.out.println("方法二,求指定月份的兔子数量：");
HomeWork19 jisuan=new HomeWork19();
System.out.println("请输入月份：");
Scanner sc=new Scanner(System.in);
int yue=sc.nextInt();
System.out.println(yue+"月份的兔子数量是"+(jisuan.rubbit(yue))*2);
}
}
20、将一个正整数分解质因数。例如：输入 90，打印出 90=2*3*3*5。package HomeWork20;
import java.util.Scanner;
public class HomeWork20 {
public static void main(String[] args) {
System.out.println("请输入一个整数：");
Scanner sc=new Scanner(System.in);
int num=sc.nextInt();
System.out.println(num+"的质因数有：");
for(int i=2;i
while(num%i==0){
num/=i;
System.out.print(i+" ");
}
}
System.out.print(" "+num);
}
}
01.类的成员变量 猜数字游戏一个类A有一个成员变量v有一个初值100。定义一个类对A类的成员变量v进行猜。如果大了则提示大了小了则提示小了。等于则提示猜测成功。import java.util.*;
public class lianxi{
public static void main(String[] dsa){
A a=new A();
Scanner input=new Scanner(System.in);
while (1==1)
{
System.out.println("请猜测数字");
int i=input.nextInt();
if (i
{
System.out.println("小了");
continue;
}
else if (i>a.v)
{
System.out.println("大了");
continue;
}
else
{
System.out.println("恭喜你猜对了！");
break;
}
}
}
}
class A{
public int v=100;
}
02.类的成员变量 请定义一个交通工具(Vehicle)的类其中有: 属性速度(speed)体积(size)等等 方法移动(move())设置速度(setSpeed(int speed))加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象并通过方法给它初始化speed,size的值并且通过打印出来。另外调用加速减速的方法对速度进行改变。public class Vehicle{
private int speed;
private String size;
public void move(){
System.out.println("i'm moving");
}
public void setSpeed(int speed){
System.out.println("now i'm running with"+speed+"per hour");
}
public void speedUp(){
Vehicle v=new Vehicle();
v.setSpeed(1000);
}
public
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
