编程题1

package Test;

import java.util.HashSet;



public class Test1 {

    public static void main(String[] args) {

        Test1 test=new Test1();
        System.out.println("==checkSam==");
        String stringA="Here you are";
        String stringB="Are you here";
        System.out.println(test.checkSam(stringA, stringB));

        System.out.println("****************************************");
        System.out.println("==replaceSpace==");
        stringA="Mr John Smith";
        System.out.println(test.replaceSpace(stringA, stringA.length()));

        System.out.println("****************************************");
        System.out.println("==zipString==");
        stringA="welcometonowcoderrrrr";
        System.out.println(test.zipString(stringA));

        System.out.println("****************************************");
        System.out.println("==transformImage==");
        int[][] a={{1,2,3},{4,5,6},{7,8,9}};
        System.out.println("before------------------");
        for (int i = 0; i < a.length; i++) {
             for (int j = 0; j < a[i].length; j++) {     
                 System.out.print(a[i][j]);
             }  
             System.out.println();       
        }
        System.out.println("after------------------");
        a=test.transformImage(a, a[0].length);
        for (int i = 0; i < a.length; i++) {
             for (int j = 0; j < a[i].length; j++) {     
                 System.out.print(a[i][j]);
             }  
             System.out.println();       
        }



        System.out.println("****************************************");
        System.out.println("==clearZero==");
        int[][] clearZero={{1,2,3},{0,1,2},{0,0,1}};
        System.out.println("before------------------");
        for (int i = 0; i < clearZero.length; i++) {
             for (int j = 0; j < clearZero[i].length; j++) {     
                 System.out.print(clearZero[i][j]);
             }  
             System.out.println();       
        }
        System.out.println("after------------------");
        clearZero=test.clearZero(clearZero, clearZero[0].length);
        for (int i = 0; i < clearZero.length; i++) {
             for (int j = 0; j < clearZero[i].length; j++) {     
                 System.out.print(clearZero[i][j]);
             }  
             System.out.println();       
        }

        System.out.println("****************************************");
        System.out.println("==checkReverseEqual==");
        System.out.println(test.checkReverseEqual("ABCD","DABC"));

    }

    /*
     * 给定两个字符串，请编写程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。这里规定大小写为不同字符，且考虑字符串重点空格。
    给定一个string stringA和一个string stringB，请返回一个bool，代表两串是否重新排列后可相同。保证两串的长度都小于等于5000。
    测试样例：
    "This is nowcoder","is This nowcoder"
    返回：true
    "Here you are","Are you here"
    返回：false
     */

    public boolean checkSam(String stringA, String stringB) {
        // write code here
        if(stringA.length()!=stringB.length())
            return false;
        int len=stringA.length();
        int[] com=new int[999];
        for (int i = 0; i < len; i++) {
            com[stringA.charAt(i)]++;
        }
        for (int i = 0; i < len; i++) {
            if(--com[stringB.charAt(i)]<0)
                return false;
        }
        return true;
    }

    /*
     * 请编写一个方法，将字符串中的空格全部替换为“%20”。假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由大小写的英文字母组成。
        给定一个string iniString 为原始的串，以及串的长度 int len, 返回替换后的string。
        测试样例：
        "Mr John Smith”,13
        返回："Mr%20John%20Smith"
        ”Hello  World”,12
        返回：”Hello%20%20World”
     */
    public String replaceSpace(String iniString, int length) {
        // write code here
        return iniString.replaceAll(" ", "%20");
    }

    /*
     * 利用字符重复出现的次数，编写一个方法，实现基本的字符串压缩功能。比如，字符串“aabcccccaaa”经压缩会变成“a2b1c5a3”。若压缩后的字符串没有变短，则返回原先的字符串。
给定一个string iniString为待压缩的串(长度小于等于3000)，保证串内字符均由大小写英文字母组成，返回一个string，为所求的压缩后或未变化的串。
测试样例
"aabcccccaaa"
返回："a2b1c5a3"
"welcometonowcoderrrrr"
返回："welcometonowcoderrrrr"
     */
    public String zipString(String iniString) {
        // write code here
        StringBuffer sb=new StringBuffer();
        int i=0;
        for (; i < iniString.length(); ) {
            sb.append(iniString.charAt(i));
            int k=1;
            int j=i+1;
            for (; j < iniString.length(); j++) {
                if(iniString.charAt(i)==iniString.charAt(j)){
                    k++;
                }else{
                    break;
                }
            }
            sb.append(k);
            i=j;
        }
        return sb.length()<iniString.length()?sb.toString():iniString;      
        /*方法二
         *  StringBuilder build = new StringBuilder();
        char pre = iniString.charAt(0);
        int count = 1;
        for (int i = 1; i < iniString.length(); ++i) {
            if (pre == iniString.charAt(i)) {
                count++;
                continue;
            } else {
                build.append(pre);
                pre = iniString.charAt(i);
            }
            build.append(count);
            count = 1;
        }
        if (count > 1)
            build.append(pre).append(count);
        return build.toString().length() >= iniString.length() ? iniString : build.toString();
         */
    }
    /*
     * 有一副由NxN矩阵表示的图像，这里每个像素用一个int表示，请编写一个算法，在不占用额外内存空间的情况下(即不使用缓存矩阵)，将图像顺时针旋转90度。
给定一个NxN的矩阵，和矩阵的阶数N,请返回旋转后的NxN矩阵,保证N小于等于500，图像元素小于等于256。
测试样例：
[[1,2,3],[4,5,6],[7,8,9]],3
返回：[[7,4,1],[8,5,2],[9,6,3]]
     */
     public int[][] transformImage(int[][] mat, int n) {
            // write code here
        //对角线上 兑换
         for (int i = 0; i < n; i++) {
            for (int j =i+1; j <n; j++) {
                mat[i][j]=mat[i][j]^mat[j][i];
                mat[j][i]=mat[i][j]^mat[j][i];
                mat[i][j]=mat[i][j]^mat[j][i];
            }
        }
         //竖对折
         for (int i = 0; i < n; i++) {
                for (int j = 0; j <n/2; j++) {
                    mat[i][j]=mat[i][j]^mat[i][n-j-1];
                    mat[i][n-j-1]=mat[i][j]^mat[i][n-j-1];
                    mat[i][j]=mat[i][j]^mat[i][n-j-1];
                }
         }
        return mat;
     }


     /*
      * 
请编写一个算法，若MxN矩阵中某个元素为0，则将其所在的行与列清零。
给定一个MxN的int[][]矩阵(C++中为vector>)mat和矩阵的阶数n，请返回完成操作后的int[][]矩阵(C++中为vector>)，保证n小于等于300，矩阵中的元素为int范围内。
测试样例：
[[1,2,3],[0,1,2],[0,0,1]]
返回：[[0,0,3],[0,0,0],[0,0,0]]
      */

     public int[][] clearZero(int[][] mat, int n) {
            // write code here
        // int[][] result=mat;  这里是地址传值， 即result改变还是mat改变 都会影响数据
         //方法一
        /* int[] x=new int[n];
         int[] y=new int[n];
         for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if(mat[i][j]==0){
                    x[i]=1;
                    y[j]=1;
                }
            }
        }
         for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    if(x[i]==1||y[j]==1){
                        mat[i][j]=0;
                    }
                }
         }
         return mat;   */

         //方法二
            HashSet x = new HashSet();
            HashSet y = new HashSet();
            for (int i=0; i<n; i++)
                for (int j=0; j<n; j++)
                {
                    if (mat[i][j] == 0) {
                        x.add(i);
                        y.add(j);
                    }
                }
            for (int i=0; i<n; i++) {
                for (int j=0; j<n; j++) {
                    if (x.contains(i) || y.contains(j))
                        mat[i][j] = 0;
                }
            }
            return mat;

        }

/*
 * 假定我们都知道非常高效的算法来检查一个单词是否为其他字符串的子串。请将这个算法编写成一个函数，给定两个字符串s1和s2，请编写代码检查s2是否为s1旋转而成，要求只能调用一次检查子串的函数。
给定两个字符串s1,s2,请返回bool值代表s2是否由s1旋转而成。字符串中字符为英文字母和空格，区分大小写，字符串长度小于等于1000。
测试样例：
"Hello world","worldhello "
返回：false
"waterbottle","erbottlewat"
返回：true
解析 ABCD  BCDA CDAB DABC
  ABCD ABCDA ABCDAB ABCDABC
 */
     public boolean checkReverseEqual(String s1, String s2) {
            // write code here
         s1=s1+s1;
         if(s1.contains(s2)){
             return true;
         }else{
             return false;
         }
        }
}