几道逻辑性强的java基础题
几道逻辑性强的java基础题java私塾教程视频中找了几个，感觉很有意思，分享一下
1、两个乒乓球队进行比赛，各出三人。甲队为a,b,c 三人，乙队为x,y,z 三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a 说他不和x 比，c 说他不和x,z 比，请编程序找出三队赛手的名单。
2、某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10 的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。请编写一个方法来实现上述加密算法。
3、企业发放的奖金根据利润提成。利润低于或等于10 万元时，奖金可提10%；利润高于10 万元，低于20 万元时，低于10 万元的部分按10%提成，高于10 万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40 万到60 万之间时高于40万元的部分，可提成3%；60 万到100 万之间时，高于60 万元的部分，可提成1.5%，高于100 万元时，超过100 万元的部分按1%提成，请编写程序，输入当月利润，求应发放奖金总数？
4、 老伯伯要带鱼、狗、猫过河到对岸.，有一条船，只能坐一个人，老伯每次只能带一样动物过河，当老伯不在的时侯狗会咬猫，猫会吃鱼.，请问怎么顺序过河呢？要求：编写程序，由程序来推出过河的顺序
5、参加会议:有人邀请A,B,C,D,E,F6个人参加一项会议，这6个人有些奇怪，因为他们有很多要求，已知：
（1）.A,B两人至少有1人参加会议。
（2）.A,E,F3人中有2人参加会议。
（3）.B和C两人一致决定，要么两人都去，要么两人都不去。
（4）.A,D两人中只1人参加会议。
（5）.C,D两人中也只要1人参加会议。
（6）.如果D不去，那么E也决定不去。
那么最后究竟有哪几个人参加了会议呢？
6、有一位厨师要从盛12斤油（a桶）的桶中倒出6斤油来，可是手边只有盛8斤油（b桶）和盛5斤油（c桶）的两个桶，问如何操作才能将6斤取出来呢?
7、有一根27厘米的细木杆，在第3厘米、7厘米、11厘米、17厘米、23厘米这五个位置上各有一只蚂蚁。木杆很细，不能同时通过一只蚂蚁。开始时，蚂蚁的头朝左还是朝右是任意的，它们只会朝前走或调头，但不会后退。当任意两只蚂蚁碰头时，两只蚂蚁会同时调头朝反方向走。假设蚂蚁们每秒钟可以走一厘米的距离。编写程序，求所有蚂蚁都离开木杆的最小时间和最大时间。
8、一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
9、程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：
(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。
(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,重复执行第一步。
(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。
10、用程序求解：
请回答下面10个问题：
1、第一个答案是b的问题是哪一个？
（a）2；（b） 3；（c）4；（d）5；（e）6
2、唯一的连续两个具有相同答案的问题是：
（a）2，3；（b）3，4；（c）4，5；（d）5，6；（e）6，7；
3、本问题答案和哪一个问题的答案相同？
（a）1；（b）2；（c）4；（d）7；（e）6
4、答案是a的问题的个数是：
（a）0；（b）1；（c）2；（d）3；（e）4
5、本问题答案和哪一个问题的答案相同？
（a）10；（b）9；（c）8；（d）7；（e）6
6、答案是a的问题的个数和答案是什么的问题的个数相同？
（a）b；（b）c；（c）d；（d）e；（e）以上都不是
7、按照字母顺序，本问题的答案和下一个问题的答案相差几个字母？
（a）4；（b）3；（c）2；（d）1；（e）0。（注：a和b相差一个字母）
8、答案是元音字母的问题的个数是：
（a）2；（b）3；（c）4；（d）5；（e）6。（注：a和e是元音字母）
9、答案是辅音字母的问题的个数是：
（a）一个质数；（b）一个阶乘数；（c）一个平方数；（d）一个立方数，（e）5的倍数
10、本问题的答案是：
（a）a；（b）b；（c）c；（d）d；（e）e。 今天看到scott说，最好的程序员不是最聪明的人，而是最好的外交家；
现在软件行业招人，有些面试题，，，我就不说了
想起上周active network来的面试，对于影响很大； 1、public class test{
//不是同时打比赛时
public static void main(String[] args){
String[] s1 = {"a","b","c"};
String[] s2 = {"x","y","z"};
for(int i=0;i<s1.length;i++){
for(int j=0;j<s2.length;j++){
if ( !(i==0 && j==0) && !(i==2 &&(j==0 || j==2)) ){
System.out.println(s1+" and " +s2+ " fight!");
}
}
}
}
}-----------------public class test{
//如果是同时开始比赛的话
String a,b,c;//甲队的
public test(String a,String b,String c){
this.a=a;
this.b=b;
this.c=c;
}
public String toString(){
return "\n"+"a V.S. "+a+" \n"+"b V.S. "+b+" \n"+"c V.S. "+c;
}
public static void main(String[] args){
String[] yi = {"x","y","z"};
ArrayList<test> ar = new ArrayList<test>();
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
for(int k=0;k<3;k++){
test t = new test(yi,yi,yi);
if(!t.a.equals(t.b) && !t.a.equals(t.c) && !t.b.equals(t.c)
&& !t.a.equals("x") && !t.c.equals("x") && !t.c.equals("z")){
ar.add(t);
}
}
}
}
for(Object obj:ar){
System.out.println(obj);
}
}
} 2、public class test{
public int encrp(int num){
int qian = (num/1000+5);
int bai = (num00/100 +5);
int shi = (num000/10+5);
int ge = (num+5);
return ge*1000+shi*100+bai*10+qian;
}
public static void main(String[] args) throws IOException{
BufferedReader br = new BufferedReader(new
InputStreamReader(System.in));
System.out.println("请输入一个四位数：");
int num = Integer.parseInt(br.readLine());
System.out.println(new test().encrp(num));
}
} 3、public class test{
public double money(int num){
if(num <=10){
return num*0.1;
}else if(num <= 20){
return 1+(num-10)*0.075;
}else if(num <= 40){
return 1.75+(num-20)*0.05;
}else if(num <= 60){
return 2.75+(num-40)*0.03;
}else if(num <= 100){
return 3.35+(num-60)*0.015;
}else {
return 3.95+(num-100)*0.01;
}
}
public static void main(String[] args) throws IOException{
System.out.println("请输入当月利润(万元)：");
Scanner sc = new Scanner(System.in);
System.out.println(new test().money(sc.nextInt()));
}
} 4、import java.util.Iterator;
import java.util.LinkedList;
public class test {
// 定义三个String对象
public static final String rabbitName = "猫";
public static final String wolfName = "狗";
public static final String cabbageName = "鱼";
// 判断两个对象之间关系是否友好
public static boolean isFriendly(Goods goods1, Goods goods2) {
if (goods1 != null) {
//猫不会和其他两位共存，只能单独
if (goods1.getGoodsName().trim().equals(rabbitName)) {
if (goods2 == null) {
return true;
} else {
return false;
}
//鱼和狗可以共存
} else if (goods1.getGoodsName().trim().equals(wolfName)) {
if (goods2 == null
|| goods2.getGoodsName().trim().equals(cabbageName)) {
return true;
} else {
return false;
}
//狗和鱼可以共存
} else if (goods1.getGoodsName().trim().equals(cabbageName)) {
if (goods2 == null
|| goods2.getGoodsName().trim().equals(wolfName)) {
return true;
} else {
return false;
}
//什么也不是的时候
} else {
return false;
}
//空无一物的时候是友好的
} else {
return true;
}
}
// test主程序
public static void main(String[] args) {
//两个列表一个移之前，一个移之后
boolean isSuccess = false;
LinkedList<Goods> beforeCrossing = new LinkedList<Goods>();
LinkedList<Goods> afterCrossing = new LinkedList<Goods>();
beforeCrossing.add(new Goods(cabbageName));
beforeCrossing.add(new Goods(rabbitName));
beforeCrossing.add(new Goods(wolfName));
//只要没成功就不停的执行
while (!isSuccess) {
//取第一个
Goods goods1 = beforeCrossing.getFirst();
System.out.println(goods1.getGoodsName() + " 被取走了");
beforeCrossing.removeFirst();
//判断是否已经取完
if (beforeCrossing.isEmpty()) {
afterCrossing.addLast(goods1);
isSuccess = true;
System.out.println("全部移动完毕！");
} else {
//没有取完的话，首先看有谁留下了
Iterator<Goods> it = beforeCrossing.iterator();
Goods[] beforeCro = new Goods;
for (int i = 0; it.hasNext(); i++) {
beforeCro = it.next();
System.out.println(beforeCro.getGoodsName() + " 留了下来");
}
//看留下的两位是否关系友好，或者是一位，或者没了
if (isFriendly(beforeCro, beforeCro)) {
//留下的友好，且对岸没有时，成功已过去
if (afterCrossing.isEmpty()) {
afterCrossing.addLast(goods1);
System.out.println(goods1.getGoodsName() + " 被成功的放到了对岸");
//留下的友好，但是对岸已经有东西了，
} else {
Goods goods2 = afterCrossing.getFirst();
//对岸的东西和将要移的东西，是否友好，好则移动
if (isFriendly(goods1, goods2)) {
afterCrossing.addLast(goods1);
System.out.println(goods1.getGoodsName()
+ " 被成功的放到了对岸");
//对岸的东西和将要移动的东西，不友好，将对岸的东西移回去，并加到末尾去，要移动的留下
} else {
beforeCrossing.addLast(goods2);
afterCrossing.removeFirst();
System.out.println(goods1.getGoodsName() + " 与 "
+ goods2.getGoodsName() + "并不和睦 于是把 "
+ goods2.getGoodsName() + "带了回来 并将 "
+ goods1.getGoodsName() + " 留了下来");
}
}
} else {
//留下的两位看来并不友好
beforeCrossing.addLast(goods1);
System.out.println("很可惜 留下来的两个东西并不和睦 于是 " + goods1.getGoodsName() + " 又被放了回去");
}
}
}
}
}
// 货物类，动物类什么的，反正方法类似，拷贝的程序
class Goods {
// 货物名称
∵ String goodsName;
// 默认构造方法
public Goods(String goodsName) {
this.goodsName = goodsName;
}
// 获得货物名称
public String getGoodsName() {
return goodsName;
}
} 5、public class HuiYi{
public static void main(String [] args){
HuiYi.t1();
}
∵ static void t1(){
for(int a1=1;a1<=2;a1++){
for(int a2=1;a2<=2;a2++){
for(int a3=1;a3<=2;a3++){
for(int a4=1;a4<=2;a4++){
for(int a5=1;a5<=2;a5++){
for(int a6=1;a6<=2;a6++){
if(
tm1(a1,a2,a3,a4,a5,a6)
&& tm2(a1,a2,a3,a4,a5,a6)
&& tm3(a1,a2,a3,a4,a5,a6)
&& tm4(a1,a2,a3,a4,a5,a6)
&& tm5(a1,a2,a3,a4,a5,a6)
&& tm6(a1,a2,a3,a4,a5,a6)
){
System.out.println"a1="+a1+",a2="+a2+",a3="+a3+",a4="+a4+",a5="+a5+",a6="+a6);
}
}
}
}
}
}
}
}
∵ static int countGo(int ... as){
int sum = 0;
for(int a : as){
if(a == 1){
sum ++;
}
}
return sum;
}
∵ static boolean tm1(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a1,a2)>=1){
return true;
}
return false;
}
∵ static boolean tm2(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a1,a5,a6)==2){
return true;
}
return false;
}
∵ static boolean tm3(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a2,a3)==0 || countGo(a2,a3)==2){
return true;
}
return false;
}
∵ static boolean tm4(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a1,a4)==1){
return true;
}
return false;
}
∵ static boolean tm5(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a3,a4)==1){
return true;
}
return false;
}
∵ static boolean tm6(int a1,int a2,int a3,int a4,int a5,int a6){
if(countGo(a4)==0){
if(countGo(a5)==0){
return true;
}else{
return false;
}
}
return true;
}
} 6、public class DaoYou{
public static void main(String args[]){
DaoYou t = new DaoYou();
t.t1();
}
∵ void t1(){
Tong t1 = new Tong();
t1.max = 10;
t1.now = 10;
Tong t2 = new Tong();
t2.max = 7;
t2.now = 0;
Tong t3 = new Tong();
t3.max = 3;
t3.now = 0;
Tong ts[] = new Tong;
ts = t1;
ts = t2;
ts = t3;
MySet set = new MySet();
set.add(ts);
stepDaoYou(set);
}
int end = 5;
∵ void stepDaoYou(MySet setKeNeng){
for(Object objs : setKeNeng.getAll()){
Tong ts[] = (Tong[])objs;
//1:判断是否已经已完成
if(ts.now==end || ts.now==end || ts.now==end){
System.out.println("倒油完成---"+ts.now+","+ts.now+","+ts.now);
break;
}
//2:递归
stepDaoYou(keNengDaoYou(ts));
}
}
MySet yiDao = new MySet();
∵ MySet keNengDaoYou(Tong [] ts){
MySet setKeNeng = new MySet();
System.out.println("A=="+ts.now+",B=="+ts.now+",C=="+ts.now);
for(int i=0;i<ts.length;i++){
for(int j=0;j<ts.length;j++){
//1:不能自己给自己倒
if(i==j){
continue;
}
//2：算出能倒多少
int canDaoYou = ts.canOut();
if(ts.canOut() > ts.canIn()){
canDaoYou = ts.canIn();
}
//3:模拟倒
ts.out(canDaoYou);
ts.in(canDaoYou);
//4:判断这个倒油的步骤是否已经出现过了
if(yiDao.contains("A="+ts.now+",B="+ts.now+",C="+ts.now)){
//已经出现了，不能这么倒，否则就死循环了
//还回去
ts.in(canDaoYou);
ts.out(canDaoYou);
//
continue;
}
//5:说明可以这么倒油
//5.1:先在已倒里面加入新的可能的倒油情况
yiDao.add("A="+ts.now+",B="+ts.now+",C="+ts.now);
//5.2添加可能性
Tong newTs[] = new Tong;
Tong t1 = new Tong();
t1.max = ts.max;
t1.now = ts.now;
Tong t2 = new Tong();
t2.max = ts.max;
t2.now = ts.now;
Tong t3 = new Tong();
t3.max = ts.max;
t3.now = ts.now;
newTs = t1;
newTs = t2;
newTs = t3;
System.out.println("keneng------------------>"+"A="+ts.now+",B="+ts.now+",C="+ts.now);
setKeNeng.add(newTs);
//6:把油还回去
ts.in(canDaoYou);
ts.out(canDaoYou);
}
}
return setKeNeng;
}
}
class Tong{
//最大值
public int max = 0;
//当前值
public int now = 0;
public void in(int a){
now += a;
}
public void out(int a){
now -=a;
}
public int canIn(){
return (max - now);
}
public int canOut(){
return now;
}
} 7、public class MaYi{
public static void main(String [] args){
MaYi t = new MaYi();
t.t1();
}
∵ void t1(){
Ant a1 = new Ant();
Ant a2 = new Ant();
Ant a3 = new Ant();
Ant a4 = new Ant();
Ant a5 = new Ant();
for(int i=1;i<=2;i++){
for(int j=1;j<=2;j++){
for(int k=1;k<=2;k++){
for(int m=1;m<=2;m++){
for(int n=1;n<=2;n++){
//做蚂蚁的初始化
a1.direct = i;
a1.site = 3;
a1.alreadyGone = false;
a2.direct = j;
a2.site = 7;
a2.alreadyGone = false;
a3.direct = k;
a3.site = 11;
a3.alreadyGone = false;
a4.direct = m;
a4.site = 17;
a4.alreadyGone = false;
a5.direct = n;
a5.site = 23;
a5.alreadyGone = false;
for(int p=1;p<1000;p++){
//1:让蚂蚁走，每次走一步
if(!a1.alreadyGone){
a1.step();
}
if(!a2.alreadyGone){
a2.step();
}
if(!a3.alreadyGone){
a3.step();
}
if(!a4.alreadyGone){
a4.step();
}
if(!a5.alreadyGone){
a5.step();
}
//2：判断两只蚂蚁是否会碰头，碰头就都调头
if(a1.site==a2.site && a1.direct==2 && a2.direct==1){
//1和2碰头了
a1.changeDirect();
a2.changeDirect();
}
if(a2.site==a3.site && a2.direct==2 && a3.direct==1){
a2.changeDirect();
a3.changeDirect();
}
if(a3.site==a4.site && a3.direct==2 && a4.direct==1){
a3.changeDirect();
a4.changeDirect();
}
if(a4.site==a5.site && a4.direct==2 && a5.direct==1){
a4.changeDirect();
a5.changeDirect();
}
//3：判断是否已经全部离开
if(a1.alreadyGone && a2.alreadyGone && a3.alreadyGone && a4.alreadyGone && a5.alreadyGone){
System.out.println("Over===="+p);
break;
}
}
}
}
}
}
}
}
}
class Ant{
//用来表示蚂蚁所在的位置
public int site = 0;
//表示蚂蚁的朝向，1表示向左，2表示向右
public int direct = 1;
//表示蚂蚁已经离开木杆
public boolean alreadyGone = false;
public void step(){
if(direct==1){
site = site - 1;
}else{
site = site + 1;
}
if(site==0 || site==27){
alreadyGone = true;
}
}
public void changeDirect(){
if(direct==1){
direct = 2;
}else{
direct = 1;
}
}
}
页:
[1]