常见面试题

/*明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，
他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，
只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把
这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。*/
import java.util.Scanner;
import java.util.TreeSet;
  
public class Main {
          
    public static void main(String[] args) {
          
  
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
              
            int num = sc.nextInt();
            TreeSet<Integer> set = new TreeSet<Integer>();
            for(int i = 0 ; i < num ;i++){
                int curr = sc.nextInt();
                set.add(curr);
            }
            for(Integer i : set){
                System.out.println(i);
            }
        }
    }
      
      
}




/*求两个数的最小公倍数*/
import java.util.Scanner;
public class Main {
    public static int getResult(int m ,int n){
        if(m<n){
            int temp=m;
            m=n;
            n=temp;
        }
        int k;
        while(n!=0){
            k=m%n;
            m=n;
            n=k;
        }
        return m;
    }
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        while(reader.hasNext()){
            int m = reader.nextInt();
            int n = reader.nextInt();
            System.out.println(m*n/getResult(m, n));
        }
 
    }
 
}
/*
计算一个数字的立方根，不使用库函数


详细描述：


•接口说明


原型：


public static double getCubeRoot(double input)


输入:double 待求解参数


返回值:double  输入参数的立方根
*/
import java.util.*;
 
public class Main
{
    // 使用二分查找算法
    public static double getCubeRoot(double input)
    {
        double min = 0;
        double max = input;
        double mid = 0;
         
        // 注意，这里的精度要提高一点，否则某些测试用例无法通过
        while ((max - min) > 0.001)
        {
            mid = (max + min) / 2;
            if (mid * mid * mid > input)
                max = mid;
            else if (mid * mid * mid < input)
                min = mid;
            else
                return mid;
        }
        return max;
    }
 
    public static void main(String[] args)
    {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext())
        {
            double input = sc.nextDouble();
            double result = getCubeRoot(input);
            System.out.printf("%.1f\n", result);
        }
        sc.close();
    }
}
/*
将一个字符串str的内容颠倒过来，并输出。str的长度不超过100个字符。 如：输入“I am a student”，输出“tneduts a ma I”。
*/
import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            String str = sc.nextLine();//next()是遇到空格；nextLine()是遇到回车
            StringBuilder sb = new StringBuilder(str);          
            System.out.println(sb.reverse().toString());
        }}}
/*
从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值
*/
import java.util.*;
  
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int count1 = 0;
        int count2 = 0;
        float sum = 0;
        while(in.hasNext()){
            int n = in.nextInt();
            if(n<0){
                count1++;
            }else{
                count2++;
                sum+=n;
            }
        }
        float average = sum/count2;
        System.out.println(count1);
        System.out.printf("%.1f\n",average);
    }
}
/*
连续输入字符串(输出次数为N,字符串长度小于100)，请按长度为8拆分每个字符串后输出到新的字符串数组，


长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。
*/
import java.util.Scanner;
 
 
 
public class Main {
 
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNextLine()){
            String s=scanner.nextLine();
            split(s);
        }
    }
     
    public static void split(String s){
        while(s.length()>=8){
            System.out.println(s.substring(0, 8));
            s=s.substring(8);
        }
        if(s.length()<8&&s.length()>0){
            s=s+"00000000";
            System.out.println(s.substring(0, 8));
        }
    }
     
 
}
/*
 Redraiment是走梅花桩的高手。Redraiment总是起点不限，从前到后，往高的桩子走，但走的步数最多，不知道为什么？你能替Redraiment研究他最多走的步数吗？ 


 


样例输入


6


2 5 1 5 4 5


 


样例输出


3


 


提示


Example: 
6个点的高度各为 2 5 1 5 4 5 
如从第1格开始走,最多为3步, 2 4 5 
从第2格开始走,最多只有1步,5 
而从第3格开始走最多有3步,1 4 5 
从第5格开始走最多有2步,4 5


所以这个结果是3。
*/
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(){
    int n;
    while(cin>>n){
        vector<int> data(n,0);
        vector<int> dp(n,1);
        int result=0;
        for(int i=0;i<n;i++){
            cin>>data[i];
            for(int j=0;j<i;j++){
                if(data[i]>data[j])
                dp[i]=max(dp[i],dp[j]+1);
            }
            result=max(result,dp[i]);
        }
        cout<<result<<endl;
    }
    return 0;
}


/*写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）*/
import java.lang.Math;
import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
  
        while(sc.hasNext()){
            String str = sc.nextLine();
            System.out.println(fun(str.substring(2)));
        }
    }
  
    public static int fun(String s){
        int n=0;
        int count= 0;
        int temp = 0;
        char ch;
  
        while(count<s.length())
        {
            ch = s.charAt(s.length()-count-1);
            if(ch>='0'&&ch<='9'){
                temp = ch-'0';
            }else if(ch>='A'&&ch<='Z'){
                temp = ch-'A'+10;
            }else if(ch>='a'&&ch<='z'){
                temp = ch-'a'+10;
            }else{
                break;
            }
            n += temp*Math.pow(16,count);
            count++;
        }
  
        return n;
    }
}


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


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


详细描述：




函数接口说明：


public String getResult(long ulDataInput)


输入参数：


long ulDataInput：输入的正整数


返回值：


String*/
import java.util.*;
  
public class Main
    {
    public static void main(String [] args)
        {
        Scanner sc=new Scanner(System.in);
        long params=sc.nextLong();
        if(params<2)
        {
            sc.close();
            return ;
        }
        String result =getResult(params);
        System.out.println(result);
        sc.close();
  
    }
     
    public static String getResult(long ulDataInput)
        {
        StringBuilder str=new StringBuilder();
        int index=2;
        while(index<=ulDataInput)
            {
            if(ulDataInput%index==0){
                 if(index==ulDataInput){
                 str.append(index).append(" ");
                     break;
                }else{
                      str.append(index).append(" ");
                     ulDataInput=ulDataInput/index;
            }
            }else
                {
                index++; 
            }
        } 
    return str.toString();
    }
}


/*
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整
*/
import java.util.Scanner;
public class Main {
 
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        double d=scanner.nextDouble();
        System.out.println(getReturn(d));
    }
     
    public static int getReturn(double d) {
        int i=(int)d;
        return  (d-i)>=0.5?i+1:i;
    }
     
 
}


/*数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出*/
import java.util.Iterator;
import java.util.Map;
import java.util.Scanner;
import java.util.TreeMap;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            Map<Integer, Integer> map = new TreeMap<Integer, Integer>();
            int n = sc.nextInt();
            for (int i = 0; i < n; i++) {
                int s=sc.nextInt();
                int value=sc.nextInt();
                if (map.containsKey(s)) {
                    map.put(s, map.get(s) + value);
                } else
                    map.put(s, value);
            }
            for (Integer key : map.keySet()) {
                System.out.println(key + " " + map.get(key));
            }
        }
    }
}


/*输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数*/
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        @SuppressWarnings("resource")
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            String s=scanner.nextLine();
            int len=s.length();
            int []arr1=new int[10];
            for(int i=len-1;i>=0;i--){
                if(arr1[s.charAt(i)-48]==0){
                    System.out.print(s.charAt(i)-48);
                    arr1[s.charAt(i)-48]++;
                }
            }
        }
    }
}


/*编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计*/
import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        while(scanner.hasNext()){
            String s=scanner.nextLine();
            int len=getLen(s);
            System.out.println(len);
        }
    }
     
public static int  getLen(String s) {
    int[] arr=new int[128];
    for(int i=0;i<s.length();i++){
        arr[s.charAt(i)]=1;
    }
    int len=0;
    for (int i = 0; i < arr.length; i++) {
        if(arr[i]==1){
            len++;
        }
    }
    return len;
}
}
/*输入一个整数，将这个整数以字符串的形式逆序输出


程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001
*/
import java.util.Scanner;
 
public class Main {
 
    public static void main(String[] args) {
        int n = new Scanner(System.in).nextInt();
        System.out.println(reverse(n));
 
    }
    private static String reverse(int n){
        String str = String.valueOf(n);
        StringBuffer sb = new StringBuffer();
        for(int i=str.length()-1;i>=0;i--){
            sb.append(str.charAt(i));
        }
        return sb.toString();
    }
 
}


/*
对字符中的
各个英文字符（大小写分开统计），数字，空格进行统计，并按照统计个数由多到少输出,如果统计的个数相同，则按照ASII码由小到大排序输出 。如果有其他字符，则对这些字符不用进行统计。
*/
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
    string st;
    while (getline(cin, st))
    {
        int a[128] = {0}, i, j, b[128] = {0};
        for (i = 0; i < st.length(); ++i)
        {
            a[st[i]]++;
            b[st[i]]++;
        }
        sort(a, a + 128);
        sort(st.begin(), st.end());
        for (i = 127; i >= 0; --i)
        {
            if (a[i] == 0)break;
            for (j = 0; j < st.length(); ++j)
            {
                if (b[st[j]] == a[i])
                {
                    cout << st[j];
                    b[st[j]] = 0;
                    break;
                }
            }
        }
        cout << endl;
    }
    return 0;
}


/*
输入整型数组和排序标识，对其元素按照升序或降序进行排序


接口说明


原型：


void sortIntegerArray(Integer[] pIntegerArray, int iSortFlag);


输入参数：


    Integer[] pIntegerArray：整型数组


int  iSortFlag：排序标识：0表示按升序，1表示按降序


输出参数：


    无


返回值：


    void
*/
#include <iostream> 
#include <algorithm> 
  
using namespace std;
    
int main(void) 
{ 
    int n;
    while ( cin >> n )
    {
        int A[n], i = n-1, tag;
        for (i = 0; i < n; i++)
            cin >> A[i];
        cin >> tag;
        sort(A, A+n);
        if (tag == 1)
            reverse(A, A+n);
        for (i = 0; i < n-1; i++)
            cout << A[i] << ' ';
        cout << A[n-1] << endl;
    }    
} 


/*
功能:等差数列 2，5，8，11，14。。。。


输入:正整数N >0


输出:求等差数列前N项和


返回:转换成功返回 0 ,非法输入与异常返回-1
*/
//等差数列求和公式：Sn=a1*n+n*(n-1)*d/2
import java.util.*;
  
public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int n = in.nextInt();
            if(n<1){
                System.out.println(-1);
            }else{
                System.out.println((2*n+3*n*(n-1)/2));
            }
             
        }
        in.close();
    }
}


/*
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：25^2 = 625，76^2 = 5776，9376^2 = 87909376。请求出n以内的自守数的个数




接口说明




/*
功能: 求出n以内的自守数的个数




输入参数：
int n


返回值：
n以内自守数的数量。
*/
#include <iostream>
#include <string>
using namespace std;
//转换成字符串 查找，利用现成的库函数 =-=
int main()
{
    long n;
    while(cin>>n){
        int ans = 2;// 0, 1也是
        for(long i = 3; i<=n; i++){
            long n2 = i*i;
            string s1 = to_string(i);
            string s2 = to_string(n2);
            int pos = s2.size()- s1.size();
            if(s2.find(s1,pos) != -1)
                ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}