龐果英雄會部分題目解答

1、數組排序

　　題目連接：http://hero.pongo.cn/Question/Details?ExamID=92&ID=94&bsh_bid=281776595

題目詳情：

　　給定一個包含1-n的數列，咱們經過交換任意兩個元素給數列從新排序。求最少須要多少次交換，能把數組排成按1-n遞增的順序，其中，數組長度不超過100。

　　例如：

　　原數組是3,2,1， 咱們只須要交換1和3就好了，交換次數爲1，因此輸出1。

　　原數組是2,3,1，咱們須要交換2和1，變成1,3,2，再交換3和2，變爲1，2，3，總共須要的交換次數爲2，因此輸出2。

　　分析：

　　經過示例能夠看出，能夠用數組的第一項跟最後一項比較，若是第一項比較大就換順序，而後拿第二項跟最後一項（這時最後一項已經變了）比較，以此類推。這樣最後一項就是最大的了，而後去掉最後一項再次執行這個過程。

　　JavaScript代碼以下：　　

function arrSortMincount(arr) {
    var comCount = 0,
        lastItem = 0;
    console.log("sort arr: [" + arr.join(",") + "]");
    if(arr.length == 1) {
        return 0;
    }
    for (var i = 0, j = arr.length; i < j; i++) {
        lastItem = arr[j - 1];
        if (lastItem < arr[i]) {
            console.log("change " + arr[i] + " and " + lastItem);
            arr[j - 1] = arr[i];
            arr[i] = lastItem;
            comCount++;
        }
    }
    if (arr.length > 1) {
        arr.pop();
    }
    return comCount + arrSortMincount(arr);
}

console.log(arrSortMincount([1,2,3]));
console.log(arrSortMincount([3,2,1]));
console.log(arrSortMincount([2,3,1]));
console.log(arrSortMincount([1,3,2]));
console.log(arrSortMincount([9,8,7,6,5,4,3,2,1,0]));

//日誌以下：
//sort arr: [1,2,3]
//sort arr: [1,2]
//sort arr: [1]
//0

//sort arr: [3,2,1]
//change 3 and 1
//sort arr: [1,2]
//sort arr: [1]
//1

//sort arr: [2,3,1]
//change 2 and 1
//change 3 and 2
//sort arr: [1,2]
//sort arr: [1]
//2

//sort arr: [1,3,2]
//change 3 and 2
//sort arr: [1,2]
//sort arr: [1]
//1

//sort arr: [9,8,7,6,5,4,3,2,1,0]
//change 9 and 0
//sort arr: [0,8,7,6,5,4,3,2,1]
//change 8 and 1
//sort arr: [0,1,7,6,5,4,3,2]
//change 7 and 2
//sort arr: [0,1,2,6,5,4,3]
//change 6 and 3
//sort arr: [0,1,2,3,5,4]
//change 5 and 4
//sort arr: [0,1,2,3,4]
//sort arr: [0,1,2,3]
//sort arr: [0,1,2]
//sort arr: [0,1]
//sort arr: [0]
//5

　　若有更好算法歡迎討論。

 

2、字符串消除

　　題目連接：http://hero.pongo.cn/Question/Details?ExamID=83&ID=85&bsh_bid=278004606

題目詳情：

定一個字符串，僅由a,b,c 3種小寫字母組成。當出現連續兩個不一樣的字母時，你能夠用另一個字母替換它，如

1. 有ab或ba連續出現，你把它們替換爲字母c；
2. 有ac或ca連續出現時，你能夠把它們替換爲字母b；
3. 有bc或cb 連續出現時，你能夠把它們替換爲字母a。

你能夠不斷反覆按照這個規則進行替換，你的目標是使得最終結果所獲得的字符串儘量短，求最終結果的最短長度。

輸入：字符串。長度不超過200，僅由abc三種小寫字母組成。

輸出： 按照上述規則不斷消除替換，所獲得的字符串最短的長度。

例如：輸入cab，輸出2。由於咱們能夠把它變爲bb或者變爲cc。

          輸入bcab，輸出1。儘管咱們能夠把它變爲aab -> ac -> b，也能夠把它變爲bbb，但由於前者長度更短，因此輸出1。

　　分析：

　　經過分析，能夠發現從字符串開始替換，而後判斷結果中是否還能夠替換，若是有再進行這個過程。

　　JavaScript代碼：

function getMinLength(str){
    console.log("Test: ", str);
    var m = new RegExp("ab|ac|bc|ba|ca|cb", "g");
    str = str.replace(m, function(s){
        var reg = new RegExp(s.split("").join("|"), "g"),
            changeTo = "abc".replace(reg, "");
        console.log("replace " + s + " to " + changeTo);
        return changeTo;
    });
    if (m.test(str)) {
        return getMinLength(str);
    } else {
        console.log("Result: ", str);
        return str.length;
    }
}

console.log(getMinLength("cab"));
console.log(getMinLength("bcab"));
console.log(getMinLength("abccbaabccba"));
/*
Test: cab
replace ca to b
Result: bb
2

Test: bcab
replace bc to a
replace ab to c
Test: ac
replace ac to b
Result: b
1

Test: abccbaabccba
replace ab to c
replace cb to a
replace ab to c
replace cb to a
Test: ccaaccaa
replace ca to b
replace ac to b
replace ca to b
Test: cbbba
replace cb to a
replace ba to c
Test: abc
replace ab to c
Result: cc
2
*/

　　若有更好算法歡迎討論。

 

3、倒水

　　題目連接：http://hero.pongo.cn/Question/Details?ID=70&ExamID=68

題目詳情：

有兩個容器，容積分別爲A升和B升，有無限多的水，如今須要C升水。

咱們還有一個足夠大的水缸，足夠容納C升水。起初它是空的，咱們只能往水缸裏倒入水，而不能倒出。

能夠進行的操做是：

1. 把一個容器灌滿；
2. 把一個容器清空（容器裏剩餘的水所有倒掉，或者倒入水缸）；
3. 用一個容器的水倒入另一個容器，直到倒出水的容器空或者倒入水的容器滿。

    問是否可以經過有限次操做，使得水缸最後剛好有C升水。

輸入：三個整數A, B, C，其中 0 < A , B, C <= 1000000000

輸出：0或1，表示可否達到要求。

　　分析：先求出由A升和B升能夠獲得幾升（小於A和B中較大值），結果爲一個數組，記爲D（從大到小排列），而後用C對D逐項求餘判斷是否爲0便可。

　　如A=10，B=7，則D = [10, 9, 7, 6, 3]

　　JavaScript代碼：

function can(a, b, c) {
    var allContainer = getAllContainers(a, b);
    console.log(allContainer);
    for(var i = 0, j = allContainer.length; i < j; i++) {
        c = c % allContainer[i];
        if (c == 0 ) {
            break;
        }
    }
    return  c == 0 ? 1 : 0;
}

function getAllContainers(a, b) {
    if (a == b) {
        return [a];
    } else {
        var min = Math.min(a, b),
            max = Math.max(a, b),
            result = [];
        a = max;
        b = min;
        while(max - min < a) {
            result.push(max - min);
            min = b - (max - min);
        }
        result.push(b, a);
        return result.sort(function(a, b){
            return b - a;
        });
    }
}

console.log(can(10,7,3));
console.log(can(9,3,121));
console.log(can(11,7,22));
/*
[10, 9, 7, 6, 3]
1

[9, 6, 3]
0

[11, 8, 7, 4]
1
*/

　　若有更好算法歡迎討論。