(B卷,100分)- 分苹果（Java & JS & Python & C）HUAWEI OD

(B卷,100分)- 分苹果（Java & JS & Python & C）

题目描述

A、B两个人把苹果分为两堆，A希望按照他的计算规则等分苹果，他的计算规则是按照二进制加法计算，并且不计算进位 12+5=9（1100 + 0101 = 9），B的计算规则是十进制加法，包括正常进位，B希望在满足A的情况下获取苹果重量最多。

输入苹果的数量和每个苹果重量，输出满足A的情况下B获取的苹果总重量。

如果无法满足A的要求，输出-1。

数据范围

1 <= 总苹果数量 <= 20000

1 <= 每个苹果重量 <= 10000

输入描述

输入第一行是苹果数量：3

输入第二行是每个苹果重量：3 5 6

输出描述

输出第一行是B获取的苹果总重量：11

用例

输入	3 3 5 6
输出	11
说明	无

输入	8 7258 6579 2602 6716 3050 3564 5396 1773
输出	35165
说明	无

题目解析

JavaScript算法源码

/* JavaScript Node ACM模式 控制台输入获取 */
const readline = require("readline");

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout,
});

const lines = [];
rl.on("line", (line) => {
  lines.push(line);

  if (lines.length === 2) {
    const n = parseInt(lines[0]);
    const arr = lines[1].split(" ").map(Number);

    console.log(getResult(n, arr));

    lines.length = 0;
  }
});

function getResult(n, arr) {
  const min = arr.sort((a, b) => a - b).shift();

  let fault, correct;
  fault = correct = min;

  for (let w of arr) {
    fault ^= w;
    correct += w;
  }

  if (fault === 0) {
    return correct - min;
  } else {
    return -1;
  }
}

Java算法源码

import java.util.Arrays;
import java.util.Scanner;

public class Main {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();
    int[] arr = new int[n];
    for (int i = 0; i < n; i++) {
      arr[i] = sc.nextInt();
    }

    System.out.println(getResult(n, arr));
  }

  public static int getResult(int n, int[] arr) {
    Arrays.sort(arr);

    int min = arr[0];
    int fault = min, correct = min;

    for (int i = 1; i < arr.length; i++) {
      int w = arr[i];
      fault ^= w;
      correct += w;
    }

    if (fault == 0) {
      return correct - min;
    } else {
      return -1;
    }
  }
}

Python算法源码

# 输入获取
n = int(input())
arr = list(map(int, input().split()))


# 算法入口
def getResult():
    arr.sort()
    fault = correct = minV = arr[0]

    for i in range(1, len(arr)):
        w = arr[i]
        fault ^= w
        correct += w

    if fault == 0:
        return correct - minV
    else:
        return -1


# 算法调用
print(getResult())

C算法源码

#include <stdio.h>
#include <stdlib.h>

void getResult(int n, int weights[]);

int main() {
    int n;
    scanf("%d", &n);

    int nums[n];
    for(int i=0; i<n; i++) {
        scanf("%d", &nums[i]);
    }

    getResult(n, nums);

    return 0;
}

int cmp(const void* a, const void* b) {
    return (*(int*) a) - (*(int*) b);
}

void getResult(int n, int nums[]) {
    qsort(nums, n, sizeof(int), cmp);

    int min = nums[0];

    int correctSum = min;
    int faultSum = min;

    for(int i=1; i<n; i++) {
        correctSum += nums[i];
        faultSum ^= nums[i];
    }

    if(faultSum == 0) {
        printf("%d\n", correctSum - min);
    } else {
        puts("-1");
    }
}