檢查字符串中的數字

Question

注意：我知道有很多方法可以簡化此過程，但不允許這樣做。 我受限於普通的基本Java，循環和手寫方法。 甚至數組也不允許使用。

任務是檢查句子中每個單詞的數字，找到最大數字的單詞，同時最大功率為3。我在這里做了所有操作，直到我輸入類似的內容，它都可以正常工作。

asdas8 dasjkj27 asdjkj64 asdjk333 asdjkj125

我收到的輸出是64，而不是125，因為它在到達第一個不是冪數3的數字時停止檢查。

我如何才能繼續迭代直到句子的結尾並避免在達到3的非冪次時停止，如何修改此代碼以實現這一目標？

編輯：但是，如果我在失敗的單詞后輸入多個單詞，它將正常工作。

例如：

asdas8 dasjkj27 asdjkj64 asdjk333 asdjkj125 asdash216

這是我的代碼：

public class Nine {

static int num(String s) { // method to change string to int
    int b = 0;
    int o = 0;
    for (int i = s.length() - 1; i >= 0; i--) {
        char bi = s.charAt(i);
        b += (bi - '0') * (int) Math.pow(10, o);
        o++;

    }

    return b;
}

static boolean thirdPow(int a) {
    boolean ntrec = false;
    if (Math.cbrt(a) % 1 == 0)
        ntrec = true;
    return ntrec;

}



static int max(int a, int b) {
    int max= 0;
    if (a > b)
        max= a;
    else
        max= b;
    System.out.print(max);
    return max;
}

static String search(String r) {
    String current= ""; // 23aa64
    String currentA= "";
    String br = ""; // smjestamo nas broj iz rijeci 23
    int bb = 0; // nas pretvoreni string u broj
    int p = 0;

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

        current+= r.charAt(i);
        if (r.charAt(i) == ' ') { 
            for (int j = 0; j < current.length(); j++) {
                while ((int) current.charAt(j) > 47 && (int) current.charAt(j) < 58) {
                    br += current.charAt(j); 
                    j++;
                }
                bb = num(br);
                System.out.println("Third pow" + thirdPow(bb));

                if (thirdPow(bb)) {
                    p = max(p, bb);

                }

                br = "";

            }

            current= "";

        }

    }

    String pp = "" + p;
    String finalRes= "";
    for (int u = 0; u < r.length(); u++) {
        currentA+= r.charAt(u);
        if (r.charAt(u) == ' ') {
            if (currentA.contains(pp))
                finalRes+= currentA;
            currentA= "";
        }
    }
    System.out.println(p);
    return finalRes;

}

public static void main(String[] args) {
    Scanner scan = new Scanner(System.in);
    System.out.print("Enter sentence: ");
    String r = scan.nextLine();

    System.out.println("Our string is : " + search(r));

}
  }

Answer 1

我假設每個單詞都由一個空格隔開並且包含非整數。

正則表達式的使用肯定會降低代碼的復雜性，讓我們嘗試以下代碼：-

String input = "asdas8 dasjkj27 asdjkj64 asdjk333 asdjkj125";

String[] extractWords = r.split(" ");        //extracting each words

int[] numbers = new int[extractWords.length]; // creating an Integer array to store numbers from each word

int i=0;

for(String s : extractWords) {
        numbers[i++] = Integer.parseInt(s.replaceAll("\\D+", "")); // extracting numbers
}

現在，“數字”數組將包含[8、27、64、333、125]

您可以使用自己的邏輯在其中找到最大值。 希望這可以幫助。

Answer 2

兄弟用

*string.split(" ");*

形成一個字符串數組，然后遍歷該數組並使用正則表達式解析數字

^[0-9]

要么

\d+

然后從數組中找到最大的數字就這么簡單。 Brother會逐步進行操作，然后您的代碼將運行得更快。

Answer 3

你可以做我正在做的事。 首先將句子拆分為單詞塊。 我這樣做是基於空格，因此是in.split("\\\\s+") 。 然后從這些單詞中找到數字。 在這些數字上，僅當其為3的冪時才檢查最高數字。

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.regex.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
static boolean isPowOfThree(int num)
{
    int temp = (int)Math.pow(num, 1f/3);
    return (Math.pow(temp, 3) == num);
}

public static void main (String[] args) throws java.lang.Exception
{
    Scanner sc = new Scanner(System.in);
    String in = sc.nextLine();
    String[] words = in.split("\\s+");
    String maxWord = ""; //init default word
    int maxNum = -1; //init default num

    for(String word : words)
    {
        Pattern p = Pattern.compile("\\d+");
        Matcher m = p.matcher(word);
        while (m.find()) 
        {
          String num = m.group();
          if(isPowOfThree(Integer.parseInt(num)))
          {
            if(Integer.parseInt(num) > maxNum)
            {
                maxNum = Integer.parseInt(num);
                maxWord = word;
            }
          }
        }
    }

    if(maxNum > -1)
    {
        System.out.println("Word is : " + maxWord);
    }
    else
    {
        System.out.println("No word of power 3");
    }

}
}

Answer 4

使用\\\\d+正則表達式以及Java中的Matcher和Pattern API可以解決此問題。

package com.company;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {

    public static void main(String[] args) {
        String i = "asdas8 dasjkj278 asdjkj64 asdjk333 asdjkj125";
        Matcher matcher = Pattern.compile("\\d+").matcher(i);

        List<Integer> numbers = new ArrayList<>();
        while (matcher.find()){
            numbers.add(Integer.parseInt(matcher.group()));
        }

        Collections.sort(numbers);
        Collections.reverse(numbers);

        Integer power3 = 0;

        for (Integer n : numbers) {
            if (isPowOfThree(n)) {
                power3 = n;
                break;
            }
        }
        System.out.println(power3);
    }

    static boolean isPowOfThree(int num) {
        int temp = (int)Math.pow(num, 1f/3);
        return (Math.pow(temp, 3) == num);
    }
}

使用\\\\d+正則表達式后，對於while(matcher.find())每次迭代，我們將獲得給定字符串中的所有數字。 一旦我們收集了給定字符串中的所有數字，就需要對集合進行反向排序。 如果我們對該集合進行迭代，則發現的第一個數字是最大的數字（是3的冪），因為該集合已按降序排序。