您好我的Google foobar问题需要帮助，这是我到目前为止所做的。
package com.google.challenges;
import java.math.BigInteger;
public class Answer{
public static String answer (int[] xs){
BigInteger result = new BigInteger("1");
int xsLen = xs.length, pos = 0;
int[] negatives = new int[xsLen];
if (xsLen == 1){
return Integer.toString(xs[0]);
}
// Split the input up into pos/negative. Pos get put onto the final value, as they don't need anything else.
// they are all useful. negative to onto seperate array and get sorted later
for (int n = 0;n < xsLen;n++){
int val = xs[n];
if (val == 0){
continue;
}
if (val > 0){
result = result.multiply(new BigInteger(Integer.toString(val)));
} else {
negatives[pos] = val;
pos++;
}
}
// even number of negatives means a full product will always be positive.
// odd number means that we discard the smallest number to maximise the result.
if ((pos % 2) == 0){
// even number, so add to result
for (int i = 0;i < pos;i++){
result = result.multiply(new BigInteger(Integer.toString(negatives[i])));
}
} else {
// sort then discard the minimum
int min = -1000; int mPos = -1;
for (int i = 0;i < pos;i++){
if(negatives[i] > min){
min = negatives[i];
mPos = i;
}
}
for (int j = 0;j < pos;j++){
if(j == mPos){
continue;
}
result = result.multiply(new BigInteger(Integer.toString(negatives[j])));
}
}
// done, return the string;
return result.toString();
}
}
这是问题，
您需要确定任何给定阵列中哪些面板可以离线修复，同时仍然保持每个阵列的最大功率输出量，并且要做到这一点，您首先需要弄清楚最大值实际上每个数组的输出。编写一个函数答案（xs），它取一个表示数组中每个面板的功率输出电平的整数列表，并返回这些数字的某些非空子集的最大乘积。因此，例如，如果一个数组包含功率输出电平为[2，-3,1,0，-5]的面板，则可以通过获取子集找到最大乘积：xs [0] = 2，xs [1 ] = -3，xs [4] = -5，得到乘积2 *（ - 3）*（ - 5）= 30.所以答案（[2，-3,1,0，-5]）将是“ 30" 。
每个太阳能电池板阵列包含至少1个且不超过50个电池板，每个电池板的功率输出电平绝对值不大于1000（某些电池板故障严重，导致能量消耗，但你知道面板的波形稳定器可以让你结合两个负输出面板来产生多个功率值的正输出。最终产品可能非常大，因此请将答案作为数字的字符串表示。
要提供Python解决方案，请编辑solution.py 要提供Java解决方案，请编辑solution.java
Inputs:
(int list) xs = [2, 0, 2, 2, 0]
Output:
(string) "8"
Inputs:
(int list) xs = [-2, -3, 4, -5]
Output:
(string) "60"
我已经参加了2天，并且非常喜欢这个答案，所以我可以了解我做错了什么并改进了！感谢阅读，希望你回答。 ：）
答案 0 :(得分：2)
你需要处理某些案件：
你的数组有1到50个整数元素，范围从-1000到1000.如果你的输入是这样的：[0,0，-43,0]。在那种情况下，
if (xsLen == 1){
return Integer.toString(xs[0]);
}
没有意义。 （你不能得到否定的答案）。在这种情况下，你的答案应为0。
解决这个问题的关键是要认识到你可以将两个负整数相乘以得到一个正整数。 BigInteger很有用，因为你的最终答案可能非常大。
我实现解决方案的方法是将每个非零整数相乘并将该值存储为BigInteger结果变量。但是，我保留了另一个变量来跟踪“最大的负整数”。最后将结果除以“最大负整数”变量，并得到答案。
我保留了正整数计数和负整数计数...希望这会有所帮助。
答案 1 :(得分：0)
你的代码很好但只需要做一个小的补充，这样如果数组中的所有元素都是零或负数，那么它应该返回0。 所以这是代码。
package com.google.challenges;
import java.math.BigInteger;
public class Answer {
public static String answer (int[] xs){
BigInteger result = new BigInteger("1");
int xsLen = xs.length, pos = 0,ng=0;
int[] negatives = new int[xsLen];
if (xsLen == 1){
return Integer.toString(xs[0]);
}
for (int n = 0;n < xsLen;n++){
int val = xs[n];
if (val == 0){
continue;
}
if (val > 0){
result = result.multiply(new BigInteger(Integer.toString(val)));
ng++;
} else {
negatives[pos] = val;
pos++;
}
}
if(ng==0)
{
int l=0;
return Integer.toString(l);
}
if ((pos % 2) == 0){
for (int i = 0;i < pos;i++){
result = result.multiply(new BigInteger(Integer.toString(negatives[i])));
}
} else {
int min = -1000; int mPos = -1;
for (int i = 0;i < pos;i++){
if(negatives[i] > min){
min = negatives[i];
mPos = i;
}
}
for (int j = 0;j < pos;j++){
if(j == mPos){
continue;
}
result = result.multiply(new BigInteger(Integer.toString(negatives[j])));
}
}
return result.toString();
}
}
答案 2 :(得分：0)
尝试制作满足这些测试用例或类似要求的代码。 {-2}-> -2
{2,3,2,2}-> 24
{-2，-2，-3}-> 6
{-2，-2，-2，-3}-> 24
{-2，-2,0,0，-2，-3}-> 24
{2,3,0,0,2,2}-> 24
{-2，-2,0,0,2,3}-> 24
{0,0}-> 0
以及在foobar挑战中，返回结果的大小可能为10 ^ 50。
因此，建议您使用String来实现产品。
import java.util.Arrays;
公共课主要 {
public static String result(int[] xs) {
// System.out.println（“ Hello World”）; int i = 0，j;
String pwr = "1";
Arrays.sort(xs);
while(i < xs.length && xs[i] < 0 ){
i++;
}
if(i != 0){
if (i == 1){
if(xs[xs.length - 1] == 0){
pwr = "0";
} else if (xs.length == 1){
return Arrays.valueOf(xs[0]);
}
}
else if(i % 2 == 0){
for (j = 0; j < i ;j++ ) {
pwr = multiply(pwr, String.valueOf(xs[j]));
}
} else {
for (j = 0; j < i - 1; j++ ) {
pwr = multiply(pwr, String.valueOf(xs[j]));
}
}
} else {
if(xs[xs.length - 1] == 0){
pwr = "0";
}
}
for(;i < xs.length; i++){
if(xs[i] != 0)
pwr = multiply(pwr, String.valueOf(xs[i]));
}
return (pwr);
}
public static String multiply(String num1, String num2){
String tempnum1 = num1;
String tempnum2 = num2;
// Check condition if one string is negative
if(num1.charAt(0) == '-' && num2.charAt(0)!='-')
{
num1 = num1.substring(1);
}
else if(num1.charAt(0) != '-' && num2.charAt(0) == '-')
{
num2 = num2.substring(1);
}
else if(num1.charAt(0) == '-' && num2.charAt(0) == '-')
{
num1 = num1.substring(1);
num2 = num2.substring(1);
}
String s1 = new StringBuffer(num1).reverse().toString();
String s2 = new StringBuffer(num2).reverse().toString();
int[] m = new int[s1.length()+s2.length()];
// Go from right to left in num1
for (int k = 0; k < s1.length(); k++)
{
// Go from right to left in num2
for (int j = 0; j < s2.length(); j++)
{
m[k+j] = m[k+j]+(s1.charAt(k)-'0')*(s2.charAt(j)-'0');
}
}
String product = new String();
// Multiply with current digit of first number
// and add result to previously stored product
// at current position.
for (int l = 0; l < m.length; l++)
{
int digit = m[l]%10;
int carry = m[l]/10;
if(l+1<m.length)
{
m[l+1] = m[l+1] + carry;
}
product = digit+product;
}
// ignore '0's from the right
while(product.length()>1 && product.charAt(0) == '0')
{
product = product.substring(1);
}
// Check condition if one string is negative
if(tempnum1.charAt(0) == '-' && tempnum2.charAt(0)!='-')
{
product = new StringBuffer(product).insert(0,'-').toString();
}
else if(tempnum1.charAt(0) != '-' && tempnum2.charAt(0) == '-')
{
product = new StringBuffer(product).insert(0,'-').toString();
}
else if(tempnum1.charAt(0) == '-' && tempnum2.charAt(0) == '-')
{
product = product;
}
// System.out.println("Product of the two numbers is :"+"\n"+product);
return product;
}
}