飞道的博客

数据结构算法 简单的面试思考题

322人阅读  评论(0)

 

目录

简单的面试思考题

思考题一

思考题二

思考题三


简单的面试思考题

思考题一

 

有64瓶疫苗, 其中一瓶不小心混入了有害物质, 现在要利用小白鼠找出那一瓶!

注意:小白鼠只要喝一点点混入有害物质的在30分钟就是死亡, 那么现在只剩下30分

钟了(只能进行一次实验), 问最少需要几只小白鼠可以找出那瓶混入有害物质的疫苗

使用二进制编码

1.将64瓶疫苗从0~63进行编号

2.将每一瓶疫苗的编号转为二进制表示


  
  1. package cn.itcast.test;
  2. /**
  3. * Author itcast
  4. * Desc
  5. */
  6. public class Test01 {
  7.     public static void main( String[] args){
  8.         for ( int i = 0; i <= 63; i++) {
  9.            System.out.println(i+ ":"+ Integer.toBinaryString(i));
  10.       }
  11.   }
  12. }
 

  
  1. 00:000000
  2. 01:000001
  3. 02:000010
  4. 03:000011
  5. 04:000100
  6. 05:000101
  7. 06:000110
  8. 07:000111
  9. 08:000000
  10. 09:000001
  11. 10:000010
  12. 11:000011
  13. 12:000100
  14. 13:000101
  15. 14:000110
  16. 15:000111
  17. 16:010000
  18. 17:010001
  19. 18:010010
  20. 19:010011
  21. 20:010100
  22. 21:010101
  23. 22:010110
  24. 23:010111
  25. 24:011000
  26. 25:011001
  27. 26:011010
  28. 27:011011
  29. 28:011100
  30. 29:011101
  31. 30:011110
  32. 31:011111
  33. 32:100000
  34. 33:100001
  35. 34:100010
  36. 35:100011
  37. 36:100100
  38. 37:100101
  39. 38:100110
  40. 39:100111
  41. 40:101000
  42. 41:101001
  43. 42:101010
  44. 43:101011
  45. 44:101100
  46. 45:101101
  47. 46:101110
  48. 47:101111
  49. 48:110000
  50. 49:110001
  51. 50:110010
  52. 51:110011
  53. 52:110100
  54. 53:110101
  55. 54:110110
  56. 55:110111
  57. 56:111000
  58. 57:111001
  59. 58:111010
  60. 59:111011
  61. 60:111100
  62. 61:111101
  63. 62:111110
  64. 63:111111
  65. -----------
  66.   ******

3.拿出6只小白鼠和上面的6个二进制位一一对应

4.然后这6只小白鼠喝对应的二进制位是1的疫苗(只喝一点点即可)

如左边第一只,喝32~63

如右边第一只,喝编号是奇数的

...其他的类似

5.30分钟后观察结果,看哪些小白鼠死了既可以推断出混入有害物质的疫苗

如: 都没死, 那么0号000000混入有害物质

如: 都死了, 那么63号111111混入有害物质

如: 从左边开始135死了,那么 42号101010混入有害物质

  • 原理:

现代科学实验思想: 通过现象猜想本质 , 通过本质/原理,也可以推导可能发生的现象

  • 如:

观察到先看见闪电, 后听到雷声, 我猜想: 光速比声速快

而事实也是确实是光速比声速快,所以先看见闪电, 后听到雷声

 

 

思考题二

有 1~ n, n个数字(n很大,但不一定有序),

但是不小心丢了其中一个,

让写代码找出丢的哪一个! 要求效率最高

  • 可能的解法


  
  1. 1.排序+二分(效率太低,因为要排序)
  2. 2.先求1~n的和((1+n)*n/2)再减去n-1个数,最后的结果的数就是丢失的数(已经很快了,但是还是要进行加减法)
  3. 3.位运算比加减法还要快
  4. &与
  5. |或
  6. !非
  7. ^异或
  8. ^异或的特点:
  9. 二进制:
  10. 1001
  11. ^1001
  12. -----
  13. 0000
  14. 1001
  15. ^0110
  16. ------
  17. 1111
  18. 所以异或的特点是二进制位相同为0,不同为1
  19. 那么推广到1~n,相同的数据异或为0,不同的先不管
  20. 1010
  21. ^0000
  22. -----
  23. 1010
  24. 一个数和0进行异或等于这个数本身
  25. 且异或满足交换律,异或顺序可以随便调
  26. 1 ^ 2 ^ 3 ....^n--这是有丢失的
  27. ^1 ^ 2 ^ 3 .x..^n--这是没有丢失的
  28. -----------------
  29. 0^0^0....^x = x

 

代码实现


  
  1. package cn.itcast.test;
  2. /**
  3. * Author itcast
  4. * Desc
  5. */
  6. public class Test02 {
  7.     public static void main(String[] args) {
  8.         int result = 0 ;
  9.         int[] arr1 = new int[]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} ;//完整的
  10.         int[] arr2 = new int[]{ 1, 2, 3, 4, 0, 6, 7, 8, 9, 10} ;//丢失了一个数的
  11.         for (int i = 0 ; i < arr1.length; i++) {
  12.             if (i == 0 ) {
  13.                 result = arr1[ i] ^ arr2[ i] ;
  14.           } else {
  15.                 //result = result ^ (arr1[ i] ^ arr2[ i] );
  16.                 result ^= (arr1[ i] ^ arr2[ i] );
  17.           }
  18.       }
  19.         System.out.println("丢失的数为:" + result);
  20.   }
  21. }

 

思考题三

有1个桶里面有100个黑球,100个白球, 桶外还有足够的黑球白球

现在从桶里每次随机取出2个球,

如果颜色相同就放回一个白球,

如果颜色不同就放回一个黑球,

问最后桶里剩下的一个球是什么颜色的球?


  
  1. 使用位运算异或^
  2. 相同为0,不同为1
  3. 所以令白球为0,黑球为1
  4. 那么题目就变成了100个0和100个1进行^
  5. 0 ^ 0 ^ 0....^ 0 ==0
  6. 1 ^ 1 ^ 1....^ 1 == 0
  7. ------------------
  8. 0是白球

 


  
  1. package cn.itcast.test;
  2. import java.util.ArrayList;
  3. import java.util. List;
  4. import java.util.Random;
  5. /**
  6. * Author itcast
  7. * Desc
  8. */
  9. public class Test03 {
  10.     public static void main( String[] args) {
  11.         List< Integer> list = new ArrayList<>();
  12.         for ( int i = 1; i <= 100; i++) {
  13.             list.add( 0); //白球
  14.             list.add( 1); //黑球
  15.       }
  16.        Random random = new Random();
  17.         while ( list.size() > 1) {
  18.             Integer i1 = list.get(random.nextInt( list.size()));
  19.             Integer i2 = list.get(random.nextInt( list.size()));
  20.             list.remove(i1); //移除该对象
  21.             list.remove(i2); //移除该对象
  22.             list.add(i1 ^ i2);
  23.       }
  24.        System.out.println( list);
  25.   }
  26. }

 


转载:https://blog.csdn.net/xiaoweite1/article/details/116674300
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场