训练级牛客

最新推荐文章于 2022-10-29 17:44:53 发布

XKX1314520

最新推荐文章于 2022-10-29 17:44:53 发布

阅读量233

点赞数

分类专栏： JAVA

本文链接：https://blog.csdn.net/XKX13419613290/article/details/80451340

版权

JAVA 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

求数列的和：数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和，精确保留2位小数。

import java.util.Scanner;  
public class Main {  
  

public static void main(String[] args)
{
    int m;
    double sum,n ;
    Scanner sc=new Scanner(System.in);// System.in代表标准输入，就是键盘输入  
    while(sc.hasNext())//等待输入下一个字符，返回true
    {
       n=sc.nextInt();// 获取键盘的输入：
        m=sc.nextInt();
         sum=0;
        for(int i = 0; i < m; i++)
        {
          sum=sum+n;
            n=Math.sqrt(n);
            
        }
        System.out.printf("%.2f",sum); // 输出输入项  
         System.out.println(); // 把我给你的东西打印到控制台，并用一个新行结束
    }
}
}

水仙花数：春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的： “水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=1^3+5^3+3^3。现在要求输出所有在m和n范围内的水仙花数。

输入数据有多组，每组占一行，包括两个整数m和n（100 ≤ m ≤ n ≤ 999）。

对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;  如果给定的范围内不存在水仙花数，则输出no; 每个测试实例的输出占一行。

输入

100 120
300 380

输出

no
370 371

import java.util.Scanner;
import java.util.Collections;
import java.util.ArrayList;
import java.util.List;
import java.lang.Math;
public class Main {     
public static void main(String[] args)  
{  
  //int m;  
   // double sum,n ;  
     
    Scanner sc=new Scanner(System.in);// System.in代表标准输入，就是键盘输入    
    List<Integer> list = new ArrayList();
    while(sc.hasNext())//等待输入下一个字符，返回true  
    {  
      int  n=sc.nextInt();// 获取键盘的输入：  
       int  m=sc.nextInt();  
         //sum=0;  
     
       for(int i=m;i<=n;i++)
        {
         int c=i%10;
         int b=i/100;
           int a=i/10%10;
           //sum=a^3+b^3+c^3;
         if(Math.pow(a,3) + (Math.pow(b,3)) + (Math.pow(c, 3))==(i)){  
                //System.out.println(i);  
             list.add(i);
            } 
       }
          Collections.sort(list);
        if(list.size()==0){
               System.out.print("no");
           }else{

             for(int i=0;i<list.size()-1;i++) {
                System.out.print(list.get(i)+" ");
            }
            System.out.print(list.get(list.size()-1));
           
           }
             
         } 
      }
    }
     
   结果为40%，原因是m与n反了。再附上聪明的方法

for ( int i = a ; i <= b ; i++ ) {
            int x = i ;
            int x2 = x;
            int y = 0 ;
            int z = 0 ;
            while (x != 0) {
                y = x%10;
                z += y*y*y;
                x = x/10;
            }
            if( x2 == z) {
                arr.add(x2);
                isEmpty = false;
            }//求个十百

题目描述：电话号码（注释：string与stringbuilder的区别 StringBuffer的添加和删除功能）

继MIUI8推出手机分身功能之后，MIUI9计划推出一个电话号码分身的功能：首先将电话号码中的每个数字加上8取个位，然后使用对应的大写字母代替（"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"），然后随机打乱这些字母，所生成的字符串即为电话号码对应的分身。

输入描述:

第一行是一个整数T（1 ≤ T ≤ 100)表示测试样例数；接下来T行，每行给定一个分身后的电话号码的分身（长度在3到10000之间）。

输出描述:

输出T行，分别对应输入中每行字符串对应的分身前的最小电话号码（允许前导0）。

输入输出

4
EIGHT                                               0
ZEROTWOONE                                          234
OHWETENRTEO                                         345
OHEWTIEGTHENRTEO                                    0345

package schooloffer17;  
  
import java.util.Arrays;  
import java.util.Scanner;  
  
/** 
 * @Author: cxh 
 * @CreateTime: 17/12/2 10:01 
 * @ProjectName: JavaBaseTest 
 * <电话号码分身></> 
 */  
public class PhoneNumDevide {  
    public static void main(String[] args) {  
        Scanner scanner=new Scanner(System.in);  
        int n;  
        n=Integer.valueOf(scanner.nextLine().trim());//n个测试用例  Integer.valueof(把字符数转换成整形变量)
        int[] record=new int[10];  //设置10个电话号码分身位置
        for(int i=0;i<n;i++){  //i有n个测试用例，循环输入
            String str=scanner.nextLine().trim().toLowerCase();  //trim()去掉字符串两端的空格，用于将大写字符转换为小写 
            Arrays.fill(record,0);//记录各个数字出现次数  
            StringBuilder sb=new StringBuilder(str);  //有大量的字符拼接的操作，我们应该使用StringBuilder 
            //阶段1  
            //two->4  
            while (sb.indexOf("w")!=-1){  
                sb.deleteCharAt(sb.indexOf("t"));  
                sb.deleteCharAt(sb.indexOf("w"));  
                sb.deleteCharAt(sb.indexOf("o"));  
                record[4]++;  
            }  
            //six->8  
            while (sb.indexOf("x")!=-1){  
                sb.deleteCharAt(sb.indexOf("s"));  
                sb.deleteCharAt(sb.indexOf("i"));  
                sb.deleteCharAt(sb.indexOf("x"));  
                record[8]++;  
            }  
            //eight->0  
            while (sb.indexOf("g")!=-1){  
                sb.deleteCharAt(sb.indexOf("e"));  
                sb.deleteCharAt(sb.indexOf("i"));  
                sb.deleteCharAt(sb.indexOf("g"));  
                sb.deleteCharAt(sb.indexOf("h"));  
                sb.deleteCharAt(sb.indexOf("t"));  
                record[0]++;  
            }  
            //zero->2  
            while (sb.indexOf("z")!=-1){  
                sb.deleteCharAt(sb.indexOf("z"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                sb.deleteCharAt(sb.indexOf("r"));  
                sb.deleteCharAt(sb.indexOf("o"));  
                record[2]++;  
            }  
            //阶段2  
            //three->5  
            while (sb.indexOf("h")!=-1){  
                sb.deleteCharAt(sb.indexOf("t"));  
                sb.deleteCharAt(sb.indexOf("h"));  
                sb.deleteCharAt(sb.indexOf("r"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                record[5]++;  
            }  
            //four->6  
            while (sb.indexOf("u")!=-1){  
                sb.deleteCharAt(sb.indexOf("f"));  
                sb.deleteCharAt(sb.indexOf("o"));  
                sb.deleteCharAt(sb.indexOf("u"));  
                sb.deleteCharAt(sb.indexOf("r"));  
                record[6]++;  
            }  
            //seven->9  
            while (sb.indexOf("s")!=-1){  
                sb.deleteCharAt(sb.indexOf("s"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                sb.deleteCharAt(sb.indexOf("v"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                sb.deleteCharAt(sb.indexOf("n"));  
                record[9]++;  
            }  
            //阶段3  
            //five->7  
            while (sb.indexOf("f")!=-1){  
                sb.deleteCharAt(sb.indexOf("f"));  
                sb.deleteCharAt(sb.indexOf("i"));  
                sb.deleteCharAt(sb.indexOf("v"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                record[7]++;  
            }  
            //阶段4  
            //nine->1  
            while (sb.indexOf("i")!=-1){  
                sb.deleteCharAt(sb.indexOf("n"));  
                sb.deleteCharAt(sb.indexOf("i"));  
                sb.deleteCharAt(sb.indexOf("n"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                record[1]++;  
            }  
            //阶段5  
            //one->3  
            while (sb.indexOf("e")!=-1){  
                sb.deleteCharAt(sb.indexOf("o"));  
                sb.deleteCharAt(sb.indexOf("n"));  
                sb.deleteCharAt(sb.indexOf("e"));  
                record[3]++;  
            }  
  
            for(int j=0;j<10;j++){  
                for(int k=0;k<record[j];k++){  
                    sb.append(j);  
                }  
            }  
            System.out.println(sb.toString());返回此对象本身（它已是一个字符串）
        }  
    }  
}

题目描述：句子翻转

给定一个句子（只包含字母和空格），将句子中的单词位置反转，单词用空格分割, 单词之间只有一个空格，前后没有空格。比如：（1） “hello xiao mi”-> “mi xiao hello”

输入描述: 输入数据有多组，每组占一行，包含一个句子(句子长度小于1000个字符)

输出描述: 对于每个测试示例，要求输出句子中单词反转后形成的句子

输入    hello xiao mi

输出    mi xiao hello

import java.util.Arrays;
import java.util.Scanner; 
public class Main {  
    public static void main(String[] args) {  
        Scanner sc=new Scanner(System.in);
         String m=sc.nextLine();
       String[]  word= m.split(" ");
         for(int i=word.length-1;i>=0;i--)
         {
            if(i==0){System.out.print(word[i]);}
            else{System.out.print(word[i]+" ");}
         } 
    }}

题目描述：树的高度

现在有一棵合法的二叉树，树的节点都是用数字表示，现在给定这棵树上所有的父子关系，求这棵树的高度

输入描述: 输入的第一行表示节点的个数n（1 ≤ n ≤ 1000，节点的编号为0到n-1）组成，

下面是n-1行，每行有两个整数，第一个数表示父节点的编号，第二个数表示子节点的编号

输出描述: 输出树的高度，为一个整数。

输入：5 输出：3

0 1

0 2

1 3

1 4

import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.Queue;
  import java.util.Scanner;
   class Node{
         public Node(int father, int child) {
         this.father = father;
        this.child = child;
    }
     int father;
     int child;
 }
 
 public class Main{
     /****
      * 层次遍历的思想，队列实现，按层添加到队列，末尾入队-1；
      */
     public static int deep(int n,ArrayList<Node> tree){
         int count=0;
        int j=0;//记录操作了多少个结点；
       if(n<=0){
            return 0;
        }else if(n==1){
            return 2;
         }else{
            Queue<Integer> queue=new LinkedList<Integer>();
              queue.offer(0);
              j++;
             queue.offer(-1);//
             boolean flag=false;//判断是否到尾结点；
             while(!queue.isEmpty()){
 //　　　　　　　　printdata(queue);
                  Integer data=queue.poll();
  //                System.out.println();
 //                System.out.println("data:"+data);
  //                System.out.println();
                  if(j==n&&flag==false){
                      queue.offer(-1);
                      flag=true;
                  }else if(data==-1){    
                     if(flag){
                          count++;
                      }else{
                          queue.offer(-1);
                          count++;
                      }                    
               }else{
                      for(int i = 0;i < tree.size(); i ++){
                          if(tree.get(i).father==data){
                             queue.offer(tree.get(i).child);
                             j++;
                          }
                     }                    
                  }
             }
             
         }
 
         return count;
    }
     public static void printdata(Queue<Integer> queue){
         for(Iterator it2 = queue.iterator();it2.hasNext();){
            System.out.println("Q:"+it2.next());
        }
     }
     public static void main(String[] args) {
         // TODO Auto-generated method stub
        Scanner in =new Scanner(System.in);
  //        while(in.hasNext()){
             int n=in.nextInt();
            ArrayList<Node> tree =new ArrayList<Node>();
              for(int i=0;i<n-1;i++){
                 int father=in.nextInt();
                int child=in.nextInt();
                Node node=new Node(father,child);
                tree.add(node);            }
            System.out.println(deep(n,tree));
  //        }
      }
  
  }//AC40%

题目描述：数串

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。
如:n=3时，3个整数13,312,343,连成的最大整数为34331213。
如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。

输入描述:

有多组测试样例，每组测试样例包含两行，第一行为一个整数N（N<=100），第二行包含N个数(每个数不超过1000，空格分开)。

输出描述:

每组数据输出一个表示最大的整数。

复制

输出：  12312
       7424613

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.*; 

public class  Main {  
    static int total = 0;   
    static List totalNUm = new ArrayList();  
    public static void main(String[] args) {  
        System.out.println("请至少输入两个数字，用空格隔开");  
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextLine();
        String[] s = scanner.nextLine().split(" ");  
        new  Main().zuhe(s, s.length, 0);  
        Collections.sort(totalNUm);  
        System.out.println("最小的组合数为：" + totalNUm.get(0));  
        System.out.println("最da的组合数为：" + totalNUm.get(totalNUm.size()-1));  
        System.out.println("共组成  " + total+" 条组合数");  
        System.out.println("所有的组合数为：" + totalNUm.toString());  
    }  
    private void zuhe(String[] array, int n, int k) {    
        if (n == k) {  
            String s = "";  
            for(int i=0;i<n;i++){  
                s += array[i];  
            }  
            totalNUm.add(s);  
            total++;  
        } else {  
            for (int i = k; i < n; i++) {  
                zuhe(array, n, k + 1);  
                swap(array, i, k);  
            }  
        }  
     }  
    private void swap(String[] a, int x, int y) {    
        String temp = a[x];  
        a[x] = a[y];  
        a[y] = temp;  
    }  
}ac0%

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.*; 

public class  Main {  
    static int total = 0;   
    static List totalNUm = new ArrayList();  
    public static void main(String[] args) {  
        System.out.println("请至少输入两个数字，用空格隔开");  
        Scanner scanner = new Scanner(System.in);
        int n=scanner.nextInt();
        int[] s = new int[n];               //scanner.nextLine().split(" "); 
        for (int i = 0; i < n; i++) {
         s[i] = scanner.nextInt();
         }
        for(int i = 0; i <n-1; i++)
        {
            for(int j = 0; j <n-1-i; j++)
            {  if(compare(s[i],s[i+1])<0)
               {
            int temp=s[i+1];
            s[i+1]=s[i];
            s[i]=temp;
              }  
           }
        }
        for(int i = 0; i <n; i++)
        {
            System.out.print(s[i]);
            }
        System.out.println();
    }  
    
    public  static  int compare(int num1,int num2)
    {
     String a=num1+"";
        String b=num2+"";
        int t1= Integer.parseInt(a+b);
            int t2=Integer.parseInt(b+a);
        
        return t1-t2;
    }
} 

ac0%

XKX1314520

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
训练级牛客

求数列的和数列的第一项为n，以后各项为前一项的平方根，求数列的前m项的和，精确保留2位小数。import java.util.Scanner; public class Main { public static void main(String[] args){ int m; double sum,n ; Scanner sc=new Scanner(S...
复制链接

扫一扫