某华

题目描述

Jessi初学英语，为了快速读出一串数字，编写程序将数字转换成英文：

如22：twenty two，123：one hundred and twenty three。

说明：

数字为正整数，长度不超过九位，不考虑小数，转化结果为英文小写；

输出格式为twenty two；

非法数据请返回“error”；

关键字提示：and，billion，million，thousand，hundred。

方法原型：public static String parse(long num) 

输入描述:

输入一个long型整数

输出描述:

输出相应的英文写法

示例1

输入

2356

输出

two thousand three hundred and fifty six

import java.util.*;
 public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){//需考虑循环输入 而非单个输入
                String n=sc.nextLine();
                if (n.length()>9||n.contains(".")) {
                    System.out.println("error");
                }
                else {
                    int da=Integer.parseInt(n);
                    System.out.println(defineOut(da));//按照百亿、百万、千进行讨论

                }
            }
    }
       //处理千以内的数
    private static String defineOut3(int da) {
        String[] num1= {"zero","one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
        String[] num2 = { "ten", "eleven", "twelve", "thirteen", "fourteen",    "fifteen", "sixteen","seventeen", "eighteen", "nineteen" };
        String[] num3 = { "","","twenty", "thirty", "forty", "fifty", "sixty",     "seventy", "eighty","ninety" };
        String result="";
        int bai=da/100;
        int shi=da%100/10;
        int ge=da%10;
        if (bai!=0) {
            result=num1[bai]+" "+"hundred and ";
        }
        if (shi!=0&&shi>=2) {
            result=result+num3[shi];
            if (ge!=0) {
                result=result+" "+num1[ge];
            }
        }else if(shi==0){

            result=result+num1[ge];
        }
        else{
            result=result+num2[da%100-10];
        }
        return result;
    }
    private static String defineOut(int da) {
        if (0<=da&&da<1000) {
            return defineOut3(da);
        }
        else if (1000<=da&&da<1000000) {
           
            return defineOut6(da);
        } 
        else if (1000000<=da&&da<1000000000) {
            return defineOut9(da);
        }
        return "error"; 
    }
      //将百亿化作百万与千以内的数进行处理
    private static String defineOut9(int da) {
         int num1=da/1000000;
         int num2=da%1000000;
         return defineOut3(num1)+" million "+defineOut6(num2);
    }
       //将百万化作两个千以内的数处理
    private static String defineOut6(int da) {
        int num1=da/1000;
        int num2=da%1000;
        return defineOut3(num1)+" thousand "+defineOut3(num2);
    }
}

题目描述

写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。

输入描述:

输入一个有字母和数字以及空格组成的字符串，和一个字符。

输出描述:

输出输入字符串中含有该字符的个数。

 示例1:

输入

ABCDEF 
A

输出

1

import java.util.*;
 public class Main {
    public static void main(String[] args) {
        
        Scanner sc=new Scanner(System.in);
        String line =sc.nextLine();
        String s=sc.nextLine().toUpperCase();
        int count=0;
        char da=s.charAt(0);
        char[] data=line.toUpperCase().toCharArray();//若使用getBytes（）data[i]l里面放的则是该字符对应的数字
        for (int i = 0; i < data.length; i++) {
            
            if (data[i]==da) {
                count++;
            }
        }
        System.out.println(count);
        
       
    }
 
}

题目描述

明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作(同一个测试用例里可能会有多组数据，希望大家能正确处理)。

Input Param

n               输入随机数的个数

inputArray      n个随机整数组成的数组

Return Value

OutputArray    输出处理后的随机整数

 注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

输入描述:

输入多行，先输入随机整数的个数，再输入相应个数的整数

输出描述:

返回多行，处理后的结果

示例1

输入:

11
10
20
40
32
67
40
20
89
300
400
15

输出

10
15
20
32
40
67
89
300
400

import java.util.*;
public class Main {
   public static void main(String[] args) 
   {
        Scanner sc=new Scanner(System.in);
       while(sc.hasNext()){
          int count=sc.nextInt();
          int[] da=new int[count];
          HashSet<Integer> s=new HashSet<>();
          for (int i = 0; i < count; i++) {
            da[i]=sc.nextInt();
        }
          Arrays.sort(da);
          for (int i = 0; i < da.length; i++) {
            s.add(da[i]);
        }
          Iterator<Integer> i=s.iterator();
        ArrayList<Integer> t=new ArrayList<>();
          while (i.hasNext()) {
            t.add(i.next());
            
        }
      Collections.sort(t);
       for (int j = 0; j < t.size(); j++) {
        System.out.println(t.get(j));
      }
    }
         sc.close();
          
    }

}
 
 

题目描述

写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

输入描述:

输入一个十六进制的数值字符串。

输出描述:

输出该数值的十进制字符串。

示例1

输入

0xA

输出

10

import java.util.Scanner;

public class Main {
   public static void main(String[] args) 
   {
       Scanner sc=new Scanner(System.in);
       while (sc.hasNext()) {
           String a=sc.nextLine();
           String data=a.substring(2, a.length());
           char[] da=data.toCharArray();
           
           int len=a.length();
           int sum=0;
           for (int j = 0; j < da.length; j++) {
               sum=(int) (sum+toTen(da[j])*Math.pow(16, da.length-j-1));
           }
           System.out.println(sum);
           
           
       }
        sc.close();
    }
   public static int toTen(char s) 
   {
       switch (s) {
        case 'A':return 10;
        case 'B':return 11;
        case 'C':return 12;
        case 'D':return 13;
        case 'E':return 14;
        case 'F':return 15;
        case '1':return 1;
        case '2':return 2;
        case '3':return 3;
        case '4':return 4;
        case '5':return 5;
        case '6':return 6;
        case '7':return 7;
        case '8':return 8;
        case '9':return 9;
        case '0':return 0;
    default:
        return -1;
        
    }
   }

}
 

题目描述

功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）

最后一个数后面也要有空格

 

详细描述：

函数接口说明：

public String getResult(long ulDataInput)

输入参数：

long ulDataInput：输入的正整数

返回值：

String

输入描述:

输入一个long型整数

输出描述:

按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。

示例1

输入

180

输出

2 2 3 3 5

package uestc;

import java.util.Scanner;
public class Main {
   public static void main(String[] args) 
   {
       Scanner sc=new Scanner(System.in);
       while (sc.hasNext()) {
           long a=sc.nextLong();
           if (a<2) {
            return;
            }
           System.out.println(getResult(a)); 
       }
        sc.close();
    }
   public static String getResult(long s) 
   {
       StringBuilder sb=new StringBuilder();
       for (int i = 2; i <= s; i++) {
            while(s%i==0) {
                sb.append(i).append(" ");
                s=s/i;
            }
       }
      return sb.toString();
    }
}
 

题目描述

开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。

输入：

合法坐标为A(或者D或者W或者S) + 数字（两位以内）

坐标之间以;分隔。

非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。

下面是一个简单的例子 如：

A10;S20;W10;D30;X;A1A;B10A11;;A10;

处理过程：

起点（0,0）

+   A10   =  （-10,0）

+   S20   =  (-10,-20)

+   W10  =  (-10,-10)

+   D30  =  (20,-10)

+   x    =  无效

+   A1A   =  无效

+   B10A11   =  无效

+  一个空 不影响

+   A10  =  (10,-10)

结果 （10， -10）

输入描述:

一行字符串

输出描述:

最终坐标，以,分隔

示例1

输入:

A10;S20;W10;D30;X;A1A;B10A11;;A10;

输出:

10,-10

import java.util.ArrayList;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Main {
   public static void main(String[] args) 
   {
       Scanner sc=new Scanner(System.in);
       while (sc.hasNext()) {
          String a=sc.nextLine();
          Point point=new Point(0,0);
          String[] data=a.split(";");
          ArrayList<String> subDatasets=new ArrayList<>();
          for (int i = 0; i < data.length; i++) {
              if (data[i].length()>3||data[i].length()<=1) {
                continue;
            }else {
              String regex="(A|S|W|D)\d{1,2}$";
              Pattern pattern=Pattern.compile(regex,Pattern.MULTILINE);
              Matcher matcher=pattern.matcher(data[i]);
              while(matcher.find())
              {   
                   subDatasets.add(matcher.group());
              };
            }
              
          }
          for (int i = 0; i < subDatasets.size(); i++) {
              
                point=calculate(subDatasets.get(i),point);
               
          }
          System.out.println(point.x+","+point.y);
          subDatasets.clear();
          
           
        }
        sc.close();
    }

        private static Point calculate(String string,Point data) {
            String s=string.substring(0, 1); 
            
            int da=Integer.parseInt(string.substring(1, string.length()));     
            switch (s) {
                case "A":return new Point(data.x-da,data.y);
                case "S":return new Point(data.x,data.y-da);
                case "W":return new Point(data.x,data.y+da);
                case "D":return new Point(data.x+da,data.y);
                default:
                    break;
                }
            return data;
            
        }
static class Point 
   {
        private int x;
        private int y;
     
        public Point(int x,int y) {
            this.x=x;
            this.y=y;
        }
    }
}