java 高手请进 有三道题 急急急！！！！

Question

第一题：
幸运号码
描述:
教室里坐着10个人，等老师来抽取今天每个人的幸运号码，老师决定，今天的幸运号码是大家姓名的大小序由小到大排序(比较方式是：按位比较，小写字母永远大于大写字母）之后的编号（编号从1开始），给你10个人的姓名，请计算Petr的幸运号码是多少呢？

运行时间限制: 无限制
内存限制: 无限制
输入:
一行，10个字符串，用空格隔开，表示10个人的姓名，注意区分大小写

输出:
如果Petr存在，则输出Petr的编号，如果Petr不存在，则输出0。

样例输入: Petr bob Bob Alice alice aLice BOB bishop queen king

样例输出: 4

答案提示: 排序后的结果为：Alice BOB Bob Petr aLice alice bishop bob king queen

第二题

俗话说“条条道路通罗马”，我们要从数学上计算出到底有多少条路。已知有N个城市（N<=10），从0到9编号，城市间要么有一条路，要么没有路，请帮忙计算下从城市A到城市B之间到底有多少条路。

运行时间限制: 无限制
内存限制: 128 MByte
输入:
题目首先输入一行“N A B”(1 < N <= 10; 0 <= A,B <= 9; A != B)，N表示有多少个城市，A标识从编号为A的城市出发，B标识目的城市。紧接着输入N行，每行包含N个数字，要么为0，要么为1，标识从该行编号标识的城市到其他所有城市是否有路。

输出:
一个整数，标识从A到B有多少条路

样例输入: 3 0 2
1 1 1
1 1 1
1 1 1

样例输出: 2

答案提示: 城市数目较多，因此不能使用完全遍历，无法满足时间复杂度要求。

第三题

给定整数n(1<n<20)，按要求填充n*n数组，对角线元素填为1，从中心开始，每往外一层数字加1，6*6数组填充的结果为
1 3 3 3 3 1
3 1 2 2 1 3
3 2 1 1 2 3
3 2 1 1 2 3
3 1 2 2 1 3
1 3 3 3 3 1
5*5数组填充的结果为
1 3 3 3 1
3 1 2 1 3
3 2 1 2 3
3 1 2 1 3
1 3 3 3 1

运行时间限制: 无限制
内存限制: 无限制
输入:
正整数n(1<n<20)

输出:
n*n数组，对角线元素填为1，从中心开始，每往外一层数字加1

样例输入: 5

样例输出: 1 3 3 3 1
3 1 2 1 3
3 2 1 2 3
3 1 2 1 3
1 3 3 3 1
三道题 随便哪道 来个大神 先做一道 都能做更好 急求啊 谢谢

Answer 1

第一题：
package com.test.bytecal;

import java.util.Scanner;

public class Compare {
private static String[] names = new String[10];

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入学生姓名，空格表示区分");
for(int i = 0; i < 10; i++){
names[i] = input.next();
}
quicksort(names, 0, names.length -1);
System.out.println("请输入你要查找的学生编号");
String nameFind = input.next();
boolean flag = false;
for(int i = 0; i < names.length; i++){
if(names[i].equals(nameFind)){
flag = true;
System.out.println(nameFind + "的幸运编号是: " + (i + 1));
}
}
if(!flag){
System.out.println("你输入的姓名有误，不存在"+nameFind+"学生");
}

}

// 快速排序
public static void quicksort(String[] str, int left, int right) {
int dp;
if (left < right) {
dp = partition(str, left, right);
quicksort(str, left, dp - 1);
quicksort(str, dp + 1, right);
}
}
//快速排序的一次分位
public static int partition(String[] subStr, int left, int right) {
String pivot = subStr[left];
while (left < right) {
while (left < right && compareString(subStr[right], pivot) == 1)
right--;
if (left < right)
subStr[left++] = subStr[right];
while (left < right && compareString (subStr[left], pivot) == -1)
left++;
if (left < right)
subStr[right--] = subStr[left];
}
subStr[left] = pivot;
return left;
}
/**
* 字符串比较
* @param str1
* @param str2
* @return
*/
public static int compareString(String str1, String str2) {
int result = 0;
int len1 = str1.length();
int len2 = str2.length();
int minLength = len1 > len2 ? len2 : len1;
int mid = 0;
for (int i = 0; i < minLength; i++) {
char a = str1.charAt(i);
char b = str2.charAt(i);
mid = a - b;
if (mid > 0) {
result = 1;
break;
} else if (mid < 0) {
result = -1;
break;
} else {
continue;
}
}
if (result == 0) {
if (len1 < len2) {
result = -1;
} else if (len1 > len2) {
result = 1;
}
}
return result;
}
}
第二题：
package com.test.bytecal;

import java.util.Scanner;

public class MatrixMultiply {
private static int numSize = 0;
private static int start = 0;
private static int end = 0;

public static void main(String[] args) {
// TODO Auto-generated method stub
//初始化
System.out.println("请输入城市数目，起点和终点： ");
Scanner input = new Scanner(System.in);
numSize = input.nextInt();
start = input.nextInt();
end = input.nextInt();
int[][] matrixPosi = new int[numSize][numSize];
System.out.println("请输入城市路径情况矩阵: ");
for(int i = 0; i < numSize; i++){
for(int j = 0; j < numSize; j++){
matrixPosi[i][j] = input.nextInt();
}
}
//开始计算路径
int pathCoount = 0;
if(matrixPosi[start][end] == 1){
pathCoount ++;
}
if(numSize >= 3){
int mid[][] = multiplication(matrixPosi, matrixPosi);
if(mid[start][end] == 1){
pathCoount ++;
}
for(int i = 3 ; i <= numSize -1; i ++){
int[][] middle = multiplication(mid, matrixPosi);
if(middle[start][end] == 1){
pathCoount ++;
}
}
}

System.out.println("城市" + start +"到城市" + end + "，存在" + pathCoount + "条路径");

}
/**
* 矩阵相乘，利用Floyd算法思想
* @param matrixa
* @param matrixb
* @return
*/
public static int[][] multiplication(int[][] matrixa, int[][] matrixb) {
int[][] result = new int[numSize][numSize];
for(int i=0; i<numSize; i++) {
for(int j=0; j<matrixb[0].length; j++) {
// i will complete this tomorrow @2012/09/17
result[i][j] = calculateSingleResult(matrixa, matrixb, i, j);

}
}
return result;

}
/**
* 矩阵相乘，存贮计算结果，不唯一就是存在row->col的路径
* @param matrixa
* @param matrixb
* @param row
* @param col
* @return
*/
private static int calculateSingleResult(int[][] matrixa, int[][] matrixb, int row, int col) {
int result = 0;
for(int k=0; k<numSize; k++) {
result += matrixa[row][k] * matrixb[k][col];
if (result >= 1) {
return 1;
}
}
return result;
}
}

第三题，看了一下，不是很懂你题目的意思，每往外一层，加一？但是6*6的貌似没有按照这个规则.追问

那个罗马那道题 输入那里有问题 要求输入N行，每行包含N个数字。
你这里得输入N*N行
还有第一行的输入也是 不能用那么多回车。

追答

java默认的分隔符是空格，如果你在控制台输入的字符串后面包含空格的话，后面的数字和字符都不会给识别，这种机试题一般是给的文件格式，你也得用读取文件的方式读取。或者你更改分隔符设置成其他的。

Answer 2

public void show(int num){
if (num%2==0) {
for (int i = 1; i <= num/2; i++) {
for (int j = 1; j <= num; j++) {
if (j==i||j==num-i+1) {
System.out.print(1);
}else if(j<i){
System.out.print(num/2-j+1);

}else if(j>num-i+1){
System.out.print(num/2-(num-j));
}else{
System.out.print(num/2-i+1);
}
}
System.out.println();
}
for (int i = num/2; i >=1; i--) {
for (int j = 1; j <= num; j++) {
if (j==i||j==num-i+1) {
System.out.print(1);
}else if(j<i){
System.out.print(num/2-j+1);

}else if(j>num-i+1){
System.out.print(num/2-(num-j));
}else{
System.out.print(num/2-i+1);
}
}
System.out.println();
}
}else{
for (int i = 1; i <= num/2+1; i++) {
for (int j = 1; j <= num; j++) {
if (j==i||j==num-i+1) {
System.out.print(1);
}else if(j<i){
System.out.print(num/2+1-j+1);

}else if(j>num-i+1){
System.out.print(num/2+1-(num-j));
}else{
System.out.print(num/2+1-i+1);
}
}
System.out.println();
}
for (int i = num/2; i >=1; i--) {
for (int j = 1; j <= num; j++) {
if (j==i||j==num-i+1) {
System.out.print(1);
}else if(j<i){
System.out.print(num/2+1-j+1);

}else if(j>num-i+1){
System.out.print(num/2+1-(num-j));
}else{
System.out.print(num/2+1-i+1);
}
}
System.out.println();
}
}
}

 这是第三题

下面是第一题

public int index(String names,String name){ //names是用空格隔开的名字字符串  name是要查询的名字
String[] nas=names.split(" "); //把名字字符串拆成数组
Arrays.sort(nas); //数组排序
for (int i = 0; i < nas.length; i++) {
if (name.equals(nas[i])) {
return i+1;
}
}
return 0;
}

 我语文不好，第二题我实在是看不懂啊

追问

代码没有主函数啊

追答 public static void main(String[] args) {
Matrix m=new Matrix();    //这个是我的类名，根据你的类名改就行了
m.show(9);                //这个参数你随便改
// System.out.println(m.index("Petr bob Bob Alice alice aLice BOB bishop queen king", "Petr"));
}
注释部分是第一题

我现在没时间，想要的话私信我你的扣扣，最晚是今天晚上

 

这是第三题用单数9做的测试结果

这是用双数8做的测试结果

这是用你的例子"Petr bob Bob Alice alice aLice BOB bishop queen king",和"Petr" 做的测试结果



 public static void main(String[] args) {
Matrix m=new Matrix();    //这个是我的类名，根据你的类名改就行了
m.show(9);
// System.out.println(m.index("Petr bob Bob Alice alice aLice BOB bishop queen king", "Petr"));
}
注释部分是第一题

本回答被提问者采纳

Answer 3

第一题：

//获取键盘输入
Scanner scanner=new Scanner(System.in);
创建列表
List<String> list=new ArrayList<>();
//将输入的内容循环添加入列表
for(int i=0;i<10;i++){
    list.add(scanner.next());
}
//列表排序
Collections.sort(list,new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});
//如果有“Petr”的话输出位置(从0开始，所以要+1)，没有的话输出0(默认没有的话是-1)
System.out.println(list.indexOf("Petr")+1);

Answer 4

我帮你写最后一道,矩阵...追问

好的 谢谢

追答

明天早上再贴给你吧,走了

Answer 5

华为机试题喔? 我是C++的 只做出两道 T.T