如何获取只删除一位数字得到的最大可能值

Question

我遇到了这个可容性测试，其中我需要 return 通过从数字中删除一个“5”数字获得的最大可能值，例如：

n = 15958 函数应该 return 1958
n = -1525 return -125
n = -50 return 0

我设法通过创建一个置换数组来做到这一点，但它是 O(NlogN) 可以让它变得更好吗？

Answer 1

将最大值设置为 Integer.MIN_VALUE
转换为字符串
迭代字符串中的所有位置
删除字符
将结果字符串转换为整数
如果找到新的最大值，请设置最大值

Return遍历所有值后的最大值！

public static void main(String []args){
  int value = 15958;

  int maxValue = Integer.MIN_VALUE;
  String stringValue = Integer.toString(value);
  for (int i = 0; i < stringValue.length(); i++) {
      String stringToCheck = stringValue.substring(0, i) + stringValue.substring(i + 1);
      int intToCheck = Integer.parseInt(stringToCheck);
      maxValue = intToCheck > maxValue ? intToCheck : maxValue;
  }
  System.out.println(maxValue);
}

Answer 2

以下 MWB 回答此处理负数并仅删除一位数字：

public static void main(String []args){
    int num = -1595;
    int sign = num > 0 ? 1 : -1;
    int value = Math.abs(num);
    int maxValue = Integer.MIN_VALUE;
    String stringValue = Integer.toString(value);

    for (int i = 0; i < stringValue.length(); i++) {

      final String digit = stringValue.substring(i, i + 1);

      if (digit.equals("5")) {
        String stringToCheck = stringValue.substring(0, i) + stringValue.substring(i + 1);
        int intToCheck = Integer.parseInt(stringToCheck) * sign;
        maxValue = Math.max(intToCheck, maxValue);
      }

    }
    System.out.println(maxValue);
}

Answer 3

是的，正确，该函数也可以完美地处理负数和正数 -

public static int getMaxValue(){ 整数值 = -15958;

        int maxValue = Integer.MIN_VALUE;
        String stringValue = Integer.toString(value);
        for (int i = 0; i < stringValue.length(); i++) {
            if(stringValue.charAt(i)=='5') {
                String stringToCheck = stringValue.substring(0, i) + stringValue.substring(i + 1);
                int intToCheck = Integer.parseInt(stringToCheck);
                maxValue = intToCheck > maxValue ? intToCheck : maxValue;
            }
        }
        //System.out.println(maxValue);
    return maxValue;
}

Answer 4

如果我们考虑 Java 7 及以上，以上所有答案的时间复杂度均为 O(n^2)。原因：1.You 遍历整个字符串 2.在每次迭代中，您都在创建一个 O(n) 操作的子字符串本身

解决方案：

int size = String.valueOf(n).length();
if(n<0) {
    size--;
}
int max = Integer.MIN_VALUE;
int divisor = Math.pow(10, size-1);
int left = 0;
int right=0;
while(divisor > 0) {
    left = n/divisor;//left part includes the current 5
    right = n%divisor;
    if(temp%5 == 0 && temp%10 != 0) {
        temp=temp/10;//remove the current 5;
        newNum = temp*divisor+remainder
        max=Math.max(newNum, max);
    }
    divisor = divisor/10;
}
return max;

Answer 5

int RemoveOneFive(int N)
{
    bool negative = (N>0) ? false:true;
 
    std::string s = std::to_string(N);
    int numFives = 0;
    for(int i=0;i<s.length(); i++)
        numFives = (s[i] == '5') ? numFives + 1 : numFives;
 
    int process = false;
    std::string out;
    for(int i=0;i<s.length(); i++)
    {
        if(s[i] != '5' || process == true)
            out.push_back(s[i]);
 
        else if(s[i] == '5')
        {
            if(numFives == 1)
                continue;
            else
            {
                numFives --;

                if((s[i+1] > '5' && negative == false) || (s[i+1] < '5' && negative == true)
                    process = true;
                else
                    out = out + s[i];
            }
        }
 
    }
 
    return std::atoi(&out[0]);
}

Answer 6

 public static int MaxAfterRemoving5(int num){
        string numStr = num.ToString();
        List<int> possibilities = new List<int>();
        for (int i = 0; i < numStr.Length;i++){
            if(numStr[i]=='5'){
                string splitStr = numStr.Remove(i, 1);
                possibilities.Add(Convert.ToInt32(splitStr));
            }
        }
        return possibilities.Max();
    }

如何获取只删除一位数字得到的最大可能值

How to get the maximum possible value obtained by deleting only one digit

java

permutation