devbox
代码探险家
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

牛客网笔试题 (经常更新)_牛客网题库

作者：代码探险家 | 2024-08-06 12:35:38

赞

踩

牛客网题库

---hashMap --- 按value排序

  1. // map排序
  2.     public static void sortMap(Map<String,Integer> map){
  3.         List<Map.Entry<String,Integer>> list =  new ArrayList<>(map.entrySet());
  4.         // list.sort
  5.         list.sort(new Comparator<Map.Entry<String, Integer>>() {
  6.             @Override
  7.             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
  8.                 return o2.getValue().compareTo(o1.getValue());
  9.             }
  10.         });
  11.         // Collections.sort
  12.         Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
  13.             @Override
  14.             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
  15.                 return o2.getValue().compareTo(o1.getValue());
  16.             }
  17.         });
  18.         for(Map.Entry<String,Integer>entry :list){
  19.             System.out.println(entry.getKey()+" "+entry.getValue());
  20.         }
  21.  
  22.     }

-----骰子翻转----

骰子有6个面，现在用1，2，3，4，5，6分别代表一个骰子的左，右，前，后，上，下的初始位置，用R代表向右滚动一次，用L代表向左滚动一次，可以向前翻转（用F表示向前翻转1次），可以向后翻转（用B表示向右翻转1次），可以逆时针旋转（用A表示逆时针旋转90度），可以顺时针旋转（用C表示逆时针旋转90度），现从初始状态开始，根据输入的动作序列，计算得到最终的状态。

  1.  
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4.  
  5. // 筛子翻转
  6. public class Shaizifanzhuan {
  7.     // 数组排序
  8.     public static void main(String[] args) {
  9.         int[] arrs= {0,1,2,3,4,5};
  10.         System.out.println("-"+JSONObject.toJSONString(arrs));
  11.         System.out.println(JSONObject.toJSONString(paixu(arrs,"R")));
  12.  
  13.     }
  14.  
  15.     public static int[] paixu (int[] nums,String str){
  16.         // nums = [0,1,2,3,4,5]  左右前后上下
  17.         int[] result = new int[6];
  18.         switch (str){
  19.             case "R": // 右
  20.                 result[0]=nums[5];
  21.                 result[1]=nums[4];
  22.                 result[2]=nums[2];
  23.                 result[3]=nums[3];
  24.                 result[4]=nums[2];
  25.                 result[5]=nums[0];
  26.                 break;
  27.             case "L": //  [0,1,2,3,4,5]  左右前后上下
  28.                 result[0]=nums[4];
  29.                 result[1]=nums[5];
  30.                 result[2]=nums[2];
  31.                 result[3]=nums[3];
  32.                 result[4]=nums[1];
  33.                 result[5]=nums[0];
  34.                 break;
  35.  
  36.             case "F": //前  // nums = [1,2,3,4,5,6]  左右前后上下
  37.                 result[0]=nums[0];
  38.                 result[1]=nums[1];
  39.                 result[2]=nums[4];
  40.                 result[3]=nums[5];
  41.                 result[4]=nums[3];
  42.                 result[5]=nums[2];
  43.  
  44.                 break;
  45.             case "B": // 后   [0,1,2,3,4,5]  左右前后上下
  46.                 result[0]=nums[0];
  47.                 result[1]=nums[1];
  48.                 result[2]=nums[5];
  49.                 result[3]=nums[4];
  50.                 result[4]=nums[2];
  51.                 result[5]=nums[3];
  52.                 break;
  53.             case "A": //逆时针 [0,1,2,3,4,5]  左右前后上下
  54.                 result[0]=nums[3];
  55.                 result[1]=nums[2];
  56.                 result[2]=nums[0];
  57.                 result[3]=nums[1];
  58.                 result[4]=nums[4];
  59.                 result[5]=nums[5];
  60.                 break;
  61.  
  62.             case "C": //  [0,1,2,3,4,5]  左右前后上下
  63.                 result[0]=nums[2];
  64.                 result[1]=nums[3];
  65.                 result[2]=nums[1];
  66.                 result[3]=nums[0];
  67.                 result[4]=nums[4];
  68.                 result[5]=nums[5];
  69.                 break;
  70.         }
  71.  
  72.  
  73.         return result;
  74.     }
  75.  
  76. }

-----判断牌型-------


五张牌，每张牌由牌大小和花色组成，牌大小2~10、J、Q、K、A，牌花色为红桃、黑桃、梅花、方块四种花色之一。 判断牌型:
 * 牌型1，同花顺：同一花色的顺子，如红桃2红桃3红桃4红桃5红桃6。
 * 牌型2，四条：四张相同数字 + 单张，如红桃A黑桃A梅花A方块A + 黑桃K。
 * 牌型3，葫芦：三张相同数字 + 一对，如红桃5黑桃5梅花5 + 方块9梅花9。
 * 牌型4，同花：同一花色，如方块3方块7方块10方块J方块Q。
 * 牌型5，顺子：花色不一样的顺子，如红桃2黑桃3红桃4红桃5方块6。
 * 牌型6，三条：三张相同 + 两张单。
 * 牌型7，其他。
 * 说明：
 * 1）五张牌里不会出现牌大小和花色完全相同的牌。
 * 2）前面的牌型比后面的牌型大，如同花顺比四条大，依次类推。
 */

  1.  
  2.  
  3. import org.apache.ibatis.annotations.Case;
  4.  
  5. import java.util.*;
  6.  
  7. // 判断牌型
  8. public class Panduanpaixing {
  9.  
  10.  
  11.     public static void main(String[] args) {
  12.         ArrayList<String> list = new ArrayList<>();
  13.         list.add("1 红");
  14.         list.add("2 a");
  15.         list.add("2 b");
  16.         list.add("2 c");
  17.         list.add("5 红");
  18.         System.out.println(getType(list));
  19.  
  20.     }
  21.  
  22.     // J 红 , 1 黑 ,J 红 , 1 黑 ,J 红 ,
  23.     public static int getType(ArrayList<String> list){
  24.         int type = 0;
  25.         List<Integer> listNumber = new ArrayList<>();
  26.         List<String> listColor = new ArrayList<>();
  27.         Set<Integer> setNum = new TreeSet<>();
  28.         Set<String> setColor = new TreeSet<>();  // 颜色相同 一个值
  29.         Map<String,Integer> map = new HashMap<>(); // 数字 数显的频率
  30.         list.stream().forEach(str->{
  31.             String [] strs  = str.split(" ");
  32.             String strNumber = strs[0] ;
  33.             String strColor = strs[1];
  34.             if(map.containsKey(strNumber)){
  35.                 map.put(strNumber,map.get(strNumber)+1);
  36.             }else{
  37.                 map.put(strNumber,1);
  38.             }
  39.             switch (strNumber){
  40.                 case "J":
  41.                     listNumber.add(11);
  42.                     setNum.add(11);
  43.                     break;
  44.                 case "Q":
  45.                     listNumber.add(12);
  46.                     setNum.add(12);
  47.                     break;
  48.                 case "K":
  49.                     listNumber.add(13);
  50.                     setNum.add(13);
  51.                     break;
  52.                 case "A":
  53.                     listNumber.add(1);
  54.                     setNum.add(1);
  55.                     break;
  56.                 default:
  57.                     listNumber.add(Integer.parseInt(strNumber));
  58.                     setNum.add(Integer.parseInt(strNumber));
  59.             }
  60.             listColor.add(strColor);
  61.             setColor.add(strColor);
  62.         });
  63.         // 判断同花 4
  64.             if(setColor.size()==1){  //同花
  65.             //判断同花顺 1
  66.             if(setNum.size()==5 ){
  67.  
  68.                 if(isShun(listNumber)){
  69.                     type = 1; // 同花顺
  70.                 }
  71.             }else{
  72.                 type = 4; //同花
  73.             }
  74.  
  75.         }
  76.         // 顺子 5
  77.         if(setColor.size()!=1){
  78.             if(setNum.size()==5){
  79.                 if(isShun(listNumber)){
  80.                     type = 5;
  81.                 }
  82.             }
  83.         }
  84.         // 三条6  四条2 葫芦3
  85.         if(setNum.size()==3){  // 22 33 1;   333  1 2
  86.            if(map.containsValue(3)){
  87.                type = 6;
  88.            }
  89.         }
  90.         if(setNum.size()==2){  // 1111 2； 11 333
  91.             if(map.containsValue(3)){
  92.                 type = 3;
  93.             }
  94.             if(map.containsValue(4)){
  95.                 type = 2;
  96.             }
  97.         }
  98.  
  99.  
  100.  
  101.  
  102.         return type;
  103.     }
  104.  
  105.     public static  boolean isShun(List<Integer> listNumber){ // 顺子
  106.  
  107.         boolean isThs = true;
  108.         for(int i =1;i<5;i++){
  109.             if(listNumber.get(i)!=listNumber.get(i-1)+1){
  110.                 isThs = false;
  111.             }
  112.  
  113.         }
  114.         return isThs;
  115.     }
  116.  
  117. }

-----按照字母个数排序-------

给定长度小于100的一个字符串,区分大小写的情况下统计其中字母的个数,并按照由大到小的顺序输出.当字母个数一样时,按照把先出现的字母放在前面.当字符串中没有字母时,则不要输出.

举例:

输入:

abbbdcdc123

输出:

b=3

d=2

c=2

a=1

  1. package utils.huawei;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4.  
  5. import java.util.*;
  6.  
  7. // 最多字母次数 排序输出
  8. public class Zuigaocishuzimu {
  9.  
  10.     public static void main(String[] args) {
  11.  
  12.         sort("aabbbdcdc123");
  13.     }
  14.  
  15.     public static void  sort(String str){  //abbbdcdc123
  16.         Map<Character,Integer> map = new LinkedHashMap<>();
  17.         Set<Character> set = new HashSet<>();
  18.  
  19.         // hashMap根据 values排序
  20.         for(char cha : str.toCharArray()){
  21.             if(cha>='A'&&cha<='z'){
  22.                 if(map.containsKey(cha)){
  23.                    map.put(cha,map.get(cha)+1) ;  // a1 b3 d2 c2
  24.                 }else {
  25.                     map.put(cha, 1);
  26.                 }
  27.  
  28. //                set.toArray();
  29.             }
  30.         }
  31.         System.out.println(JSONObject.toJSONString(map));
  32.         char [] chars = new char[map.size()];
  33.         int []  nums = new int[map.size()];
  34.         int i =0;
  35.         Object o = map.keySet().toArray()[0];
  36.         Object a = map.values().toArray()[0];
  37.         chars[0] = (char)o;
  38.         nums[0] = (int) a;
  39.  
  40.  
  41.         for(Map.Entry<Character,Integer> entry: map.entrySet()){
  42.              char ch = entry.getKey();
  43.              Integer num= entry.getValue();
  44.              chars[i]=ch; //a
  45.              nums[i]=num; //1   根据num排序   3 i-1:2
  46.              int j  = i; // 0
  47.  
  48.              while( j>0&&nums[j]>nums[j-1]){   // 交换j 到合适的地方
  49.                   int tempNum = nums[j];
  50.                   char tempChar = chars[j];
  51.                   chars[j]= chars[j-1];
  52.                   chars[j-1] = tempChar;
  53.                   nums[j] =nums[j-1];
  54.                   nums[j-1] = tempNum;
  55.  
  56.              }
  57.             i++;
  58.         }
  59.  
  60.         System.out.println(chars);
  61.  
  62.         for(int s =0;s<=chars.length-1;s++){
  63.             System.out.println(chars[s]+" "+nums[s]);
  64.         }
  65.  
  66.     }
  67.  
  68.  
  69.     // map排序
  70.     public static void sortMap(Map<String,Integer> map){
  71.         List<Map.Entry<String,Integer>> list =  new ArrayList<>(map.entrySet());
  72.         // list.sort
  73.         list.sort(new Comparator<Map.Entry<String, Integer>>() {
  74.             @Override
  75.             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
  76.                 return o2.getValue().compareTo(o1.getValue());
  77.             }
  78.         });
  79.         // Collections.sort
  80.         Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
  81.             @Override
  82.             public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
  83.                 return o2.getValue().compareTo(o1.getValue());
  84.             }
  85.         });
  86.         for(Map.Entry<String,Integer>entry :list){
  87.             System.out.println(entry.getKey()+" "+entry.getValue());
  88.         }
  89.  
  90.     }
  91. }
  92.  
  93.

--------消除重复数字的最大整数------------------

  1.  
  2.  
  3. import java.math.BigInteger;
  4. import java.util.Arrays;
  5. import java.util.HashMap;
  6. import java.util.Map;
  7.  
  8. // 消除重复数字的最大整数
  9. public class MostBig {
  10.  
  11.     public static void main(String[] args) {
  12.         mostBig(new BigInteger("2134123745971246890123064"));
  13.     }
  14.  
  15.     public static void mostBig(BigInteger data){
  16.         String str = data+"";
  17.         char[] chars = str.toCharArray();
  18.         Arrays.sort(chars);
  19.         Map<String,Integer> map = new HashMap<>();
  20.         for(int i=chars.length-1;i>=0;i--){
  21.             char cha = chars[i];
  22.             if(!map.containsKey(cha+"")){
  23.                 System.out.print(cha);
  24.                 map.put(cha+"",1);
  25.             }
  26.         }
  27.  
  28.     }
  29. }

-------------------牛客网小题汇总-------

  1.  
  2. import com.alibaba.fastjson.JSONObject;
  3.  
  4. import java.util.*;
  5.  
  6. public class Main {
  7.  
  8.     // 子串的最长路径查找
  9.     public static void zichuanlujing(String [] strs){
  10.         Arrays.sort(strs);
  11.         Arrays.stream(strs).forEach(str-> System.out.println(str));
  12.     }
  13.  
  14.     public static void main(String [] args){
  15.  
  16.         Scanner scanner = new Scanner(System.in);
  17.         int num = scanner.nextInt();
  18.         while(scanner.hasNext()){
  19.  
  20.             String [] strs = new String[num];
  21.             for(int i =0;i<num;i++){
  22.                 strs[i] = scanner.next();
  23.             }
  24.             System.out.println(JSONObject.toJSONString(strs));
  25.             zichuanlujing(strs);
  26.         }
  27.  
  28.  
  29. //        字符串反转
  30. //        Scanner scanner = new Scanner(System.in);
  31. //        String str = scanner.nextLine();
  32. //        char [] strs = str.toCharArray();
  33. //        StringBuffer stringBuffer = new StringBuffer();
  34. //        for(int i=0;i<strs.length;i++){
  35. //            stringBuffer.append(strs[strs.length-i-1]);
  36. //        }
  37. //        System.out.println(stringBuffer);
  38.  
  39. //合并表记录
  40. //        Scanner scanner = new Scanner(System.in);
  41. //        Map<Integer,Integer> map = new TreeMap<>();
  42. //        while(scanner.hasNext()){
  43. //            int lenth = scanner.nextInt();
  44. //            while(lenth-->0){
  45. //
  46. //               int key = scanner.nextInt();
  47. //               int value = scanner.nextInt();
  48. //               if(map.containsKey(key)){
  49. //                   map.put(key,value+map.get(key));
  50. //               }else{
  51. //                   map.put(key,value);
  52. //               }
  53. //           }
  54. //            for(Map.Entry<Integer,Integer> entry :map.entrySet()){
  55. //                System.out.println(entry.getKey()+" "+entry.getValue());
  56. //            }
  57. //        }
  58.  
  59.  
  60.  
  61. //        System.out.println(isZhishu(3));
  62.  
  63. //        while(scanner.hasNext()){
  64. //            String str1 = scanner.nextLine().replaceAll(" ","");
  65. //            String str2 = scanner.nextLine().replaceAll(" ","");
  66. //            ArrayList a1 = strSplit(str1);
  67. //            ArrayList a2 = strSplit(str2);
  68. //            a1.stream().forEach(str-> System.out.println(str));
  69. //            a2.stream().forEach(str-> System.out.println(str));
  70. //        }
  71.  
  72.     }
  73.  
  74.     //句子反转
  75.     public static  String reserse(String str){
  76.         String []strs = str.split(" ");
  77.         StringBuffer result = new StringBuffer();
  78.         for(int i =strs.length-1;i>=0;i--){
  79.             if(i==0){
  80.                 result.append(strs[i]);
  81.             }else{
  82.                 result.append(strs[i]+" ");
  83.             }
  84.         }
  85.         return result.toString();
  86.     }
  87.  
  88.     // 数字颠倒
  89.     public static void shuzidiandao(int data){
  90.         char[] chars = (data+"").toCharArray();
  91.         for(int i=chars.length-1;i>=0;i--){
  92.             System.out.print(chars[i]);
  93.         }
  94.  
  95.     }
  96.     // 重复字符最长串  aaaaabbbbaaccccc
  97.     public static String maxRepeat(String str){
  98.         if(str.length()==1){
  99.             return str;
  100.         }
  101.         char[] chars = str.toCharArray();
  102.         String temp = str.substring(0,1);
  103.  
  104.         int start = 1;
  105.         int end = 1;
  106.         Map<Integer,Integer> map = new HashMap<>(); // key 开始，value 结束
  107.         for(int i=1;i<chars.length;i++){  // 分割数组
  108.             if(chars[i]!=chars[i-1]){  // 不相等分割
  109. //                end = i;
  110.                 if((end-start)>temp.length()||(end-start)==temp.length()&&temp.charAt(0)>chars[i]){  // 长度小于 或者accis吗小于
  111.                     temp = str.substring(start,end);
  112.                 }
  113.                 if(temp.length()==1){ // 单独 a b c
  114.                     if(chars[i]<chars[i-1]){
  115.                         temp = chars[i]+"";
  116.                     }
  117.                 }
  118.                 start = i;
  119.                 end = i;
  120.             }else{
  121.                 end = i;
  122.                 // 判断是最后一个串， 则需要重新判断temp
  123.                 if(i==chars.length-1){
  124.                     String s = str.substring(start,end);
  125.                     System.out.println("-"+s);
  126.                     if(s.length()>temp.length()||s.charAt(0)<temp.charAt(0)){
  127.                         temp = s;
  128.  
  129.                     }
  130.                 }
  131.             }
  132.         }
  133.  
  134.         return temp;
  135.     }
  136.  
  137.     // 重复字符排序   ABCDAB -> AB
  138.     public static  void chongfuzifupaixu(String str){
  139.         Map<Character ,Integer> map = new TreeMap<>();
  140.         char [] chars = str.toCharArray();
  141.         for(int i=0;i<chars.length;i++){
  142.             if(map.containsKey(chars[i])){
  143.                 map.put(chars[i],map.get(chars[i])+1);
  144.             }else{
  145.                 map.put(chars[i],1);
  146.             }
  147.         }
  148.         for(Map.Entry<Character,Integer> entry:map.entrySet()){
  149.             if(entry.getValue()>1){
  150.                 System.out.print(entry.getKey());
  151.             }
  152.         }
  153.     }
  154.  
  155.     //  计算字符个数
  156.     public static int zifugeshu(String str){
  157.         char [] chars = str.toCharArray();
  158.         Set<Character> set = new HashSet<>();
  159.         for(int i=0;i<chars.length;i++){
  160.             if(chars[i]>=0&&chars[i]<=127){
  161.                 set.add(chars[i]);
  162.             }
  163.         }
  164.         return set.size();
  165.     }
  166.  
  167.     // 提取不重复的整数
  168.     public static void getbuchongfu(int data){
  169.         Set<String> set = new TreeSet();
  170.         String  str = data+"";
  171.         for(int i=str.length()-1;i>=0;i--){
  172.             if(!set.contains(""+str.charAt(i))){
  173.                 set.add(""+str.charAt(i));
  174.                 System.out.print(str.charAt(i));
  175.             }
  176.         }
  177.  
  178.     }
  179.  
  180.     // 链表操作
  181.  
  182.     // 二叉树 先序遍历 非递归
  183.     public static  void treeBianli(TreeNode treeNode){
  184.         Stack<TreeNode> stack = new Stack<>();
  185.         while(treeNode!=null||!stack.isEmpty()){
  186.  
  187.             while(treeNode.left!=null){
  188.                 System.out.println(treeNode.val);
  189.                 stack.push(treeNode);
  190.                 treeNode = treeNode.left;
  191.             }
  192.             if(stack!=null){
  193.                 treeNode = stack.pop();
  194.                 treeNode = treeNode.right;
  195.             }
  196.         }
  197.  
  198.     }
  199.  
  200.     // 二叉树遍历 递归
  201.     public static void xianxuBian(TreeNode treeNode){
  202.         System.out.println(treeNode.val);
  203.         if(treeNode.left!=null){
  204.            xianxuBian(treeNode.left);
  205.         }
  206.         if(treeNode.right!=null){
  207.             xianxuBian(treeNode.right);
  208.         }
  209.     }
  210.  
  211.     // 快排序
  212.     public static void quickSort(int []numbers,int start,int end ){
  213.         if(start<end){
  214.             int base = numbers[start];// 基数
  215.             int temp ;
  216.             int i = start ;
  217.             int j =end;
  218.             do{
  219.                 while(numbers[i]>=base&&i<end){
  220.                     i++;
  221.                 }
  222.                 while(numbers[j]<=base&& j>start){
  223.                     j--;
  224.                 }
  225.                 // 交换
  226.                 if(i<=j){
  227.                     temp = numbers[i];
  228.                     numbers[i] = numbers[j];
  229.                     numbers[j] = temp;
  230.                 }
  231.             }while(i<j);   // 找到base 位置， 左边比它小，右边比它大
  232.  
  233.             numbers[start] = numbers[i];  // base位置变换
  234.             numbers[i] = base;
  235.             quickSort(numbers,start,i-1);
  236.             quickSort(numbers,i+1,end);
  237.  
  238.         }
  239.     }
  240.  
  241.     // 取近似值
  242.     public static int getJinshizhi(float data){
  243.         String str = new String (data+"");
  244.         String[] strs = str.split(".");
  245.         if(strs.length==2){
  246.             if(Integer.parseInt(strs[1])>=5){
  247.                 return Integer.parseInt(strs[0])+1;
  248.             }
  249.         }
  250.         return Integer.parseInt(strs[0]);
  251.     }
  252.     public static int getJinshizhi2(float f){
  253.         int i = (int)f;
  254.          i = (f-i)>=0.5?++i:i;
  255.         return i;
  256.     }
  257.  
  258.     // 质数因子
  259.     public static String  getZhishuResult(long data){
  260.         StringBuffer result = new StringBuffer("");
  261.         int i = 2;
  262.         while(data-->0){
  263.             if(data%i==0&&isZhishu(i)){ //因数
  264.                 result.append(i+" ");
  265.                 i++;
  266.             }
  267.         }
  268.         return result.toString();
  269.     }
  270.  
  271.     // 质数因子2
  272.     public static void zhishuyinzi(long data){
  273.         while(data!=1){
  274.             for(int i =2;i<data;i++){
  275.                 if(data%i==0){
  276.                     System.out.println(i+" ");
  277.                     data =data/i;
  278.                     break;
  279.                 }
  280.             }
  281.         }
  282.     }
  283.  
  284.     public static void canculate(long num){
  285.         for(long i=2;i<=num;i++){
  286.             if(num%i==0){
  287.                 System.out.print(i+" ");
  288.                 canculate(num/i);
  289.                 return;
  290.             }
  291.         }
  292.     }
  293.  
  294.     // 判断是否为质数
  295.     public static boolean isZhishu(long data){
  296.         boolean result = true;
  297.         int i =2;
  298.         while(data-->0&&i<data){
  299.            if( data%(i++)==0){
  300.                result = false;
  301.                break;
  302.            }
  303.         }
  304.         return result;
  305.     }
  306.  
  307.     // 输入十六进制 -》 十进制
  308.     public static int shiliu(String str){
  309.  
  310.         return Integer.parseInt(str.substring(2),16);
  311.     }
  312.  
  313.     // 字符串分割
  314.     public static ArrayList<String> strSplit(String  str){
  315.         ArrayList<String> arrayList = new ArrayList<>();
  316.         while(str.length()>=8){
  317.             arrayList.add(str.substring(0,8));
  318.             str = str.substring(8);
  319.         }
  320.         StringBuffer last =  new StringBuffer(str);
  321.         for(int i=0;i<8- str.length();i++){
  322.             last.append("0");
  323.         }
  324.         arrayList.add(last.toString());
  325.        //   arrayList.toArray(new String [0]);  返回数组
  326.         return arrayList;
  327.     }
  328.  
  329.     // 数组去重排序
  330.     public static int[] quchongpaixu (int [] arr){
  331.         // 排序
  332.  
  333.         for(int i=0;i<arr.length-1;i++){
  334.             boolean isSorted = true;
  335.             for(int j =0;j<arr.length-1-i;j++){
  336.                 if(arr[j]>arr[j+1]){
  337.                     int temp = arr[j];
  338.                     arr[j] = arr[j+1];
  339.                     arr[j+1] = temp;
  340.                     isSorted = false;
  341.                 }
  342.             }
  343.             if(isSorted){
  344.                 break;
  345.             }
  346.         }
  347.  
  348.         // 去重
  349.         ArrayList<Integer> arrayList = new ArrayList();
  350.         arrayList.add(arr[0]);
  351.         for(int i:arr){
  352.  
  353.             if(arrayList.get(arrayList.size()-1)!=i){
  354.                 arrayList.add(i);
  355.             }
  356.         }
  357.         Integer[] result = new Integer[arrayList.size()];
  358.         return  arrayList.stream().mapToInt(Integer::intValue).toArray();
  359.     }
  360.  
  361.     // 数组包含
  362.     public static int numHas(String str1,String target){
  363.         int num =0;
  364.         for(char ch : str1.toCharArray()){
  365.             if(ch==target.charAt(0)|| ch== target.toUpperCase().charAt(0)||ch == target.toLowerCase().charAt(0)){
  366.                 num++;
  367.             }
  368.         }
  369.         return num;
  370.     }
  371.  
  372.     public static int lent(String str){
  373.         String [] strs =  str.split(" ");
  374.         return strs[strs.length-1].length();
  375.     }
  376. }
  377. class Node{
  378.     String str ;
  379.     Node next ;
  380.  
  381.     public Node getNext() {
  382.         return next;
  383.     }
  384.  
  385.     public String getStr() {
  386.         return str;
  387.     }
  388.  
  389.     public void setNext(Node next) {
  390.         this.next = next;
  391.     }
  392.  
  393.     public void setStr(String str) {
  394.         this.str = str;
  395.     }
  396. }
  397. class  TreeNode{
  398.     int val;
  399.     TreeNode left;
  400.     TreeNode right;
  401. }

--------3水瓶子换一瓶水-----------

  1.  
  2. import java.util.Scanner;
  3.  
  4. public class Qishiping {
  5.     int sum =0;
  6.     public static void main(String[] args) {
  7.         Scanner scanner = new Scanner(System.in);
  8.  
  9.  
  10.         while(scanner.hasNext()){
  11.             int in = scanner.nextInt();
  12.             if(in==0){
  13.                 break;
  14.             }
  15.  
  16.             if(in==1){
  17.                 System.out.println(0);
  18.             }
  19.             if(in==2){
  20.                 System.out.println(1);
  21.             }
  22.             System.out.println(h(in));
  23. //            int c = in%3;  //
  24. //            if(in%3==2){ // 喝完，剩下2个 +1
  25. //                int b  = (int)in/3;
  26. //                sum+=b; //
  27. //                (b+c)%3
  28. //            }
  29.         }
  30.     }
  31.     static  int h(int n){
  32.         if(n<2){
  33.             return 0;
  34.         }
  35.         int a = n%3;  // 59/3  19  2
  36.         if(n==2){
  37.             return 1; // 借一瓶
  38.         }
  39.         int b = n/3; // 19
  40.  
  41.         return b+h(b+a);
  42.     }
  43.  
  44. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/代码探险家/article/detail/937454?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号