話題の配列を「安全プランを証明」（牛オフ10.22）

テストサイト：トラバース、検索、ソート、時間とスペース効率、思考、ソートアルゴリズム

// Q01半順序2次元配列[検索]自然を十分に活用

（同一の各一次元アレイの長さ）は、上から下に増加する順に、二次元アレイの各列を並べ替えるために、昇順ソートの順に左から右に、各行。完全な機能、例えば、二次元アレイと整数を入力し、配列の整数が含まれているか否かが判断されます。

行列が部分的に注文したので、アップ番号、右のデジタル増分を減少させます。

1. 目標数値は、行だけの数よりも少ない先頭に表示されます
2. 横断i行、j列の対応する要素が目標より大きい場合、前行I-1、対象におけるj列のみ後で現れます。

したがって、左下隅から見て開始します。ターゲットデジタル時間シフトの左下隅より、数が左下隅、右よりも大きい場合に対象となります。
経路探索は、複雑さはO（+行数、列の数）であり、進められます。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int nrows = array.size();
        int ncols = array[0].size();
         
        int i = nrows - 1, j = 0;
         
        while(i >= 0 && j < ncols){
            if(array[i][j] == target) return true;
            else if(array[i][j]< target ){
                j++;
            }else i--;
        }
         
        return false;
    }
};

WA警告:

：決意条件が&&ミス（境界配列アクセス）を引き起こす、書かれたので、エラーコードは、以前のバージョンを以下の

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        int nrows = array.size();
        int ncols = array[0].size();
        if( ncols == 0 || nrows == 0) return false;
        for(int i = nrows - 1, j = 0; i >= 0, j < ncols; i--){
            if( array[i][j] == target )
                return true;
            if( array[i][j] < target){
                i++;
                j++;
            }
        }
          
        return false;
    }
};

// Q06 [暴力の】半アレイ内の最小要素を回転させる||

いくつかの要素の配列の先頭には、配列、我々は回転呼んで配列の最後に移動しました。
出力回転最小の素子アレイの回転の入力配列の非降順。
例えば、配列{3,4,5,1,2}、{1,2,3,4,5}は最小のアレイの回転です。
注：配列のサイズは0、リターン0である場合は、すべての要素は、0より大きいに記載されています。

回転による、非還元、非還元半部のアレイの前半分は、転換点から前方にトラバースは、最小の要素でなければなりません。全く転換点がない場合、すべての要素が等しいです。
。・
。・``

しかし、転機は半分を試すことができます。彼らはインターバルポイントの右端が最小の要素に当たるようにしようことを選んだので、ターニングポイントの右側にあるので、最小の要素です。その後：

1. array[mid] > array[high]
   この状況は、この場合、中間右の特定の最小数のアレイ[3,4,5,6,0,1,2]と同様です。
   低=ミッド+ 1
2. array[mid] == array[high]：
   この状況は、配列[1,0,1,1,1]または[1,1,1,0,1]、悪い中間の最小数は、左または右、この場合に決定し、持っていた工程と同様です狭い範囲。
   高い=高- 1
3. array[mid] < array[high]：
   この状況は、配列[2,2,3,4,5,6,6]、最小必ずしもアレイの数左側又は半ばに[中間]と同様です。右が必然的に増加しているので。
   高い=中旬

最後のセグメントの長さを考慮すると、上述した実施形態の場合の2又は3が最も小さい要素への収束の最終ローとハイポイントということであるであることに留意されたいです。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        if(rotateArray.size()==0)
            return 0;
        int lo =0, hi = rotateArray.size()-1,mid;
         
        while(lo< hi){
            mid = lo+((hi-lo)>>1);
            if(rotateArray[mid]>rotateArray[hi])
                lo=mid+1;
            else if (rotateArray[mid] == rotateArray[hi])
                hi-=1;
            else hi=mid;
        }
        return rotateArray[hi];
    }
};

Q13は、ODD前に、アレイの偶数次の調整します

アレイ内の数字の順序を調整する機能を実現するために、整数の配列を入力し、アレイの前半のすべての奇数部分は、すべての偶数アレイの第2の半分に位置し、奇数の間で比較的偶数、奇数を確保しさえするよう同じ位置。

方法1：その後、さえを追加し、最初の奇数追加、新しい配列を開きます。少しのコード。

方法2：追加メモリーの助けなし

/**
 * 1.要想保证原有次序，则只能顺次移动或相邻交换。
 * 2.i从左向右遍历，找到第一个偶数。
 * 3.j从i+1开始向后找，直到找到第一个奇数。
 * 4.将[i,...,j-1]的元素整体后移一位，最后将找到的奇数放入i位置，然后i++。
 * 5.終止條件：j向後遍歷查找失敗。
 */
public void reOrderArray2(int [] a) {
    if(a==null||a.length==0)
        return;
    int i = 0,j;
    while(i<a.length){
        while(i<a.length&&!isEven(a[i]))
            i++;
        j = i+1;
        while(j<a.length&&isEven(a[j]))
            j++;
        if(j<a.length){
            int tmp = a[j];
            for (int j2 = j-1; j2 >=i; j2--) {
                a[j2+1] = a[j2];
            }
            a[i++] = tmp;
        }else{// 查找失敗
            break;
        }
    }
}
boolean isEven(int n){
    if(n%2==0)
        return true;
    return false;
}

/ Q19時計プリント変数行列[使用]ボーダー

1 2 6 7 8 3 4 9 10. 5. 11：次の4×4行列を入力した場合、例えば、各番号に連続して印刷する時計回りの順に外側から内側に向かって順に、行列を入力
12 15 16 13 14が順次印刷されていますデジタル1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10。

/**
 A--------------------------------------------------------
 * 思路1：vis数组记录 - 简单但浪费空间
 * 思路2：用变量记录当前是第几圈 - 边界计算有点麻烦
 * 思路☆：用四个变量分别记录当前的四周边界，检查是否在边界内 && 边界是否满足条件
 T--------------------------------------------------------
 * 注意边界的检查（保证[在边界内 && 边界合法]） 
 */

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> ans = new ArrayList<>();

        if(matrix.length == 0 || matrix[0].length == 0)
            return ans;

        int nrow = matrix.length, ncol = matrix[0].length;
        int top=0,left=0,bottom=nrow-1,right=ncol-1;
        while (top<=bottom&&left<=right){
            // top: left -> right
            for(int i=left;i<=right;i++){
                ans.add(matrix[top][i]);
            }top++;
            // right: top -> bottom
            for(int i=top;i<=bottom&&left<=right;i++){//其实这里left<=right的判断多余，因为left和right的值都还没有变化
                ans.add(matrix[i][right]);
            }right--;
            // bottom: right -> left
            for(int i=right;i>=left&&top<=bottom;i--){
                ans.add(matrix[bottom][i]);
            }bottom--;
            // left: bottom -> top
            for(int i=bottom;i>=top&& left<=right;i--){
                ans.add(matrix[i][left]);
            }left++;
        }
        return ans;
    }
}

/ Q28は、配列を見つけるために数字の半分以上を発生します

この番号を見つけ、配列の半分以上の長さを表示される配列番号の数があります。例えば、入力アレイ9の長さは{1,2,3,2,2,2,5,4,2}。数2は5回、アレイ内のアレイの半分以上の長さ、出力2が表示されているので。0出力がある場合。

方法1：各番号が表示された回数をカウントにHashMap

/**
 * 用 HashMap 统计各个数字出现的次数
 * 注意 HashMap 的使用方法
 */

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class Solution {
    public int  MoreThanHalfNum_Solution(int [] array) {
        HashMap<Integer,Integer> map = new HashMap<>();

        for(int i=0;i<array.length;i++){
            if(!map.containsKey(array[i])){
                map.put(array[i],1);
            }else{
                int cnt = map.get(array[i]);
                map.put(array[i],++cnt);
            }
        }

        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()){
            Map.Entry entry = (Map.Entry)iter.next();
            Integer key = (Integer)entry.getKey();
            Integer val = (Integer)entry.getValue();
            if(val>array.length/2){
                return key;
            }
        }
        return 0;
    }
}

方法2：大K O（N）に基づいて、パーティションの検索

アレイは、（= N / 2）、デジタルソートされた配列（中央値）、次いで、O（n）のルックアップを利用する途中の特定の配列の後に、より多くの発生数の半分よりも大きいKアルゴリズムがある場合。

/**
 * 由于每次 partition 后，pivot 左边的值都较小，右边的值都较大，
 * 所以当 pivot 位置为 K 时，pivot 的值为第 K 大的值。
 * 不断对区间进行划分使得 pivot 位于 K, 然后检验它出现的次数是否大于一半。
 */

public class Solution {
    public int  MoreThanHalfNum_Solution(int [] array) {
        if(array == null||array.length ==0)
            return 0;
        int mid = array.length/2;
        int start = 0, end = array.length-1;
        int index = Partition(array,start,end); // 左闭右闭
        while(index!=mid){
            if(index > mid){
                index = Partition(array,start,index-1);
            }else{
                index = Partition(array,index+1,end);
            }
        }
        int result = array[index];

        if(check(array,result,mid))
            return result;

        return 0;
    }

    private int Partition(int[] arr, int start, int end) {
        int pivot = arr[start];
        int left = start, right = end;
        while (left < right) {
            // 因为pivot取的是最左边，所以要先从右边找
            while (left < right && arr[right] >= pivot) right--;
            arr[left] = arr[right];
            while (left < right && arr[left] <= pivot) left++;
            arr[right] = arr[left];
        }
        arr[left] = pivot;
        return left;// left 为最后枢值所在的位置
    }

    private boolean check(int[] arr, int result, int mid){
        int times=0;

        for (int anArr : arr) {
            if (anArr == result)
                times++;
        }
        if(times*2>arr.length)
            return true;
        return false;
    }
}

方法3：分析は、ペアごとの取り消しを横断

あなたは数、および回数を認定した場合には、他のすべての回表示される数字よりもさらに表示されます。
アイデアの本質は破壊的な異なる数のペアは、その後、予選番号が最後の桁に委ねなければならないということです。
2つの値の配列を横断するとき保存：1は数値配列、1つの数です。次の番号を横断するとき、場合には、以前と同じ図、プラス数1に記憶されているか、1だけデクリメントされ、番号が0の場合、次の番号が保存され、その数は1に設定されています。保存された数字を通過した後も望まれています。そして、それは条件をすることができ満たしているかどうかを判断します。

/ Maxと[DP、Math.max（）]連続サブアレイQ30

HZは時折、それらの非コンピュータ科学の学生を点滅するために、いくつかの専門的な問題を取得します。テストグループが今日終了します後、彼はアップ話し：旧一次元パターン認識では、ベクトルは正の整数、問題の解決策であるときに最大と連続サブベクトルを計算する必要があることが多いです。ベクターは、負の数が含まれている場合は、それを補うだろう横に正の数を負の数が含まれている、と期待できますか？例えば：{6、-3、-2,7、-15,1,2,2}、及び8の最大連続サブベクトル（第3まで、0から始まります）。その最大連続サブ配列にして返し、あなたは彼が住んでだまされてはいけないのだろうか？（サブベクトルの長さは、少なくとも1です）

/**
 * dp[i] 为以 array[i] 为末尾的最大子向量和
 * dp[i] = max(dp[i-1]+a[i], a[i])
 */

public class Solution {
    public int FindGreatestSumOfSubArray(int[] array) {
        if(array==null||array.length==0)
            return 0;

        int rst = array[0],dp = array[0];

        for(int i=1;i<array.length;i++){
            dp = Math.max(dp+array[i],array[i]);
            rst=Math.max(rst,dp);
        }

        return rst;
    }
}

/ Q32は、アレイの最小数に配置[Collections.sort（）、持つInteger.toString（int型のN）、stringBuilder.append（STR）]

正の整数のアレイ、一緒にスプライスされた番号に配置された全ての数字の配列を入力し、スプライスは、一つ最小すべての番号を印刷することができます。3,32,321入力アレイは} {例えば、3つの数の最小数は321323に配置することができる印刷します。

/**
 * 不是比较字典序！
 *
 * 先将整型数组转换成String数组，然后排序，最后将排好序的字符串数组拼接。
 * 关键就是制定排序规则:
 * 若ab > ba 则 a > b，
 * 若ab < ba 则 a < b，
 * 若ab = ba 则 a = b；
 * 解释说明：
 * 比如 "3" < "31"但是 "331" > "313"，所以要将二者拼接起来进行比较
 */

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        if(numbers==null||numbers.length==0)
            return "";
        ArrayList<String> arrayList = new ArrayList<>();
        for(int n:numbers)
            arrayList.add(Integer.toString(n));

        // 重定义 Collections.sort()的排序规则
        Collections.sort(arrayList, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                String s1=o1+o2;
                String s2=o2+o1;
                return s1.compareTo(s2); // 返回的值小于0则表示 s1<s2, s1 排在 s2 前
            }
        });


        StringBuilder rst=new StringBuilder();
        for(String s:arrayList){
            rst.append(s);
        }

        return rst.toString();
    }
}

簡潔には、一時的に理解していない、と書かれました。

public String PrintMinNumber(int [] numbers) {
        ArrayList<Integer> list = new ArrayList();
        Arrays.stream(numbers).forEach(list::add);
 
        list.sort((str1, str2) -> {
            String s1 = str1 + "" + str2;
            String s2 = str2 + "" + str1;
            return s1.compareTo(s2);
        });
 
        String s = "";
        for (int j : list) {
            s += j;
        }
 
        return s;
    }

Array.sort() to_string(int n)

逆の/// Q35アレイ

番号は図面の前後よりも大きい場合には、アレイ内の二つの数字は、2つの数字は逆対を形成します。配列を入力し、この配列P.逆ペアの総数を見出します P結果モジュロ十億七を出力します。すなわち、出力P％十億七

入力：

タイトル入力配列の範囲の同一のデジタルデータを確実ではない：データの50％、サイズは<= 10 ^ 4サイズ<= 2 * 10データ75％、サイズ<=データ10 ^ 5〜100％、のため^ 5

例：

逆対数1,2,3,4,5,6,7,0は7です。

方法1：逆統計の並べ替えをマージ

再帰マージソートプロセスは、2つのセクションに分かれて最初のセクションは、順序付けられた約2を取得し、次に左右のセクションでは、マージ。

約規則的間隔がセクション番号に逆の順序で計算することができるが、数は、合流部との間に逆方向であることができます。逆部屋の数の間隔=逆数は、順序および2つのサブインターバル+部分区間を逆転します。

O（N）補助空間マージによって必要とされます。

public class Solution {
    public int InversePairs(int[] array) {
        if (array == null || array.length == 0)
            return 0;
        int[] arr = array.clone();
        int[] copy = arr.clone();
        int MOD = 1000000007;
        long ans = MergeSort(arr, copy, 0, arr.length, MOD);// [ , )
        return (int) (ans % MOD);
    }

    private long MergeSort(int[] arr, int[] copy, int start, int end, int MOD) {// [ , )
        long count = 0;
        if (start + 1 < end) {
            int mid = (start + end) / 2;
            long a = MergeSort(arr, copy, start, mid, MOD);
            long b = MergeSort(arr, copy, mid, end, MOD);
            long c = Merge(arr, copy, start, mid, end, MOD);
            count = a + b + c;
        }
        return count % MOD;
    }

    private long Merge(int[] arr, int[] copy, int start, int mid, int end, int MOD) {
        long count = 0;
        
        System.arraycopy(arr, start, copy, start, end - start);
        int i = start, j = mid, k = start;
        while (i < mid && j < end) {
            if (copy[i] <= copy[j]) {
                arr[k++] = copy[i++];
            } else {
                count += (mid - i);
                arr[k++] = copy[j++];
            }
        }
        while (i < mid) arr[k++] = copy[i++];
        while (j < end) arr[k++] = copy[j++];

        return count % MOD;
    }
}

方法2：フェンウィックツリー

たぶん、あなたは書きませんでし離散を追加したいです。

逆の順序数を求めるのフェンウィックツリー原則として
、この問題の最初の明確なフェンウィックツリーメンテナンス情報が挿入フェンウィックツリーの順序に従って、元のソースデータに表示されてセクション番号の数で、最初のi桁がのために道を挿入します配列の最初のツリーa[i]のビットは、その親の更新間隔にカバーが、一方、1に設定されQuery(a[i])得ることができる[ 1, a[i]]部と、の代わりにだけ、その数に等しい未満のi番目の番号の前に、だけなので、それ自体に等しくてもよいですそれが未満ありQuery(a[i])-1、そのより明らかに大きいがあり、1をi-1-(Query(a[i])-1) = i-Query(a[i])2

for (int i = 1; i <= n; i++) {
    Update(i, 1);
    ans += i - Query(a[i]);
}

int lowbit(int x) {
    return x & (-x);
}
void Update(int pos, int val) {
    for (int i = pos; i <= n; i += lowbit(i)) {
        c[i] += val;
    }
}
int Query(int pos) {
    int ans = 0;
    for (int i = n; i > 0; i -= lowbit(i)) {
        ans += c[i];
    }
    return ans;
}

参考ます。https：//blog.csdn.net/Tc_To_Top/article/details/79562501

ソート配列に現れる数/ Q37番号[バイナリサーチ書き込ま分析、equal_range（）]

デフォルトは昇順です。

方法1：手書きバイナリ検索、およびK-K 0.5 + 0.5の検索

（注：エラー、この二分法が書かれたリターンを存在する配列の番号を見つけた場合）

/**
 * 由于是有序数组中查找，考虑二分；
 * 由于是整数，所以可以稍微变一下，搜索k-0.5和k+0.5
 * 两个位置相减，即为k出现的次数
 */
public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        if(array==null||array.length==0)
            return 0;
        return BiSearch(array, k+0.5) - BiSearch(array, k-0.5) ;
    }

    private int BiSearch(final int[] array,double x){
        // 返回第一个大于x的数的位置
        int left=0,right = array.length-1,mid;
        while(left<=right){
            mid= (right-left)/2+left;
            if(array[mid]<=x)// 如果需要的是第一个大于等于x的数的位置呢？
                left=mid+1;
            else
                right=mid-1;

        }
        return left;
    }
}

バイナリ考え分析書き込み：
最初の位置に戻ることに起因する最後で、Xより大きい数に等しいleft目標位置、初期範囲として指定された[0, array.length]（最後まで配列を見つけるノーリターンがないため）。ルックアップ・プロセス、場合
① a[mid] <x場合a[mid]、左目標、left = mid+1
② ターゲットの右、; ③ 、可能なターゲットは、ターゲットはまた、右の上にあってもよいです。最後に、とき間隔のみ2つの要素が、あればゴールと呼ばれる、左、または両者が一致の終わりを見つけるために、右。a[mid] >xa[mid]right = mid-1
a[mid]==xa[mid]right = mid
leftrightleft

二部概要

同時に、ミッド=左または左=が半ば+ 1または右=半ばまたは右=ミッド+文言1、議論を分割するために、原則的には割り当てが残って異なっていると、右の目標を確実にするしないを探してバイナリ検索タスク次いで、所与のループ終了条件が適切= <左、または右<放置された場合[左、右]間隔の最後、長さは2です。

//搜索k和k+1
public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        if(array==null||array.length==0)
            return 0;
        return BiSearch(array, k+1) - BiSearch(array, k) ;
    }

    private int BiSearch(final int[] array,int x){
        // 返回第一个大于等于x的数的位置
        int left=0,right = array.length,mid;
        //为了使得当元素在数组中不存在时返回正确 right != array.length-1
        while(left<right){
            mid= (right-left)/2+left;
            if(array[mid]<x)
                left=mid+1;
            else
                right=mid;
        }
        return left;
    }
}

方法2：C ++ STL equal_range（）

lower_bound(begin, end,val)第一の容器を返す以上のval要素の位置イテレータ。
upper_bound(begin, end, val)：最初の容器は返すよりも大きいval要素のイテレータの位置。
binary_search(begin, end, val)：要素が血管に等しい復帰はありますval。
equal_range(begin, end, val)：リターンlower_boundとupper_boundのペア。

class Solution {
public:
    int GetNumberOfK(vector<int> data ,int k) {
        auto resultPair = equal_range(data.begin(), data.end(),k);
        return resultPair.second - resultPair.first;
    }
};

// Q40見つける一度だけ2ビット・コンピューティングのデジタル[]配列

二つの数の整数型配列に加えて、他の数字が二回表示されます。これら二つの図が表示されるだけで検索するプログラムを作成してください。

私たちは、1つの番号が一度表示されますがある場合は、すべての要素XORの結果が数値であることを知っています。
この問題では、排他的論理和、排他的OR 2つの数の結果のすべての要素。明らかに、我々は2つの数のXORの結果から、元の数を導出することはできません。
アレイの数は2つのカテゴリに分類される、ビットのいずれかが0である排他的論理和ビットは、2ビットの差の一定数、バイナリ1である場合は、ビットは、クラス1であります、いくつかは、2つのカテゴリに二つの数字を探しています。カテゴリの数をそれぞれXORは、結果を得ます。

//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        if(array == null || array.length==1)
            return ;

        int xor = 0;
        for(int x:array){
            xor^=x;
        }

        if (xor == 0)
            return;

        int fisrtBit = (xor&(xor-1))^xor;// 结合上次学到的 n&(n-1) ，找到第一个为1 的bit ^. ^  ，或者 Xor&~(Xor - 1)
        
        num1[0]=num2[0]=0;
        for(int x:array){
            if((x&fisrtBit)!=0) num1[0]^=x;
            else num2[0]^=x;
        }
    }
}

開発：数の配列が一度だけ表示されますが、他の図は、この番号を見つけるために3回登場しています

32ビット・アレイのアプリケーションは、バイナリに番号のそれぞれの元の配列が1であり、展開して、[]ビット+1結局、各ビットが3の倍数か否かを判断する1それは、その後、我々は数字を見ているされている場合（または0）、これは確かにそうでない場合は1、ゼロであります

/**
     * 数组a中只有一个数出现一次，其他数字都出现了3次，找出这个数字
     * @param a
     * @return
     */
public static int find1From3(int[] a){
    int[] bits = new int[32];
    int len = a.length;
    for(int i = 0; i < len; i++){
        for(int j = 0; j < 32; j++){
            bits[j] = bits[j] + ( (a[i]>>>j) & 1);
        }
    }
    int res = 0;
    for(int i = 0; i < 32; i++){
        if(bits[i] % 3 !=0){
            res = res | (1 << i);
        }
    }
    return res;
}

/ Q50アレイ繰り返すデジタル補助記憶手段[しません]

アレイにおけるnの長さの全ての数は、n-1の範囲は0です。
一部のデジタル配列が重複しているが、重複しているどのように多くの番号がわかりません。各桁が数回繰り返されるか分からないのです。重複した数字のいずれかの配列を見つけてください。
例えば、もし入力アレイ7 {2,3,1,0,2,5,3}の長さは、第2の繰り返し桁の対応する出力。

番号がアクセスされた後、対応する値+ Nビットで提供することができる場合には、同じ番号の後に遭遇し、対応するビット数がn以上となっている見つけ、この数値を直接戻すことができます。

public class Solution {
    public boolean duplicate(int numbers[],int length,int [] duplication) {
        for( int i=0;i<length;i++){
            int val=numbers[i];
            if(val>=length) val-=length;
            if(numbers[val]>=length){
                duplication[0]=val;
                return true;
            }
            numbers[val]+=length;
        }
        
        return false;
    }
}

Q51建築物の配列

配列Aを与えられた[0,1、...、N- 1]、 配列B [0,1、...、N-構築してください 1]、 Bが要素B [I] = A [あり0] Aの[1] ... [-I。1] A [私は+ 1] ... [N - 1]。あなたは分裂を使用することはできません。

まず、再び逆方向に乗って、一緒に乗ります。

public class Solution {
    public int[] multiply(int[] A) {
        int[] B = new int[A.length];
        if (B.length != 0) B[0] = 1;
        for (int i = 1; i < B.length; i++) {
            B[i] = B[i - 1] * A[i - 1];
        }

        int temp = 1;
        for (int j = B.length - 2; j >= 0; j--) {
            temp *= A[j + 1];
            B[j] *= temp;
        }
        return B;
    }
}