关于使用二维数组输出和字符串问题

Question

本帖最后由 xdrs_lu 于 2010-03-19 20:41:49 编辑

Answer 1

是问题太简单，没人想回答么o(>﹏<)o

Answer 2

/**
 * @(#)Print.java
 *
 *
 * @author 
 * @version 1.00 2010/3/19
 */public class Print {
        
    /**
     * Creates a new instance of <code>Print</code>.
     */
    public Print() {
    
     int n = 4;
    
     int a[][] = new int[n][n];
    
     for(int i=0;i<n;i++){
     for(int j=i;j<n;j++)
     a[i][j]=a[j][i]=i;
    
     }
    
     //输出a
     print(a,n,n);
    
     int b[][] = new int[4][7];
     for(int i=n-1;i>=0;i--)
     for(int j=3;j>=3-i;j--)
     b[i][j]=b[i][6-j]=j+i-2;
     //输出b
     print(b,n,7);
    }
    
    void print(int a[][],int n,int m){
    
     for(int i=0;i<n;i++){
     for(int j=0;j<m;j++)
     System.out.print(a[i][j]+" ");
     System.out.println("\n");
     }
    }
    
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
        
        new Print();
    }
}

Answer 3

形象点的说吧，Java的二维数组可以声明为每行长短不一的形式，这样解第二个问题就可以一步到位了。至于第一题，还是好好看看书吧，都是数组应用的基础问题，看看书自己肯定能解决的

Answer 4

找不到符号
符号： 方法 print(int[][],int,int)
位置： 类 HomeWork
       print(a,n,n);
       ^
1 错误它说出现错误，而且我也不明为什么输出的格式不是应该写成"System.out.println()"这样吗？也把整个程序在JCreator上运行了一次，还是错误"D:\JAVA\HomeWork.java:58: 需要为 class、interface 或 enum
}         
^
1 错误”

Answer 5

1.不多说了，几个循环就能搞定的事，写个伪代码1.1
for(int i=0; i<4; i++) {
    for(int j=i; j<4; j++) {
        a[i][j] = i;
        a[j][i] = i;
    }
}
1.2
杨辉三角？
可以看成是个4*7的二维数组，满足一定规则输出数组的元素，现在没法调~
2.
将两个字符串转化成两个字符数组，然后排序，然后用两个升序数组合并的那种算法就可以找到相同得了~

Answer 6

在JAVA中一维数组是引用，二维数组是在一维数组的基础上再添加引用。

Answer 7

哇~传说中的牛人啊~
谢谢指教~只是，第2题我知道怎么样找相同的，但是会有两个相同答案输出不是么，比如说string s1="welcome to zhuhai",s2="come here"。我的方法是作比较，那s1中的welcome里，就有两个e了，并且与s2中都有相应的相同字符，那最后答案会输出两个e，我可以只让它输出一个e吗？因为我不会用你说的那种数组合并的算法

Answer 8

public static void main(String[] args) {
int a[][] = new int[4][4];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
System.out.print(i > j ? j : i);
}
System.out.println();
}
}

Answer 9

[code=java] 
public class Main {    /**
     * 数组呀数组
     */
    public static void main(String[] args) {
        ///////1-1
        c1(11);
        System.out.println("");
        /////1-2
        c2(11);        ///2
        String s1="welcome to Zhuhai",s2="come here";
        java.util.HashSet set = new java.util.HashSet();
        for(int k=0;k<s1.length();k++){
            for(int j=0;j<s2.length();j++){
                if(s1.charAt(k)!=' '&&s1.charAt(k)==s2.charAt(j)){
                    set.add(""+s1.charAt(k));
                }
            }
        }
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.print( it.next());
        }
    }    static void c1(final int l) {
        //生成数组
        if (l < 1) {
            return ;
        }
        int[][] t = new int[l][l];
        for (int j = 0; j < l; j++) {
            for (int i = 0; i < l; i++) {
                t[j][i] = i > j ? j : i;
            }
        }        /////////打印
        int[] sm = new int[t[0].length];
        //计算对齐
        for (int j = t.length - 1; j > -1; j--) {
            for (int i = t[j].length - 1; i > -1; i--) {
                if (t[j][i] < 0) {
                    continue;
                }
                if (String.valueOf(t[j][i]).length() > sm[i]) {
                    sm[i] = String.valueOf(t[j][i]).length();
                }
            }
        }
        for (int j = 0; j < t.length; j++) {
            for (int i = 0; i < t[j].length; i++) {
                System.out.print(t[j][i]);
                for (int k = 0; k < sm[i] - String.valueOf(t[j][i]).length() + 2; k++) {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }    static void c2(final int l) {
        //生成数组
        if (l < 1) {
            return;
        }
        int[][] t = new int[l][l * 2 - 1];
        for (int j = 0; j < l; j++) {
            for (int i = 0; i < l; i++) {
                t[j][l - 1 - i] = j - i + 1;
                t[j][l - 1 + i] = j - i + 1;
            }
        }        ////打印
        int[] sm = new int[t[0].length];
        //计算对齐
        for (int j = t.length - 1; j > -1; j--) {
            for (int i = t[j].length - 1; i > -1; i--) {
                if (t[j][i] <= 0) {
                    continue;
                }
                if (String.valueOf(t[j][i]).length() > sm[i]) {
                    sm[i] = String.valueOf(t[j][i]).length();
                }
            }
        }
        for (int j = 0; j < t.length; j++) {
            for (int i = 0; i < t[j].length; i++) {
                if (t[j][i] > 0) {
                    System.out.print(t[j][i]);
                    for (int k = 0; k < sm[i] - String.valueOf(t[j][i]).length() + 2; k++) {
                        System.out.print(" ");
                    }
                } else {
                    for (int k = 0; k < sm[i] + 2; k++) {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}/*
run：
0  0  0  0  0  0  0  0  0  0  0   
0  1  1  1  1  1  1  1  1  1  1   
0  1  2  2  2  2  2  2  2  2  2   
0  1  2  3  3  3  3  3  3  3  3   
0  1  2  3  4  4  4  4  4  4  4   
0  1  2  3  4  5  5  5  5  5  5   
0  1  2  3  4  5  6  6  6  6  6   
0  1  2  3  4  5  6  7  7  7  7   
0  1  2  3  4  5  6  7  8  8  8   
0  1  2  3  4  5  6  7  8  9  9   
0  1  2  3  4  5  6  7  8  9  10                                 1                                  
                           1   2   1                              
                        1  2   3   2   1                          
                     1  2  3   4   3   2  1                       
                  1  2  3  4   5   4   3  2  1                    
               1  2  3  4  5   6   5   4  3  2  1                 
            1  2  3  4  5  6   7   6   5  4  3  2  1              
         1  2  3  4  5  6  7   8   7   6  5  4  3  2  1           
      1  2  3  4  5  6  7  8   9   8   7  6  5  4  3  2  1        
   1  2  3  4  5  6  7  8  9   10  9   8  7  6  5  4  3  2  1     
1  2  3  4  5  6  7  8  9  10  11  10  9  8  7  6  5  4  3  2  1  
ecomh成功生成（总时间：2 秒）
*/
[java]

Answer 10

/**
* 数组呀数组
*/
public class Main {    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        ///////1-1
        c1(11);
        System.out.println("");
        /////1-2
        c2(11);        ///2
        String s1="welcome to Zhuhai",s2="come here";
        java.util.HashSet set = new java.util.HashSet();
        for(int k=0;k<s1.length();k++){
            for(int j=0;j<s2.length();j++){
                if(s1.charAt(k)!=' '&&s1.charAt(k)==s2.charAt(j)){
                    set.add(""+s1.charAt(k));
                }
            }
        }
        Iterator it = set.iterator();
        while(it.hasNext()){
            System.out.print( it.next());
        }
    }    static void c1(final int l) {
        //生成数组
        if (l < 1) {
            return ;
        }
        int[][] t = new int[l][l];
        for (int j = 0; j < l; j++) {
            for (int i = 0; i < l; i++) {
                t[j][i] = i > j ? j : i;
            }
        }        /////////打印
        int[] sm = new int[t[0].length];
        //计算对齐
        for (int j = t.length - 1; j > -1; j--) {
            for (int i = t[j].length - 1; i > -1; i--) {
                if (t[j][i] < 0) {
                    continue;
                }
                if (String.valueOf(t[j][i]).length() > sm[i]) {
                    sm[i] = String.valueOf(t[j][i]).length();
                }
            }
        }
        for (int j = 0; j < t.length; j++) {
            for (int i = 0; i < t[j].length; i++) {
                System.out.print(t[j][i]);
                for (int k = 0; k < sm[i] - String.valueOf(t[j][i]).length() + 2; k++) {
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }    static void c2(final int l) {
        //生成数组
        if (l < 1) {
            return;
        }
        int[][] t = new int[l][l * 2 - 1];
        for (int j = 0; j < l; j++) {
            for (int i = 0; i < l; i++) {
                t[j][l - 1 - i] = j - i + 1;
                t[j][l - 1 + i] = j - i + 1;
            }
        }        ////打印
        int[] sm = new int[t[0].length];
        //计算对齐
        for (int j = t.length - 1; j > -1; j--) {
            for (int i = t[j].length - 1; i > -1; i--) {
                if (t[j][i] <= 0) {
                    continue;
                }
                if (String.valueOf(t[j][i]).length() > sm[i]) {
                    sm[i] = String.valueOf(t[j][i]).length();
                }
            }
        }
        for (int j = 0; j < t.length; j++) {
            for (int i = 0; i < t[j].length; i++) {
                if (t[j][i] > 0) {
                    System.out.print(t[j][i]);
                    for (int k = 0; k < sm[i] - String.valueOf(t[j][i]).length() + 2; k++) {
                        System.out.print(" ");
                    }
                } else {
                    for (int k = 0; k < sm[i] + 2; k++) {
                        System.out.print(" ");
                    }
                }
            }
            System.out.println();
        }
    }
}
/*run：
0  0  0  0  0  0  0  0  0  0  0   
0  1  1  1  1  1  1  1  1  1  1   
0  1  2  2  2  2  2  2  2  2  2   
0  1  2  3  3  3  3  3  3  3  3   
0  1  2  3  4  4  4  4  4  4  4   
0  1  2  3  4  5  5  5  5  5  5   
0  1  2  3  4  5  6  6  6  6  6   
0  1  2  3  4  5  6  7  7  7  7   
0  1  2  3  4  5  6  7  8  8  8   
0  1  2  3  4  5  6  7  8  9  9   
0  1  2  3  4  5  6  7  8  9  10                                 1                                  
                           1   2   1                              
                        1  2   3   2   1                          
                     1  2  3   4   3   2  1                       
                  1  2  3  4   5   4   3  2  1                    
               1  2  3  4  5   6   5   4  3  2  1                 
            1  2  3  4  5  6   7   6   5  4  3  2  1              
         1  2  3  4  5  6  7   8   7   6  5  4  3  2  1           
      1  2  3  4  5  6  7  8   9   8   7  6  5  4  3  2  1        
   1  2  3  4  5  6  7  8  9   10  9   8  7  6  5  4  3  2  1     
1  2  3  4  5  6  7  8  9  10  11  10  9  8  7  6  5  4  3  2  1  
ecomh成功生成（总时间：2 秒）*/

Answer 11

对于第一题的第二问二楼的赋值算法不错，但是只给三角形赋值了，其余没被赋值的数组里面的项被默认赋值为0，没有达到输出三角形的效果。其实这个问题不用数组也可以搞定的了，用几个循环就行了。代码如下：
public class Printsjx{
             
public static void main(String [ ] args){
                        int i,j,n,k,l;
              System.out.println("请输入您所需的图形的行数:"+args[0]);
             n=Integer.parseInt(args[0]);
             for(i=1;i<=n;i++)
               {
                  for(j=1;j<=n-i;j++)
                  {
                      System.out.print("  ");
                     }
                  for(j=1;j<=i;j++)
                  {
                      System.out.print(j+" ");
                     }
                  for(k=i+1;k<=2*i-1;k++)
                  {
                        l=2*i-k;
                      System.out.print(l+" ");
                     }
              
                  
                      System.out.print(" \n");
  }  
 }
}
          不知是否满意？

Answer 12

其实我也是个Java菜鸟，希望共同进步吧。我再对上面的补充一下，引用二楼的赋值算法，用二维数组输出三角形：
class Print{
 public static void main(String args[]){
  int i,j,k,n;
  System.out.println("请输入你需要输出地行数："+args[0]);
  n=Integer.parseInt(args[0]);
  int b[][]=new int [n][2*n-1];
  for(i=n-1;i>=0;i--)
   for(j=n-1;j>=n-1-i;j--)
    b[i][j]=b[i][2*n-j-2]=j+i-n+2;
  for(i=0;i<n;i++){
   for(j=0;j<n-i-1;j++)
    System.out.print(" ");
   for(k=j;k<n+i;k++)
    System.out.print(b[i][k]);
   System.out.print("\n");
  }
 }
}
只限于10行以内的，超过10行就变形了，呵呵

Answer 13

java codeclass ErweiShuzu {
  public static void main(String[] args) {
    //第一个图形
    int[][] num = new  int[4][4];  //构造4*4列二维数组
    //下面用于初始化,数组循环一般用for循环
    for(int i = 0; i < num.length; i++) {
      for(int j = 0; j < num[0].length; j++) {
        //
        num[i][j] = (i<j)?i:j;
      }
    }
    //打印之;
    for(int i = 0; i < num.length; i++) {
      for(int j = 0; j < num[0].length; j++) {
        System.out.print(num[i][j] + " ");
      }
      System.out.println();
    }    //下面打印第二个图形,为避免重声明变量,将数组名命为num0;
    int[][] num0 = new int[4][];
    //下面是初始化,注意不要将所有数字全放入数组,只要前半截
    for(int i = 0; i < num0.length; i++) {
      num0[i] = new int[i + 1];    
      //如第n行只要(1,2,……,n),即(i + 1)个数      for(int j = 0; j < num0[i].length; j++) {
        num0[i][j] = j + 1;   //初始化值
      }
    }
    
    //打印之
    for(int i = 0; i < num0.length; i++) {
      //打印开头空格,有(num0.length - num0[i].length)个
      for(int j = 0; j < num0.length - num0[i].length; j++)
        System.out.print("  ");
      //打印数组中的数
      for(int j = 0; j < num0[i].length; j++)
        System.out.print(num0[i][j] + " ");
      //倒序打印数组,注意从倒数第二个开始
      for(int j = num0[i].length - 2; j >= 0; j--)
        System.out.print(num0[i][j] + " ");
      System.out.println();    //换行
    }
  }
}
Java code;
关于打印图形,一般用不上数组,记住数组是用来存储数据的,如果用不着存储数据,那也没必要非用数组了.对于第二个问题,涉及到了动态数组的概念(事实上数组创建,大小不能改变),也就是一个可以大小改变的数组,你需要自己写一个类,来处理可变的数组.以后也用得着.其基本算法为:
   1.创建动态数组的概念;
   2.以其中一个为参照,将另一个与之比较,如果出现新的匹配,就向动态数组添加新元素,并初始为零;如果是已有的匹配,动态数组相应值++;
   3.处理动态数组的概念. 

Answer 14

补充一下,刚才看了你的要求,由于不需要统计相同字符出现的次数,故可用下面代码:for(int i = 0; i < s1.length(); i++) {
  for(int j = 0; j < s2.length(); j++) {
    if(s1.charAt(i) == charAt(j))
      System.out.print(s1.charAt(i));
    }
  }
}这个代码的问题在于如果多次匹配,就会多次打印,例如s1和s2中有相同的三个e ,就会打印3次.如果要限制此情况,就要定义一个数组,这个数组也是动态的.

Answer 15

import java.util.Arrays;public class StrCmp {
public static void main(String[] args) {
String str1 = "Welcome to WestLake";
String str2 = "I Have Been To West Lake";
stringCompare(str1, str2);
}

public static void stringCompare(String str1, String str2) {
System.out.println(str1);
System.out.println(str2);
char[] c1 = str1.toCharArray();
char[] c2 = str2.toCharArray();
int c1Length = c1.length;
int c2Length = c2.length;
Arrays.sort(c1);
Arrays.sort(c2);
System.out.println(Arrays.toString(c1));
System.out.println(Arrays.toString(c2));
System.out.print("Result:");
for(int i=0, j=0; i<c1Length && j<c2Length;) {
if(c1[i] == c2[j]) {
System.out.print("\t'" + c1[i] + "'");
}

while(i < c1.length-1 && c1[i] == c1[i+1]) {
i++;
}
while(j < c2.length-1 && c2[j] == c2[j+1]) {
j++;
}

if(c1[i] < c2[j]) {
i++;
}else {
j++;
}
}
}
}
/*Result:
Welcome to WestLake
I Have Been To West Lake
[ ,  , L, W, W, a, c, e, e, e, e, k, l, m, o, o, s, t, t]
[ ,  ,  ,  ,  , B, H, I, L, T, W, a, a, e, e, e, e, e, k, n, o, s, t, v]
Result: ' ' 'L' 'W' 'a' 'e' 'k' 'o' 's' 't'*/

Answer 16

public class TrianglePrint {
public static final int N = 20;
public static void main(String[] args) {
int[][] a = new int[N][];
triangleArray(a);
for(int i=0; i<a.length; i++) {
for(int j=0; j<a[i].length; j++) {
System.out.print((0 == a[i][j] ? " " : a[i][j]) + "\t");
}
System.out.println();
}
}

public static void triangleArray(int[][] a) {
for(int i=0; i<a.length; i++) {
a[i] = new int[N+i];
a[i][N-1] = i+1;
for(int j=1; j<i+1; j++) {
a[i][N-1-j] = a[i][N-1]-j;
a[i][N-1+j] = a[i][N-1]-j;
}
}
}
}
/*(三角形数组)
                  1
                1 2 1
              1 2 3 2 1
            1 2 3 4 3 2 1
          1 2 3 4 5 4 3 2 1
        1 2 3 4 5 6 5 4 3 2 1
      1 2 3 4 5 6 7 6 5 4 3 2 1
    1 2 3 4 5 6 7 8 7 6 5 4 3 2 1
  1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1
1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1
*/