混拼 核心计算方法

python

def bubbleSort(arr):
    """
    冒泡排序
    :param arr:
    :return:
    """
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j][0] > arr[j + 1][0]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr


def calculateByNumbersAndSpell(arr, spell):
    """
    获取最不浪费 但不一定合理的 个数
    :param arr:
    :param spell:
    :return:
    """

    import math
    sum_numbers = sum(arr)
    average_number = sum_numbers / spell
    arr_result_1 = [i / average_number for i in arr]
    arr_result_2 = [(int(math.ceil(arr[index] / int(i))), int(i), index, arr[index]) for index, i in enumerate(arr_result_1)]
    arr_result_3 = [(int(math.ceil(arr[index] / int(i + 1))), int(i + 1), index, arr[index]) for index, i in
                    enumerate(arr_result_1)]
    print(arr_result_2)
    print(arr_result_3)
    arr_result_2 = bubbleSort(arr_result_2)
    sum_1 = 0
    for item in arr_result_3:
        sum_1 += item[1]
    arr_result_2 = arr_result_2[0:sum_1 - spell]
    for item in arr_result_2:
        number, count, index, n = item
        arr_result_3[index] = item
    max_number = arr_result_3[0][0]
    for item in arr_result_3[1:]:
        number, count, index, n = item
        max_number = number if max_number < number else max_number

    return max_number, arr_result_3

arr_input = [1000, 1000, 1000]
spell = 33
max_number,arr = calculateByNumbersAndSpell(arr_input, spell)

print("输入数量")
print(arr_input)
print("拼数:%d" % spell)
print("----------最不浪费的拼法如下------")
for item in arr:
    print('%d放%d个,至少印%d' %(item[3],item[1],item[0]))

print("大张数:%d" % max_number)

java

 public static void main(String[] args) {

        calculateByNumbersAndSpell(Arrays.asList(3500, 3230, 5070, 11250, 13000), 7, 8);

    }

     public static Map<String, Object> calculateByNumbersAndSpell(List<Integer> arr, int col, int row) {
        int spell = col * row;

        //累加求和
        int sum_numbers = arr.stream().mapToInt(item -> item).sum();
        //平均数
        float average_number = (sum_numbers+0.0f) / spell;

        List<Integer> arr_result_1 = new ArrayList<>();
        arr.stream().forEach(item -> arr_result_1.add((int)(item / average_number)));
        List<List<Integer>> arr_result_2 = new ArrayList<>();
        for (int i = 0; i < arr_result_1.size(); i++) {
            List<Integer> list_1 = new ArrayList<>();

            int temp = (int) Math.ceil((0.0f+arr.get(i)) / arr_result_1.get(i));
            if(temp==0){
                list_1.add(1);
            }else{
                list_1.add(temp);
            }

            list_1.add(arr_result_1.get(i));
            list_1.add(i);
            list_1.add(arr.get(i));
            arr_result_2.add(list_1);
        }
        List<List<Integer>> arr_result_3 = new ArrayList<>();
        for (int i = 0; i < arr_result_1.size(); i++) {
            List<Integer> list_2 = new ArrayList<>();
            int temp = (int) Math.ceil((0.0f+arr.get(i)) / (1 + arr_result_1.get(i)));
            if(temp==0){
                list_2.add(1);
            }else{
                list_2.add(temp);
            }


            list_2.add(arr_result_1.get(i) + 1);
            list_2.add(i);
            list_2.add(arr.get(i));
            arr_result_3.add(list_2);
        }
        bubbleSort(arr_result_2);
        int sum_1 = arr_result_3.stream().mapToInt(item -> item.get(1)).sum();

        arr_result_2 = arr_result_2.subList(0, sum_1 - spell);
        for (List<Integer> list : arr_result_2) {
            arr_result_3.set(list.get(2), list);
        }
        int max_number = arr_result_3.get(0).get(0);
        for (int i = 1; i < arr_result_3.size(); i++) {
            max_number = max_number > arr_result_3.get(i).get(0) ? max_number : arr_result_3.get(i).get(0);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("max_number", max_number);
        System.out.println(arr_result_3);
        bubbleSort2(arr_result_3, row);
        map.put("arr", arr_result_3);
        return map;
    }

JavaScript

function bubbleSort(arr) {
    for (var i = 0; i < arr.length; i++) {
        for (var j = 0; j < arr.length - i - 1; j++) {
            if (arr[j][0] > arr[j + 1][0]){
                var temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
    return arr
}


function calculateByNumbersAndSpell(arr, spell) {
    var sum_numbers= 0;
    for (var i = 0; i < arr.length; i++)sum_numbers+=arr[i];
    var average_number = sum_numbers / spell;
    var arr_result_1 = new Array();
    for (var i = 0; i < arr.length; i++) {
        arr_result_1.push(arr[i]/average_number)
    }
    var arr_result_2 = new Array();
    for (var i = 0; i < arr_result_1.length; i++) {
        var temp_arr = new Array();
        temp_arr.push(parseInt(Math.ceil(arr[i]/parseInt(arr_result_1[i]+''))+''));
        temp_arr.push(parseInt(arr_result_1[i]+''));
        temp_arr.push(parseInt(i+''));
        temp_arr.push(parseInt(arr[i]+''));
        arr_result_2.push(temp_arr)
    }
    var arr_result_3 = new Array();
    for (var i = 0; i < arr_result_1.length; i++) {
        var temp_arr = new Array();
        temp_arr.push(parseInt(Math.ceil(arr[i]/parseInt((arr_result_1[i]+1)+''))+''));
        temp_arr.push(parseInt((arr_result_1[i]+1)+''));
        temp_arr.push(parseInt(i+''));
        temp_arr.push(parseInt(arr[i]+''));
        arr_result_3.push(temp_arr)
    }
    arr_result_2 = bubbleSort(arr_result_2)
    var sum_1 = 0
    for (var i = 0; i < arr_result_3.length; i++)sum_1+=arr_result_3[i][1]
    arr_result_2 = arr_result_2.slice(0,sum_1-spell)
    for (var i = 0; i < arr_result_2.length; i++) {
        arr_result_3[arr_result_2[i][2]] = arr_result_2[i]
    }
    var max_numer = arr_result_3[0][0];
    for (var i = 1; i < arr_result_3.length; i++) {
        max_numer = arr_result_3[i][0]>max_numer?arr_result_3[i][0]:max_numer
    }
    var map = {};
    map['max_number'] = max_numer;
    map['arr'] = arr_result_3;
    return map;
}
arr_input = [100, 100, 100]
spell = 33
map = calculateByNumbersAndSpell(arr_input,spell)
alert(map['max_number'])
alert(map['arr'])