通过在数字之间加“ 5”来返回最大可能的整数？

Question

在网上申请工作后，我在Codility在线测试平台上的Java编程测试中被问到这样的问题，有2个小时的时间限制回答。

问题是这样的： 给定输入正负整数N，编写一个Java程序，该程序返回可以通过在数字之间添加一个额外的“ 5”数字来返回的最大整数。 示例：如果N = 42，则解为542； 如果N = 731，则解= 7531; 如果N ＝ 0，则溶液＝ 50；如果N ＝ 0，则溶液＝ 50。 如果N = -36，解决方案= -356

你们可以帮助设计有效的编程解决方案吗？ 我认为解决方案的关键是找到小于5的第一个数字（从左到右），并将5放在前面。 以及负数的反向逻辑。 下面是一个令人头痛的解决方案，甚至可能无法按时进行编码。 我很好奇到底有什么更好或更有效的解决方案。

import java.util.*;
public class LagerstIntAddDigit5
{ public int LagerstIntAddDigit5(int N)
    {   int tmp=N, bignum=0, i=0;
        boolean isneg=false;
        if(N<0)
        {   isneg=true;
             tmp=0- tmp;
        }
        ArrayList <Integer> digits = new ArrayList <Integer>();
        while (tmp!=0)
        {  digits.add(tmp%10);
           tmp/=10;
        }
        if(digits.size()==0)
        {   digits.add(0);
        }Collections.reverse(digits);        

        while(i<digits.size())
        {   int dig=digits.get(i);
            if((!isneg && dig<5) || (isneg && dig>5))
            {   break;
            }i++;
        }digits.add(i,5);

        for (int j=0;j< digits.size();j++)
        {   bignum += digits.get(j) * Math.pow(10,digits.size()-j-1);
        }if(isneg)
        {   bignum=0-bignum;
        }return bignum;
    }
}

PS：我认为，这种算法测试对于工作筛选问题非常困难，尤其是在2小时的极限时间压力下。 我想知道，如果临时机构招聘人员能够逃脱询问如此艰巨的问题来筛选入门级技术支持工作，IT行业将变得人满为患，还是管理人员对IT工人造成不合理的压力。

Answer 1

您可以将其视为字符串解析问题，并仅匹配开头的子字符串以找到插入点。

public int largestIntAddDigit5(int n)  {
    return Integer.valueOf(String.valueOf(n)
          .replaceAll("^(-[0-5]*|[5-9]*)(.*)$" ,"$15$2")) ;
} 

Answer 2

您不必转换为string 。 在C#

    public static int getMax(int n)
    {
        bool isNegative = n < 0;
        int input = Math.Abs(n);

        int maxNumber = input * 10 + 5; // Starts with 5 at the end
        int multiplier = 10;

        while (true) // Move 5 to the left...
        {
            int lastDigits = input % multiplier;
            int firstDigits = (input - lastDigits) / multiplier;
            int newNumber = (firstDigits * 10 + 5) * multiplier + lastDigits;

            if (isNegative) newNumber = newNumber * -1;
            if (newNumber > maxNumber)
            {
                maxNumber = newNumber;
            }

            multiplier = multiplier * 10;
            if (firstDigits == 0) break;
        }
        return maxNumber;
    }

Answer 3

public static int largestIntAddDigit5(int i) {
    boolean neg = i < 0;
    StringBuilder sb = new StringBuilder();
    char[] chars = Integer.toString(neg ? -i : i).toCharArray();
    if (neg) {
        sb.append('-');
    }
    boolean need5 = true;
    for (char c : chars) {
        if (need5) {
            if ((neg && c > '5') || (!neg && c < '5')) {
                sb.append('5');
                need5 = false;
            }
        }
        sb.append(c);
    }
    if (need5) {
        sb.append('5');
    }
    return Integer.parseInt(sb.toString());
}

Answer 4

如果您是初学者，则可能意味着您要使用字符串。 我可以想到的没有字符串的唯一方法是需要知道诸如modulo技巧，很多人都不知道。

对此缺乏答案表明了这一点。 通常，这些面试问题是由3-5人提出的。 然而，在30分钟后，我们只有一个答案，这需要您了解StringBuilder类。

这是一个基于字符串的答案。

public static String assembleDigit(int i, String[] digitArray){
        String newDigit = "";
        for (int j = 0; j < digitArray.length; j++) {
            if (i == j){
                newDigit += "5" + digitArray[j];
            }
            else{
                newDigit +=  digitArray[j];
            }
        }
        return newDigit;
    }
    public static int largestDigitAdd5(int N){
        String number = Integer.toString(N);
        String[] digitArray = number.replace("-","").split("");

        int index =0;
        String newDigit = "";

        if ( N >= 0){
            for (int i = 0; i < digitArray.length; i++) {
                if (digitArray.length >= 3 && i == 0){
                    continue;
                }
                if (Integer.parseInt(digitArray[i]) < 5){
                    newDigit = assembleDigit(i, digitArray);
                    break;
                }
            }
        }
        else {
            for (int i = digitArray.length -1; i >= 0; i--) {
                if (digitArray.length >= 3 && i == digitArray.length -1 ){
                    continue;
                }
                if (Integer.parseInt(digitArray[i]) > 5){
                    newDigit= "-";
                    newDigit += assembleDigit(i, digitArray);
                    break;
                }
            }

        }
        return Integer.parseInt(newDigit);
    }

    public static void main(String[] args)
    {
        int N = 731;
        System.out.println(largestDigitAdd5(N));
    }

Answer 5

在玩了几分钟之后，这就是我的主意。 就像voytek所说的那样，他们可能正在寻找自己的方式。 祝好运！

public static int largestIntAddDigit5(int n) {   
    int result = 0;
    boolean isNeg;
    int tmp = n;
    ArrayList <Integer> digits = new ArrayList <Integer>();

    if(n >= 0) {
        isNeg = false;
    }
    else {
        isNeg = true;
        n = Math.abs(n);
    }

    if (tmp == 0) {
        digits.add(0);
    }
    else {
        while ( tmp != 0 ) {
            digits.add(tmp % 10);
            tmp /= 10;
        }    
    }
    Collections.reverse(digits);
    int i = 0;
    while(digits.size() > 0) {
        if (!isNeg) {
            if (digits.get(i) < 5) {
                digits.add(i, 5);
                for (Integer x : digits) {
                    result = result * 10 + x;
                }
                return result;
            }
            else {
                i++;
            }
        }
        else {
            if (digits.get(i) > 5) {
                digits.add(i, 5);
                for (Integer x : digits) {
                    result = result * 10 + x;
                }
                return -result;
            }
            else {
                i++;
            }
        }
    }
    return 5;
}