电话号码分身_

Java

牛客196305255号

import java.util.*;
public class Main{
    private final static char[] sCHAR= {'Z','W','U','X','G','S','O','T','V','I'};
	private final static String[] sSTR= {"ZERO","TWO","FOUR","SIX",
			"EIGHT","SEVEN","ONE","THREE","FIVE","NINE"};
	private final static int[] sNUM= {2,4,6,8,0,9,3,5,7,1};
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        int t=sc.nextInt();
        sc.nextLine();
        for(int i=0;i<t;i++){
            String str=sc.nextLine();
            solve(str);
        }
        sc.close();
    }
    public static void solve(String str) {
		Map<Character,Integer> map=new HashMap<>();
		List<Integer> list=new ArrayList<>();
		for(int i=0;i<str.length();i++) {
			char c=str.charAt(i);
			if(map.containsKey(c))
				map.put(c, map.get(c)+1);
			else
				map.put(c,1);
		}
		for(int i=0;i<sCHAR.length;i++) {
			if(map.containsKey(sCHAR[i])) {
				int n=map.get(sCHAR[i]);
				if(n>0) {
					for(int j=0;j<n;j++) {
						list.add(sNUM[i]);
					}
					for(int j=0;j<sSTR[i].length();j++) {
						char c=sSTR[i].charAt(j);
						map.put(c, map.get(c)-n);
					}
				}
			}
		}
		Collections.sort(list);
		StringBuilder sb=new StringBuilder();
		for(int i:list)
			sb.append(i);
		System.out.println(sb.toString());
	}
}

发表于 2021-01-20 15:58:11 回复(0)

Java

重邮渣渣

//特别要注意9 nine 不能用n去判断除非除以2

import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStreamReader;

/**
* @author Y.bear
* @version 创建时间：2018年9月3日下午2:54:32 类说明
*/
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int times = Integer.valueOf(reader.readLine());
        String[] results=new String[times];
        for (int i = 0; i <times; i++) {
            int[] result = new int[10];
            String readLine = reader.readLine();
            transform(readLine, result);
            print(result,i,results);
        }
        for (String string : results) {
            System.out.println(string);
        }

    }

    public static void print(int[] result,int index,String[] results) {
        StringBuffer buffer=new StringBuffer();
        for (int i = 0; i < result.length; i++) {
            while (result[i] > 0) {
                result[i]--;
                buffer.append(i);
            }
        }
        results[index]=buffer.toString();

    }

    public static void getResult(int num, int count, int[] result) {
        while (count > 0) {
            count--;
            result[(num + 2) % 10]++;
        }
    }

    public static void transform(String line, int[] result) {
        char[] letters = new char[26];
        char[] charArray = line.toUpperCase().toCharArray();
        for (char c : charArray) {
            letters[c - 'A']++;
        }
        int zero = letters['Z' - 'A'];
        getResult(0, zero, result);
        letters['Z' - 'A'] -= zero;
        letters['E' - 'A'] -= zero;
        letters['R' - 'A'] -= zero;
        letters['O' - 'A'] -= zero;

        int two = letters['W' - 'A'];
        getResult(2, two,result);
        letters['T' - 'A'] -= two;
        letters['W' - 'A'] -= two;
        letters['O' - 'A'] -= two;

        int four = letters['U' - 'A'];
        getResult(4, four, result);
        letters['F' - 'A'] -= four;
        letters['O' - 'A'] -= four;
        letters['U' - 'A'] -= four;
        letters['R' - 'A'] -= four;

        int six = letters['X' - 'A'];
        getResult(6, six, result);
        letters['S' - 'A'] -= six;
        letters['I' - 'A'] -= six;
        letters['X' - 'A'] -= six;

        int eight = letters['G' - 'A'];
        getResult(8, eight, result);
        letters['E' - 'A'] -= eight;
        letters['I' - 'A'] -= eight;
        letters['G' - 'A'] -= eight;
        letters['H' - 'A'] -= eight;
        letters['T' - 'A'] -= eight;

        int one = letters['O' - 'A'];
        getResult(1, one, result);
        letters['O' - 'A'] -= one;
        letters['N' - 'A'] -= one;
        letters['E' - 'A'] -= one;

        int three = letters['T' - 'A'];
        getResult(3, three, result);
        letters['T' - 'A'] -= three;
        letters['H' - 'A'] -= three;
        letters['R' - 'A'] -= three;
        letters['E' - 'A'] -= three;
        letters['E' - 'A'] -= three;

        int five = letters['F' - 'A'];
        getResult(5, five, result);
        letters['F' - 'A'] -= five;
        letters['I' - 'A'] -= five;
        letters['V' - 'A'] -= five;
        letters['E' - 'A'] -= five;

        int seven = letters['S' - 'A'];
        getResult(7, seven, result);
        letters['S' - 'A'] -= seven;
        letters['E' - 'A'] -= seven;
        letters['V' - 'A'] -= seven;
        letters['E' - 'A'] -= seven;
        letters['N' - 'A'] -= seven;

        int nine = letters['I' - 'A'];
        getResult(9, nine, result);
        letters['N' - 'A'] -= nine;
        letters['I' - 'A'] -= nine;
        letters['N' - 'A'] -= nine;
        letters['E' - 'A'] -= nine;

    }
}

发表于 2018-09-03 16:48:21 回复(0)

Java

ゆなちゃん

import java.util.Scanner;
import java.util.ArrayList;

//0~9单词出现过的字母
enum alph{E,F,G,H,I,N,O,R,S,T,U,V,W,X,Z};

public class Main{
    public static int[] convert(String s){
        int alphTimes[]=new int[15];    //共15种字母；
        int numTimes[]=new int[10];
        
        for(int i=0;i<15;i++)alphTimes[i]=0;    //每个字母出现过的次数
        for(int i=0;i<10;i++)numTimes[i]=0;
        //统计所有字母出现过的次数
        char []p = s.toCharArray();
        for(int i=0;i<p.length;i++){
            switch(p[i]){
            case 'E':alphTimes[alph.E.ordinal()]++;break;
            case 'F':alphTimes[alph.F.ordinal()]++;break;
            case 'G':alphTimes[alph.G.ordinal()]++;break;
            case 'H':alphTimes[alph.H.ordinal()]++;break;
            case 'I':alphTimes[alph.I.ordinal()]++;break;
            case 'N':alphTimes[alph.N.ordinal()]++;break;
            case 'O':alphTimes[alph.O.ordinal()]++;break;
            case 'R':alphTimes[alph.R.ordinal()]++;break;
            case 'S':alphTimes[alph.S.ordinal()]++;break;
            case 'T':alphTimes[alph.T.ordinal()]++;break;
            case 'U':alphTimes[alph.U.ordinal()]++;break;
            case 'V':alphTimes[alph.V.ordinal()]++;break;
            case 'W':alphTimes[alph.W.ordinal()]++;break;
            case 'X':alphTimes[alph.X.ordinal()]++;break;
            case 'Z':alphTimes[alph.Z.ordinal()]++;break;
            default:break;
            }
        }
        //每个字母出现在的数字：
        //E(0,1,3,5,7,8,9), F(4,5), G(8), H(3,8), I(5,6,8,9)
        //N(1,7,9), O(0,1,2,4), R(0,3,4), S(6,7), T(2,3,8)
        //U(4), V(5,7), W(2), X(6), Z(0)
        //Round 1:只在1个单词里出现过的字母：Z(0),W(2),U(4),X(6),G(8)
        //这些直接统计各自出现的次数；但这是加8取余后的结果，我们应该存到+2取余的下标处
        numTimes[(0+2)%10]=alphTimes[alph.Z.ordinal()];
        numTimes[(2+2)%10]=alphTimes[alph.W.ordinal()];
        numTimes[(4+2)%10]=alphTimes[alph.U.ordinal()];
        numTimes[(6+2)%10]=alphTimes[alph.X.ordinal()];
        numTimes[(8+2)%10]=alphTimes[alph.G.ordinal()];
        //然后所有项减掉这些单词连带字母的次数；主角请摆到最后一个（或者不摆），否则后面的都是减零了
        //0
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.Z.ordinal()];
        alphTimes[alph.R.ordinal()]-=alphTimes[alph.Z.ordinal()];
        alphTimes[alph.O.ordinal()]-=alphTimes[alph.Z.ordinal()];
        alphTimes[alph.Z.ordinal()]-=alphTimes[alph.Z.ordinal()];
        //2
        alphTimes[alph.T.ordinal()]-=alphTimes[alph.W.ordinal()];
        alphTimes[alph.O.ordinal()]-=alphTimes[alph.W.ordinal()];
        alphTimes[alph.W.ordinal()]-=alphTimes[alph.W.ordinal()];
        //4
        alphTimes[alph.F.ordinal()]-=alphTimes[alph.U.ordinal()];
        alphTimes[alph.O.ordinal()]-=alphTimes[alph.U.ordinal()];
        alphTimes[alph.R.ordinal()]-=alphTimes[alph.U.ordinal()];
        alphTimes[alph.U.ordinal()]-=alphTimes[alph.U.ordinal()];
        //6
        alphTimes[alph.S.ordinal()]-=alphTimes[alph.X.ordinal()];
        alphTimes[alph.I.ordinal()]-=alphTimes[alph.X.ordinal()];
        alphTimes[alph.X.ordinal()]-=alphTimes[alph.X.ordinal()];
        //8
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.G.ordinal()];
        alphTimes[alph.I.ordinal()]-=alphTimes[alph.G.ordinal()];
        alphTimes[alph.H.ordinal()]-=alphTimes[alph.G.ordinal()];
        alphTimes[alph.T.ordinal()]-=alphTimes[alph.G.ordinal()];
        alphTimes[alph.G.ordinal()]-=alphTimes[alph.G.ordinal()];
        //更新一下，每个字母出现在的数字：
        //E(1,3,5,7,9), F(5), H(3), I(5,9), N(1,7,9)
        //O(1), R(3), S(7), T(3), V(5,7)
        //Round 2:剩下数字里有独立字母的有：1(O),3(H,R,T), 5(F), 7(S)，统计这些数字
        numTimes[(1+2)%10]=alphTimes[alph.O.ordinal()];
        numTimes[(3+2)%10]=alphTimes[alph.H.ordinal()];
        numTimes[(5+2)%10]=alphTimes[alph.F.ordinal()];
        numTimes[(7+2)%10]=alphTimes[alph.S.ordinal()];
        //各字母减掉次数
        //1
        alphTimes[alph.N.ordinal()]-=alphTimes[alph.O.ordinal()];
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.O.ordinal()];
        alphTimes[alph.O.ordinal()]-=alphTimes[alph.O.ordinal()];
        //3
        alphTimes[alph.H.ordinal()]-=alphTimes[alph.T.ordinal()];
        alphTimes[alph.R.ordinal()]-=alphTimes[alph.T.ordinal()];
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.T.ordinal()];
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.T.ordinal()];
        alphTimes[alph.T.ordinal()]-=alphTimes[alph.T.ordinal()];
        //5
        alphTimes[alph.I.ordinal()]-=alphTimes[alph.F.ordinal()];
        alphTimes[alph.V.ordinal()]-=alphTimes[alph.F.ordinal()];
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.F.ordinal()];
        alphTimes[alph.F.ordinal()]-=alphTimes[alph.F.ordinal()];
        //7
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.S.ordinal()];
        alphTimes[alph.V.ordinal()]-=alphTimes[alph.S.ordinal()];
        alphTimes[alph.E.ordinal()]-=alphTimes[alph.S.ordinal()];
        alphTimes[alph.N.ordinal()]-=alphTimes[alph.S.ordinal()];
        alphTimes[alph.S.ordinal()]-=alphTimes[alph.S.ordinal()];
        //剩下一个9，直接统计
        numTimes[(9+2)%10]=alphTimes[alph.I.ordinal()];
        //返回统计数列
        return numTimes;
    }
    public static void main(String args[]){
        Scanner s = new Scanner(System.in);
        int lines = s.nextInt();
        for(int i=0;i<lines;i++){
            String inp = s.next();
            int [] res = convert(inp);
            for(int j=0;j<10;j++){
                for(int k=0;k<res[j];k++)System.out.print(j);
            }
            System.out.println();
        }
    } 
}

发表于 2018-05-03 13:14:13 回复(0)

Java

小米李二牛

一张图说明一切问题

发表于 2018-03-29 16:44:43 回复(2)

Java

晨风20

//丧心病狂的题目
import java.util.Scanner; public class Main { public static void main(String[] args) {
        Scanner in = new Scanner(System.in);  int t = Integer.parseInt(in.nextLine());  for (int i = 0; i < t; i++) { doWork(in);
        }
    } public static void doWork(Scanner in) {
        String s = in.nextLine(); int[] cs = new int[27]; for (int i = 0; i < s.length(); i++) {
            cs[s.charAt(i) - 'A']++;
        } int[] num = new int[10];
        num[0] = cs['Z' - 'A'];
        num[6] = cs['X' - 'A'];
        num[2] = cs['W' - 'A'];
        num[4] = cs['U' - 'A'];
        num[8] = cs['G' - 'A'];
        num[3] = cs['T' - 'A'] - num[2] - num[8];
        num[7] = cs['S' - 'A'] - num[6];
        num[5] = cs['V' - 'A'] - num[7];
        num[1] = cs['O' - 'A'] - num[0] - num[2] - num[4];
        num[9] = (cs['N' - 'A'] - num[7] - num[1]) / 2;
        StringBuilder builder = new StringBuilder(); for (int i = 8; i <=9; i++) { for (int j = 0; j < num[i]; j++) {
                builder.append((i+2)%10);
            }
        } for (int i = 0; i <=7; i++) { for (int j = 0; j < num[i]; j++) {
                builder.append(i+2);
            }
        }
        System.out.println(builder.toString());
    }
}

发表于 2018-03-07 21:10:19 回复(0)

Java

傻傻傻傻

//电话号码分身
/**
 Z:zero
 X:six
 S:seven
 W:two
 G:wight
 V:five
 I:nine
 U:four
 R:three
 E:one
 */
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            int count = in.nextInt();
            StringBuilder[] strings = new StringBuilder[count];
            for (int i = 0; i < count; i++)
                strings[i] = new StringBuilder(in.next());
            
            for (int i = 0; i < count; i++) {
                StringBuilder res = new StringBuilder();
                while (strings[i].length() > 0) {
                    if (strings[i].toString().contains("Z")) {
                        //zero
                        res.append(0);
                        strings[i].deleteCharAt(strings[i].indexOf("Z"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                        strings[i].deleteCharAt(strings[i].indexOf("R"));
                        strings[i].deleteCharAt(strings[i].indexOf("O"));
                    } else if (strings[i].toString().contains("X")) {
                        //six
                        res.append(6);
                        strings[i].deleteCharAt(strings[i].indexOf("S"));
                        strings[i].deleteCharAt(strings[i].indexOf("I"));
                        strings[i].deleteCharAt(strings[i].indexOf("X"));
                    } else if (strings[i].toString().contains("S")) {
                        //seven
                        res.append(7);
                        strings[i].deleteCharAt(strings[i].indexOf("S"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                        strings[i].deleteCharAt(strings[i].indexOf("V"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                        strings[i].deleteCharAt(strings[i].indexOf("N"));
                    } else if (strings[i].toString().contains("W")) {
                        //two
                        res.append(2);
                        strings[i].deleteCharAt(strings[i].indexOf("T"));
                        strings[i].deleteCharAt(strings[i].indexOf("W"));
                        strings[i].deleteCharAt(strings[i].indexOf("O"));
                    } else if (strings[i].toString().contains("G")) {
                        //eight
                        res.append(8);
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                        strings[i].deleteCharAt(strings[i].indexOf("I"));
                        strings[i].deleteCharAt(strings[i].indexOf("G"));
                        strings[i].deleteCharAt(strings[i].indexOf("H"));
                        strings[i].deleteCharAt(strings[i].indexOf("T"));
                    } else if (strings[i].toString().contains("V")) {
                        //five
                        res.append(5);
                        strings[i].deleteCharAt(strings[i].indexOf("F"));
                        strings[i].deleteCharAt(strings[i].indexOf("I"));
                        strings[i].deleteCharAt(strings[i].indexOf("V"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                    } else if (strings[i].toString().contains("I")) {
                        //nine
                        res.append(9);
                        strings[i].deleteCharAt(strings[i].indexOf("N"));
                        strings[i].deleteCharAt(strings[i].indexOf("I"));
                        strings[i].deleteCharAt(strings[i].indexOf("N"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                    } else if (strings[i].toString().contains("U")) {
                        //four
                        res.append(4);
                        strings[i].deleteCharAt(strings[i].indexOf("F"));
                        strings[i].deleteCharAt(strings[i].indexOf("O"));
                        strings[i].deleteCharAt(strings[i].indexOf("U"));
                        strings[i].deleteCharAt(strings[i].indexOf("R"));
                    } else if (strings[i].toString().contains("R")) {
                        //three
                        res.append(3);
                        strings[i].deleteCharAt(strings[i].indexOf("T"));
                        strings[i].deleteCharAt(strings[i].indexOf("H"));
                        strings[i].deleteCharAt(strings[i].indexOf("R"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                    } else if (strings[i].toString().contains("E")) {
                        //one
                        res.append(1);
                        strings[i].deleteCharAt(strings[i].indexOf("O"));
                        strings[i].deleteCharAt(strings[i].indexOf("N"));
                        strings[i].deleteCharAt(strings[i].indexOf("E"));
                    }
                }
                //System.out.println(res.toString());
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < res.length(); j++) {
                    if (res.charAt(j) >= '8') sb.append(res.charAt(j) - '8');
                    else sb.append(res.charAt(j) + 10 - '8');
                }
                //System.out.println(sb.toString());
                char[] chs = new char[sb.length()];
                for (int j = 0; j < sb.length(); j++)
                    chs[j] = sb.charAt(j);
                Arrays.sort(chs);
                System.out.println(new String(chs));
            }
        }
    }
}

发表于 2017-12-25 21:11:07 回复(0)

Java

被遗忘尾巴上清晰的思念

注：思路来自码友“封刀隠”。

这道题主要是需要从字符串中剥离出0-9的英语单词个数，然后从0开始打印

剥离的方法是通过单词的特有字母来作为标记计数

"ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE"

0---Z, 2---W, 4---U, 6---X, 8---G

1用O表示需要减去0，2，4的个数，因为这三个单词中也有O

3用H表示减去8的个数

5用F表示减去4的个数

7用S表示减去6的个数

9用I表示减去5，6，8的个数

最后从0开始打印即可。

代码如下：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int t = sc.nextInt();
        sc.nextLine();
        for(int i = 0; i < t; i++)
        {
            String s = sc.nextLine();
            int len = s.length();
            int[] n = new int[10];
            for(int j = 0; j < len; j++)
            {
                if(s.charAt(j)=='Z')   //0
                    n[0]++;
                else if(s.charAt(j)=='O')//1   -0-2-4
                    n[1]++;
                else if(s.charAt(j)=='W')//2
                    n[2]++;
                else if(s.charAt(j)=='H')//3   -8   
                    n[3]++;
                else if(s.charAt(j)=='U')//4
                    n[4]++;
                else if(s.charAt(j)=='F')//5   -4
                    n[5]++;
                else if(s.charAt(j)=='X')//6
                    n[6]++;
                else if(s.charAt(j)=='S')//7   -6
                    n[7]++;
                else if(s.charAt(j)=='G')//8
                    n[8]++;
                else if(s.charAt(j)=='I')//9   -8-6-5
                    n[9]++;    
            }
            n[1] = n[1]-n[0]-n[2]-n[4];
            n[3] = n[3]-n[8];
            n[5] = n[5]-n[4];
            n[7] = n[7]-n[6];
            n[9] = n[9]-n[8]-n[6]-n[5];
            
            for(int j = 0; j < n[8]; j++)
                System.out.print(0);
            for(int j = 0; j < n[9]; j++)
                System.out.print(1);
            for(int k = 0; k < 8; k++)
            {
                for(int j = 0; j < n[k]; j++)
                    System.out.print(k+10-8);
            }
            System.out.println();
        }
    }
}

发表于 2017-12-18 00:14:02 回复(0)

Java

DoneSpeak

通过率 10%。还真不知道错误在哪里、、、

先统计不同字母的个数，在进行拼凑。

有人可以帮忙看下吗？

import java.util.Scanner;
import java.util.LinkedList;
import java.util.Arrays;

public class Main{
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		
		int n = in.nextInt();
		in.nextLine();
		while(n -- > 0) {
			String str = in.nextLine();
			int[] counts = new int[26];
			int[] nums = new int[10];
			for(int i = 0; i < str.length(); i ++) {
				counts[str.charAt(i)-'A'] ++;
			}
			// ZERO = Z
			nums[0] = counts['Z' - 'A'];
			// TWO = W
			nums[2] = counts['W' - 'A'];
			// FOUR = U
			nums[4] = counts['U' - 'A'];
			// SIX = X
			nums[6] = counts['X' - 'A'];
			// FIVE = F - FOUR
			nums[5] = counts['F' - 'A'] - nums[4];
			// SEVEN = V - FIVE
			nums[7] = counts['V' - 'A'] - nums[5];
			// EIGHT = G
			nums[8] = counts['G' - 'A'];
			// NINE = I - SIX - EIGHT - FIVE
			nums[9] = counts['I' - 'A'] - nums[6] - nums[8] - nums[5];
			// THREE = H - EIGHT
			nums[3] = counts['H' - 'A'] - nums[8];
			// ONE = O - ZERO - TWO - FOUR
			nums[1] = counts['O' - 'A'] - nums[0] - nums[2] - nums[4];
			String result = "";
			for(int i = 8; i != 7; i = (i + 1) % 10) {
				for(int j = 0; j < nums[i]; j ++) {
					int num = (i + 2) % 10;
					result += num;
				}
			}
			System.out.println(result);
		}
	}
	
}

编辑于 2017-09-14 16:27:43 回复(0)

Java

指offer的剑在哪？

难点在于：电话号码转换之后还被随机打乱了，这样就不太好找了，因为单词之间有些字母重复出来的；这里就需要观察力了，观察者九个单词之间的独立性；比如：z是zero专有字母，其余的一葫芦画瓢

发表于 2017-09-12 15:42:26 回复(0)

Java

while_wrong_debug

package cn.weisiqian.test;

import java.util.Scanner;

public class Test {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

int count = scanner.nextInt();

scanner.nextLine();

for (int i = 0; i < count; i++) {

StringBuffer str = new StringBuffer();

str.append(scanner.nextLine());

char[] array = str.toString().toCharArray();

int[] charCount = new int[26];

int[] numberCount = new int[10];

int length = array.length;

for (int j = 0; j < length; j++) {

charCount[array[j] - 'A']++;

}

charCount['F' - 'A'] -= charCount['U' - 'A'];

charCount['H' - 'A'] -= charCount['G' - 'A'];

charCount['O' - 'A'] -= charCount['U' - 'A'] + charCount['W' - 'A'] + charCount['Z' - 'A'];

charCount['I' - 'A'] -= charCount['G' - 'A'] + charCount['X' - 'A'] + charCount['F' - 'A'];

numberCount[0] += charCount['G' - 'A'];

numberCount[1] += charCount['I' - 'A'];

numberCount[2] += charCount['Z' - 'A'];

numberCount[3] += charCount['O' - 'A'];

numberCount[4] += charCount['W' - 'A'];

numberCount[5] += charCount['H' - 'A'];

numberCount[6] += charCount['U' - 'A'];

numberCount[7] += charCount['F' - 'A'];

numberCount[8] += charCount['X' - 'A'];

numberCount[9] += charCount['S' - 'A'];

for (int j = 0; j < 10; j++) {

for (int k = 0; k < numberCount[j]; k++) {

System.out.print(j);

}

System.out.println("");

}

发表于 2017-08-27 22:54:17 回复(0)

Java

飞翔152

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
            int number = sc.nextInt();
            for (int i = 0; i < number; i++) {
                String fenshen  = sc.next();
                result(fenshen);
            }
    }

    private static void result(String fenshen) {
            int [] sa = {0,0,0,0,0,0,0,0,0,0};
            char [] arr_num = fenshen.toCharArray();
            ArrayList<String> numArray = new ArrayList<String>();
            numArray.clear();
            for (char j :arr_num)
            {
                numArray.add(String.valueOf(j));
            }

                while (numArray.remove("Z")) {
                    sa[0] ++;
                    numArray.remove("O");
                }

                while (numArray.remove("W")) {
                    sa[2] ++;
                    numArray.remove("O");
                }

                while (numArray.remove("U")) {
                    sa[4] ++;
                    numArray.remove("O");
                    numArray.remove("F");
                }

                while (numArray.remove("X")) {
                    sa[6] ++;
                    numArray.remove("S");
                    numArray.remove("I");
                }

                while (numArray.remove("G")) {
                    sa[8]++;
                    numArray.remove("H");
                    numArray.remove("I");
                }

                while (numArray.remove("H")) {
                    sa[3] ++;
                }

                while (numArray.remove("F")) {
                    sa[5] ++;
                    numArray.remove("I");
                }

                while (numArray.remove("S")) {
                    sa[7] ++;
                }

                while (numArray.remove("O")) {
                    sa[1] ++;
                }

                while (numArray.remove("I")) {
                    sa[9] ++;
                }

            for(int k=8;k<18;k++)
            {
                int a;
                if (k>9) a=k-10;
                else
                    a=k;


                if (sa[a]>0) {

                    if (a < 8)
                        for (int j=0;j<sa[a];j++) {
                            System.out.print(a + 2);
                        }
                    else

                        for (int j=0;j<sa[a];j++) {
                            System.out.print(a - 8);
                        }
                }
            }
            System.out.println();
    }
}

编辑于 2017-08-13 03:32:51 回复(0)

Java

Evergreen

**，**题

import java.util.Scanner;

/**
 * Created by Evergreen on 2017/8/10.
 */
public class Main {
    public static void handle(String str){
        str=str.toLowerCase();
        int[] hash=new int[10];
        StringBuffer sb=new StringBuffer(str);
        while(sb.toString().contains("z")){//zero
            //2
            hash[2]++;
            sb.deleteCharAt(sb.indexOf("z"));
            sb.deleteCharAt(sb.indexOf("e"));
            sb.deleteCharAt(sb.indexOf("r"));
            sb.deleteCharAt(sb.indexOf("o"));
        }
        while(sb.toString().contains("x")){//six
            hash[8]++;
            sb.deleteCharAt(sb.indexOf("s"));
            sb.deleteCharAt(sb.indexOf("i"));
            sb.deleteCharAt(sb.indexOf("x"));
        }
        while(sb.toString().contains("s")){//seven
            hash[9]++;
            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"));
        }
        while(sb.toString().contains("u")){//four
            hash[6]++;
            sb.deleteCharAt(sb.indexOf("f"));
            sb.deleteCharAt(sb.indexOf("o"));
            sb.deleteCharAt(sb.indexOf("u"));
            sb.deleteCharAt(sb.indexOf("r"));
        }
        while(sb.toString().contains("f")){//five
            hash[7]++;
            sb.deleteCharAt(sb.indexOf("f"));
            sb.deleteCharAt(sb.indexOf("i"));
            sb.deleteCharAt(sb.indexOf("v"));
            sb.deleteCharAt(sb.indexOf("e"));
        }
        while(sb.toString().contains("g")){//eight
            hash[0]++;
            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"));
        }
        while(sb.toString().contains("w")){//two
            hash[4]++;
            sb.deleteCharAt(sb.indexOf("t"));
            sb.deleteCharAt(sb.indexOf("w"));
            sb.deleteCharAt(sb.indexOf("o"));
        }
        while(sb.toString().contains("h")&&!sb.toString().contains("g")){//three
            hash[5]++;
            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"));
        }
        while(sb.toString().contains("o")&&!sb.toString().contains("z")){//one
            hash[3]++;
            sb.deleteCharAt(sb.indexOf("o"));
            sb.deleteCharAt(sb.indexOf("n"));
            sb.deleteCharAt(sb.indexOf("e"));
        }
        while(sb.toString().contains("n")) {//nine
            hash[1]++;
            sb.deleteCharAt(sb.indexOf("n"));
            sb.deleteCharAt(sb.indexOf("i"));
            sb.deleteCharAt(sb.indexOf("n"));
            sb.deleteCharAt(sb.indexOf("e"));
        }
        for(int i=0;i<10;i++){
            for(int j=1;j<=hash[i];j++){
                System.out.print(i);
            }
        }
        System.out.println();
    }
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextInt()){
            int n=sc.nextInt();
            for(int i=0;i<n;i++)
                handle(sc.next());
        }
    }
}

发表于 2017-08-10 14:23:11 回复(18)

Java

superyouyo

统计拥有的字母数量，然后可以找到规律，只有0（ZERO）有字母Z，也就是说，有多少个Z就有多少个0。同理，只有2有字母W，4有字母U，6有字母X，8有字母G。

将上述单词从字母统计中删去，发现剩下的单词中，只有5有字母F，1有字母O，3有字母R，7有字母S。

再删去，发现只有9有字母I。

将以上数字统计后排序可得。

import java.util.*;
import java.lang.*;

public class Main {
    static String[] table = { "ZERO", "ONE", "TWO", "THREE", "FOUR", "FIVE",
            "SIX", "SEVEN", "EIGHT", "NINE" };
    static int retL = 0;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i, j;
        int n = sc.nextInt();
        sc.nextLine();
        String str;
        int[] mark = new int[26];
        int[] ret = new int[10000];
        int temp = 0;
        while (sc.hasNext()) {
            retL = 0;
            str = sc.nextLine();
            for(i=0;i<str.length();i++) {
                mark[str.charAt(i)-'A']++;
            }

            if(mark['Z' - 'A'] != 0) handle(mark, ret, 2, 'Z');
            if(mark['W' - 'A'] != 0) handle(mark, ret, 4, 'W');
            if(mark['U' - 'A'] != 0) handle(mark, ret, 6, 'U');
            if(mark['X' - 'A'] != 0) handle(mark, ret, 8, 'X');
            if(mark['G' - 'A'] != 0) handle(mark, ret, 0, 'G');
            if(mark['F' - 'A'] != 0) handle(mark, ret, 7, 'F');
            if(mark['O' - 'A'] != 0) handle(mark, ret, 3, 'O');
            if(mark['R' - 'A'] != 0) handle(mark, ret, 5, 'R');
            if(mark['S' - 'A'] != 0) handle(mark, ret, 9, 'S');
            if(mark['I' - 'A'] != 0) handle(mark, ret, 1, 'I');

            Arrays.sort(ret,0,retL);
            for (i = 0; i < retL; i++) {
                System.out.print(ret[i]);
            }
            System.out.println();
        }
    }

    public static void handle(int[] mark, int[] ret, int num, char point) {
        int temp = mark[point - 'A'],i;
        for (i = 0; i < temp; i++) {
            ret[retL++] = num;
        }
        for (i = 0; i < table[(num+8)%10].length(); i++) {
            mark[table[(num+8)%10].charAt(i) - 'A'] -= temp;
        }
    }
}

编辑于 2017-08-09 05:11:54 回复(1)

电话号码分身

输入描述:

输出描述:

输入

输出

问题信息

热门推荐

通过挑战的用户

相关试题