public class Test2 {
创新互联专业为企业提供容县网站建设、容县做网站、容县网站设计、容县网站制作等企业网站建设、网页设计与制作、容县企业网站模板建站服务，10余年容县做网站经验，不只是建网站，更提供有价值的思路和整体网络服务。
public static void main(String[] args) {
int oneDesk;//第一张桌子价格
int twoDesk;//第二张桌子价格
int threeDesk;//第三张桌子价格
for(int i=1;i4001;i++){//总价是4000，所以第一张桌子价格只能在1和4000之间
oneDesk=i;
twoDesk=oneDesk-400;
threeDesk=twoDesk*2;
if(oneDesk+twoDesk+threeDesk==4000twoDesk0threeDesk0){
System.out.println("第一张桌子的价格"+oneDesk);
System.out.println("第二张桌子的价格:"+twoDesk);
System.out.println("第三张桌子的价格:"+threeDesk);
}
}
}
}
方法一：
import java.util.ArrayList;
import java.util.List;
public class test10 {
// 解题思路：先带走猫，后带走狗，再把猫带回，把鱼带过去，最后再把猫带过去即可
// 定义两个集合，存放，带过去的动物，和剩下的动物
static ListString there = new ArrayListString();
static ListString here = new ArrayListString();
public static void main(String[] args) {
here.add("cat");
here.add("dog");
here.add("fish");
test10 test10 = new test10();
test10.take();
}
// 判断动物是否安全
public boolean isSafty(ListString list) {
// 如果一个集合中同时出现了猫和狗，猫和鱼的都认为不安全
if (list.add("dog") list.add("cat") || list.add("cat")
list.add("fish")) {
return false;
}
return true;
}
public void take() {
// 得到要带走的动物
String anim = here.get(0);
// 从剩下的集合中删除
here.remove(here.get(0));
if (anim.equals("cat")) {
// 添加到以带过去的集合里面
there.add(anim);
// 继续带下一个动物
if (here.isEmpty()) {
System.out.println();
System.out.println("最后在把" + anim + "带走了");
return;
} else {
System.out.println("带走了" + anim);
System.out.print("剩下：");
for (String s : here) {
System.out.print(s + " ");
}
System.out.println();
System.out.println("----------------------------");
take();
}
} else if (anim.equals("dog")) {
there.add(anim);
System.out.println("然后把" + anim + "带走");
// 判断是否安全，之后继续带下一个动物
if (isSafty(there)) {
take();
} else {
String animal = there.get(0);
there.remove(animal);
here.add(animal);
System.out.println("然后把" + animal + "带回");
// 继续带下一个动物
take();
}
} else if (anim.equals("fish")) {
System.out.print("之后把" + anim + "带走");
take();
}
}
}
方法二：
import java.util.ArrayList;
import java.util.Random;
/*
* 需求:
* 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
* 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
* 编程解决猫狗鱼过河问题。
* 分析:
* 定义猫,狗,鱼元素.定义两岸集合.定义方法判断不和谐状况.
* 步骤:
* 1.将猫狗鱼抽象为三个String型变量.将两岸抽象为两个集合.
* 2.定义判断是否和谐方法.
* */
public class Test10 {
public static void main(String[] args) {
//开始过河.
doTransport();
}
public static void doTransport() {
// 抽象出猫,鱼,狗和两岸.
ArrayListString arr1 = new ArrayListString();
ArrayListString arr2 = new ArrayListString();
arr1.add("鱼");
arr1.add("猫");
arr1.add("狗");
// 农夫将要携带到船上动物.(前一字符表示农夫当前携带动物,后一字符表示上次农夫携带的动物,为了让农夫不出现重复拿同一个动物的情况)
System.out.println("农夫,猫,鱼,狗都在此岸,开始过河.\n");
String[] boat ={"-","-"};
while (arr1.size() 0) {
move(arr1, arr2, boat);
}
System.out.println("\n农夫,猫,鱼,狗都到达彼岸.");
}
public static void move(ArrayListString arr1, ArrayListString arr2,String[] boat) {
//农夫船上是否有动物,有则不需随机选择携带.
if (boat[0].equals("-")) {
int one=0;
do{
// 农夫从此岸随机带上一个动物.
one = new Random().nextInt(arr1.size());
}while(arr1.get(one).equals(boat[1]));
boat[1]=boat[0];
boat[0] = arr1.get(one);
arr1.remove(one);
}
// 判断此岸是否和谐
if (ifNice(arr1)) {
// 此岸和谐,农夫则将动物送去彼岸.
arr2.add(boat[0]);
System.out.println("---农夫带" + boat[0] + "去彼岸 ");
//首先判断是否将三个动物都放彼岸,是则无需判断是否和谐.
if(arr2.size()==3){
return;
}
// 判断彼岸是否和谐.
if (ifNice(arr2)) {
// 彼岸和谐,农夫则完成此次运送.
boat[1]=boat[0];
boat[0] ="-";
System.out.println(" 农夫单独回此岸---");
} else {
// 彼岸不和谐,农夫则将岸上动物与携带动物交换.送回此岸.
boat[0]=arr2.get(0);
System.out.println(" 农夫带" +boat[0]+ "回此岸---");
arr2.remove(0);
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
} else {
// 如果此岸不和谐则放回此岸.
arr1.add(boat[0]);
boat[1]=boat[0];
boat[0]="-";
}
}
public static boolean ifNice(ArrayListString arr) {// 判断是能否共存.
if ((arr.contains("猫") arr.contains("狗"))
|| (arr.contains("鱼") arr.contains("猫"))) {
return false;
} else {
return true;
}
}
}
“while(a.size()1)”是要保证在每次循环的时候检查是否剩余的小孩数大于1，大于1才循环，等于1直接就是结果。我有新解：不可能是500. 如果报到3的人退出后.是继续下一个人往下报的话. 那500应该在第二轮就被淘汰掉了.结果是436.如果报到3的人退出后.是从头开始报的话.500在倒数第2个被淘汰掉.然后淘汰掉1. 结果是2所以，程序应该是：public class Count3Quit {
public static void main(String[] args) {
boolean[] arr = new boolean[500];
for(int i=0; iarr.length; i++) {
arr[i] = true;
}
int leftCount = arr.length;
int countNum = 0;
int index = 0;
while(leftCount 1) {
if(arr[index] == true) {
countNum ++;
if(countNum == 3) {
countNum = 0;
arr[index] = false;
leftCount --;
}
}
index ++;
if(index == arr.length) {
index = 0;
}
}
for(int i=0; iarr.length; i++) {
if(arr[i] == true) {
System.out.println(i);
}
}
}
}
代码如下：
import java.util.Arrays;
public class App53 {
public static void main(String[] args) {
String s = "12 335 4456 111 7799 5";
// 将原字符串通过空格分割成字符串数组
String[] numbers = s.split(" ");
// 进行排序
Arrays.sort(numbers,(x, y) - {
// 如果 x 大于3位，截取后3位
if (x.length() 3) {
x = x.substring(x.length() - 3, x.length());
}
// 如果 y 大于3位，截取后3位
if (y.length() 3) {
y = y.substring(y.length() - 3, y.length());
}
// 转换成整型并比较大小
return Integer.valueOf(x).compareTo(Integer.valueOf(y));
});
// 将排序后的结果拼接成字符串
String result = String.join(" ", numbers);
// 输出结果
System.out.println("排序前：" + s);
System.out.println("排序后：" + result);
}
}
你好，
依照题意，次数一个四位数，所以范围是1000——9999
算法如下：
for (int j = 1000; j10000; j++) {
int addResultForward = j%100;/*得到后两位数*/
int addResultBack = (int)j/100;/*得到前两位数，*/
int addResult = addResultForward + addResultBack;
/*算出两者之和*/
if(j == addResult*addResult)打印结果：...;
}
算法绝对精炼！！！
public static int [] getRemoveSame(int [] srcArray){
ListInteger list = new ArrayListInteger();
for (int i = 0; i srcArray.length; i++) {
//如果list里已经有数组的某个元素，则不添加到list中，进行下次循环
if (list.contains(srcArray[i])) {
continue;
}
list.add(srcArray[i]);
}
int [] newArray = new int[list.size()];
int index = 0;
for (int a : list) {
newArray[index++] = a;
}
return newArray;
}
