Как распечатать самое длинное слово в строке БЕЗ использования массивов и только циклов в Java

Question

В настоящее время я могу понять, как отобразить самую длинную длину слова. Однако, есть ли способ использовать циклы, чтобы определить самое длинное слово и распечатать его?

    public static void longestWordCalculator(String rawText)
{
    int lengthCounter = 0;
    int finalCounter = 0;
    int textLength = rawText.length();
    for (int i = 0; i < textLength ; i++)
    {
        String indexValue = Character.toString(rawText.charAt(i));
        if(!" ".equals(indexValue))
        {
            lengthCounter++;
        }
        else
        {
            finalCounter = Math.max(finalCounter, lengthCounter);
            lengthCounter = 0;
        }
    }
    System.out.println("Final Value: " + Math.max(finalCounter, lengthCounter));
}

Answer 1

Вот решение без разделения:

public class LongestWord {

      public static void longestWordCalculator(String rawText)
      {
          int lastSeparator = -1;
          int maxLength = 0;
          int solPosition = 0;
          int textLength = rawText.length();

          for (int i = 0; i < textLength ; i++)
          {
              //here you may check for other separators
              if (rawText.charAt(i) == ' ') {
                  lastSeparator = i; 
              }
              //assuming no separator is part of a word 
              else {
                  if (i - lastSeparator > maxLength) {
                      maxLength = i - lastSeparator;
                      solPosition = lastSeparator;
                  }
              }
          }
          if (maxLength > 0) {
              String solution = rawText.substring(solPosition+1, solPosition+maxLength+1);
              System.out.println("Longest word is: " + solution);
          }
          else {
              System.out.println("No solution finded!");
          }

      }

      public static void main (String args[]) {
          longestWordCalculator("la casa de mi amigo");
          longestWordCalculator("quiero agua");
          longestWordCalculator("bblablabla");
          longestWordCalculator("");
      }
}

Вывод:

Longest word is: amigo
Longest word is: quiero
Longest word is: bblablabla
No solution finded!

Answer 2

Это простое решение, и оно фактически выведет все слова с самой длинной длиной вместо одного.

public class Main {

    public static void main(String[] args) {

        String string = "one two three four five six seven eight nine";

        String currentWord = "";
        String largestWords = "";
        int longestLength = 0;

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

            char iteratedLetter = string.charAt(i);
            if (iteratedLetter == ' ') { // previous word just ended.

                if (currentWord.length() > longestLength) {
                    largestWords = "";
                    longestLength = currentWord.length();
                }
                else if (currentWord.length() == longestLength) {
                    largestWords += currentWord + " ";
                }

                currentWord = "";
            }
            else {
                currentWord += iteratedLetter;
            }



        }

        System.out.println("Largest words: " + largestWords);

    }
}

Я рекомендую понять код, хотя, как вы сказали, это задание .

Answer 3

Я сохраняю ваш код, не используя массив. Вот обновленный код:

public class Test {
    public static void longestWordCalculator(String rawText) {
        int lengthCounter = 0;
        int finalCounter = 0;
        int textLength = rawText.length();
        StringBuffer processingWord = new StringBuffer();
        String foundWord = null;
        for (int i = 0; i < textLength; i++) {
            String indexValue = Character.toString(rawText.charAt(i));
            if (!" ".equals(indexValue)) {
                processingWord.append(rawText.charAt(i));
                lengthCounter++;

            } else {
                if (finalCounter < lengthCounter) {
                    finalCounter = lengthCounter;
                    foundWord = processingWord.toString();
                    processingWord = new StringBuffer();
                }
                lengthCounter = 0;
            }
        }
        System.out.println("Final Value: " + finalCounter + ", Word: " + foundWord);
    }

    public static void main(String args[]) {
        longestWordCalculator("It looks good");
    }
}

Надеюсь, что это поможет.

Answer 4

Два опубликованных ответа хороши, и я бы их использовал, однако, если вы хотите сохранить текущую реализацию и избежать массивов и т. Д. c, вы можете сохранить местоположение начала текущей самой длинной строки при сохранении новой самой длинной длина с longestIndex = i - lengthCounter. В конце выведите подстроку в rawText из longestIndex в longestIndex + finalCounter.

Правка - попробуйте что-то вроде этого

int lengthCounter = 0;
    int finalCounter = 0;
    int textLength = rawText.length();
    int longestIndex = 0;
    for (int i = 0; i < textLength ; i++)
    {
        String indexValue = Character.toString(rawText.charAt(i));
        if(!" ".equals(indexValue))
        {
            lengthCounter++;
        }
        else
        {
            if (lengthCounter > finalCounter) {
                longestIndex = i - lengthCounter;
                finalCounter = lengthCounter;
            }

            lengthCounter = 0;
        }
    }
    System.out.println("Final Value: " + finalCounter);
    System.out.println("Longest Word: " + rawText.substring(longestIndex, longestIndex + finalCounter));

Answer 5

Используйте Pattern и Matcher и while l oop. Что-то вроде

public static void longestWordCalculator(String rawText) {
    Pattern p = Pattern.compile("(\\S+)\\b");
    Matcher m = p.matcher(rawText);
    String found = null;
    while (m.find()) {
        String s = m.group(1);
        if (found == null || s.length() > found.length()) {
            found = s;
        }
    }
    if (found == null) {
        System.out.println("No words found");
    } else {
        System.out.printf("The longest word in \"%s\" is %s which is %d characters.%n", 
                rawText, found, found.length());
    }
}

Answer 6

Разделите текст по пробелу и найдите самое длинное слово. Попробуйте этот код.

public class Test {
    public static void longestWordCalculator(String rawText) {
        String[] words = rawText.trim().replaceAll(" +", " ").split(" ");
        int foundIndex = -1;
        int maxLenght = 0;
        String foundWord = "";
        for (int i = 0; i < words.length; i++) {
            if (words[i].length() > maxLenght) {
                maxLenght = words[i].length();
                foundWord = words[i];
                foundIndex = i;
            }
        }
        System.out.println(String.format("Longest word is [Word=%s, WordLength=%s, WordIndex=%s]", foundWord, maxLenght, foundIndex));
    }

    public static void main(String args[]) {
        longestWordCalculator("It looks good");
    }
}

Входные данные: «Выглядит хорошо»

Выходные данные: самое длинное слово [Word = выглядит, WordLength = 5, WordIndex = 1]

Answer 7

Можно использовать split(), чтобы разбить строку на строковый массив, а затем циклически перебирать каждый элемент, чтобы проверить длину слова. В этом примере мы предполагаем, что специальных символов нет, а слова разделяются пробелом.

Эта функция найдет первое самое длинное слово, т. Е. При значении ie будет выведено первое слово с самой длинной длиной. В приведенном ниже примере вы можете видеть, что looking и longest имеют одинаковое количество символов, но выводит только looking.

public static void longestWordCalculator(String rawText)
{
    int textLength = rawText.length();
    String longestWord = "";
    String[] words = rawText.split("\\s");
    for (int i = 0; i < words.length; i++)
    {
        if (words[i].length() > longestWord.length()) {
          longestWord = words[i];
        }
    }
    System.out.println("Longest word: " + longestWord);
    System.out.println("With length of: " + longestWord.length());
}

Использование: longestWordCalculator("Hello I am looking for the longest word");

Выходы

Самое длинное слово: смотрящий

С длиной: 7

РЕДАКТИРОВАТЬ:

Без использования массивов:

public static void longestWordCalculator(String rawText)
{
    int nextSpaceIndex = rawText.indexOf(" ") + 1;
    String longestWord = "";
    do {
        String word = rawText.substring(0, nextSpaceIndex);
        rawText = rawText.substring(nextSpaceIndex); // trim string
        if (word.length() > longestWord.length()) {
            longestWord = word;
        }
        int tempNextIndex = rawText.indexOf(" ") + 1;
        nextSpaceIndex = tempNextIndex == 0 ? rawText.length() : tempNextIndex;
    } while (rawText.length() > 0);
    System.out.println("Longest word: " + longestWord);
    System.out.println("With length of: " + longestWord.length());
}