Количество вхождений элементов внутри массива? (Java)

Question

Я работаю над поиском этого алгоритма в течение примерно 6 часов и, похоже, не придумал решение. Я пытаюсь подсчитать вхождения элементов внутри массива и еще два отдельных массива. Один для уникальных экземпляров и один для того, сколько раз эти экземпляры происходят. Я обнаружил, что некоторые другие думают здесь о списках массивов и хэш-картах, но я могу использовать только массивы.

К примеру, у меня есть этот массив (уже отсортированный):

{cats, cats, cats, dog, dog, fish} 

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

{cats, dog, fish} 

И, наконец, сколько раз эти случаи происходят:

{3, 2, 1} 

Вот код, я до сих пор:

public void findArrs(String[] words) 
{ 
    int counter = 1; 
    for(int i = 0; i < words.length - 1; i++){ 
    if(!(words[i].equals(words[i+1]))){ 
    counter++; 
    } 
} 

String[] unique = new String[counter]; 
int[] times = new int[counter]; 

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

    }  
} 

Это все код, который у меня есть после всех моих попыток.

Answer 1

Вот обычный простой JavaScript:

var myarray = {"cats", "cats", "cats", "dog", "dog", "fish"}; 
var values = []; 
var instanceCount = [] 
for(var i = 0; i < myarray.length; i++){ 
    var value = myarray[i]; 
    var counter = 0; 
    for(var j = 0; j < myarray.length; j++){ 
     if(firstVal == myarray[j]) counter++; 
    } 
    //Build your arrays with the values you asked for 
    values.push(value); 
    instanceCount.push(counter); 

    //Remove All occurences further in the array 
    var idx = myarray.indexOf(value); 
    while (idx != -1) { 
     myarray.splice(idx, 1); 
     idx = array.indexOf(myarray, idx + 1); 
    } 
} 

//Handle Result here 

Answer 2

Вот как это можно сделать, используя только массивы. Сложная часть - вы должны знать количество элементов до создания массива. Поэтому мне пришлось создать свою собственную функцию для создания большего массива. На самом деле два, один для подсчета и один для уникальных значений.

Если вы можете использовать Векторы, вам будет лучше. Вот без vetors:

public class HelloWorld{ 

    public static void main(String []args){ 
     String[] initalArray; 

     // allocates memory for 10 integers 
     initalArray = new String[6]; 
     initalArray[0] = "cats"; 
     initalArray[1] = "cats"; 
     initalArray[2] = "cats"; 
     initalArray[3] = "dog"; 
     initalArray[4] = "dog"; 
     initalArray[5] = "fish"; 

     String[] uniqueValues = new String[0]; 
     int[] countValues = new int[0]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      boolean isNewValue = true; 
      for (int j = 0; j < uniqueValues.length; j++) 
      { 
       if (uniqueValues[j] == initalArray[i]) 
       { 
        isNewValue = false; 
        countValues[j]++; 
       } 
      } 

      if (isNewValue) 
      { 
       // We have a new value! 
       uniqueValues = addToArrayString(uniqueValues, initalArray[i]); 
       countValues = addToArrayInt(countValues, 1); 
      } 
     } 

     System.out.println("Results:"); 
     for(int i = 0; i < countValues.length; i++) 
     { 
      System.out.println(uniqueValues[i] + "=" + countValues[i]); 
     } 
    } 

    public static String[] addToArrayString(String[] initalArray, String newValue) 
    { 
     String[] returnArray = new String[initalArray.length+1]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      returnArray[i] = initalArray[i]; 
     } 
     returnArray[returnArray.length-1] = newValue; 

     return returnArray; 
    } 

    public static int[] addToArrayInt(int[] initalArray, int newValue) 
    { 
     int[] returnArray = new int[initalArray.length+1]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      returnArray[i] = initalArray[i]; 
     } 
     returnArray[returnArray.length-1] = newValue; 

     return returnArray; 
    } 
} 

Как уже упоминалось в комментариях, если мы знаем, что массив в порядке, то нам не нужно искать через весь предыдущий массив, и может просто проверить uniqueValues ​​непосредственно.

public class HelloWorld{ 

    public static void main(String []args){ 
     String[] initalArray; 

     // allocates memory for 10 integers 
     initalArray = new String[6]; 
     initalArray[0] = "cats"; 
     initalArray[1] = "cats"; 
     initalArray[2] = "cats"; 
     initalArray[3] = "dog"; 
     initalArray[4] = "dog"; 
     initalArray[5] = "fish"; 

     String[] uniqueValues = new String[0]; 
     int[] countValues = new int[0]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      boolean isNewValue = true; 
      if (i > 0) 
      { 
       if (uniqueValues[uniqueValues.length-1] == initalArray[i]) 
       { 
        isNewValue = false; 
        countValues[uniqueValues.length-1]++; 
       } 
      } 

      if (isNewValue) 
      { 
       // We have a new value! 
       uniqueValues = addToArrayString(uniqueValues, initalArray[i]); 
       countValues = addToArrayInt(countValues, 1); 
      } 
     } 

     System.out.println("Results:"); 
     for(int i = 0; i < countValues.length; i++) 
     { 
      System.out.println(uniqueValues[i] + "=" + countValues[i]); 
     } 
    } 

    public static String[] addToArrayString(String[] initalArray, String newValue) 
    { 
     String[] returnArray = new String[initalArray.length+1]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      returnArray[i] = initalArray[i]; 
     } 
     returnArray[returnArray.length-1] = newValue; 

     return returnArray; 
    } 

    public static int[] addToArrayInt(int[] initalArray, int newValue) 
    { 
     int[] returnArray = new int[initalArray.length+1]; 
     for(int i = 0; i < initalArray.length; i++) 
     { 
      returnArray[i] = initalArray[i]; 
     } 
     returnArray[returnArray.length-1] = newValue; 

     return returnArray; 
    } 
} 

Answer 3

Предполагая, что words массив имеет по меньшей мере один элемент:

int numberOfDifferentWords = 1; 
String firstWord = words[0]; 
for(int i = 0; i < words.length; i++) { 
    if(!firstWord.equals(words[i])) { 
     numberOfDifferentWords++; 
    } 
} 

// These two arrays will contain the results. 
String[] wordResultArray = new String[numberOfDiffentWords]; 
int[] countResultArray = new int[numberOfDiffentWords]; 

// This will mark where we should put the next result 
int resultArrayIndex = 0; 

String currentWord = firstWord; 
int currentWordCount = 0; 
for(int i = 0; i < words.length; i++) { 
    //if we're still on the same word, increment the current word counter 
    if(currentWord.equals(words[i])) { 
     currentWordCount++; 
    } 
    //otherwise, transition to a new word 
    else { 
     wordResultArray[resultArrayIndex] = currentWord; 
     wordCountArray[resultArrayIndex] = currentWordCount; 
     resultArrayIndex++; 

     currentWord = words[i]; 
     currentWordCount = 1; 
    } 
} 

Как и другие ответы уже упоминалось, эта проблема может быть упрощена с помощью списка такого ArrayList для хранения результатов.

Answer 4

Было бы очень просто, если вы используете ArrayList. Но поскольку вы хотите особенно массивы, вот мой код.

int lth = words.length; 
// Specify a broad length 
String[] unique = new String[lth]; 
int[] times = new int[lth]; 

int i = 0; 
int j = 0; 
int count; 
while (i < lth) { 
    String w = words[i]; 
    count = 1; 
    while(++i < lth && words[i].equals(w)) ++count; 
    unique[j] = w; 
    times[j++] = count; 
} 

// Reduce the length of the arrays  
unique = Arrays.copyOf(unique, j); 
times = Arrays.copyOf(times, j);  

for (i = 0; i < unique.length;++i) 
    System.out.println(unique[i] + " " + times[i]); 

Как вы можете видеть, реальной проблемой является длина массивов, которые вы должны указать перед их использованием. С ArrayLists вам не придется. Кроме того, поскольку элементы сортируются, предпочитайте использовать цикл while вместо цикла for. Это просто хорошо.

Answer 5

Создайте уникальную переменную экземпляра, чтобы вы могли извлекать их из другого класса с использованием методов getter.

Примечание: Модифицированный код можно найти по комментариям (для строки «Добавленная строка») для блока между «Добавленный код начинается здесь» до «Добавленный код заканчивается здесь»). Я попытался объяснить реализацию кода.Пожалуйста, дайте мне знать в комментариях, если мне нужно больше работать над своими навыками документации

public class someClass(){ 
    private String[] unique; 
    private int[] times; 
    //Added code starts here 
    public String[] getUnique(){ 
    return this.unique; 
    } 

    public int[] getTimes(){ 
    return this.times; 
    } 
    //Added code ends here 
    //Below implementation would work as intended only when words array is sorted 
    public void findArrs(String[] words) 
    { 
    int counter = 1; 
    for(int i = 0; i < words.length - 1; i++){ 
     if(!(words[i].equals(words[i+1]))){ 
      counter++; 
     } 
    } 

    unique = new String[counter]; 
    times = new int[counter]; 
    //Added line. 
    unique[0] = words[0]; 
    for(int i=0,j=0; i < words.length&&j < counter; i++){ 
    //Added code starts here 
     if(!(unique[j].equals(words[i]))){ 
      j++; //increment count when latest element in unique array is not equal to latest element in words array 
      unique[j] = words[i]; //add newly found unique word from words array to unique array 
      times[j] = 1; //make the count to 1 for first non repeated unique word 

     } 
     else{ 

      times[j]++; //increment the count every time the string repeats 
     } 
    //Added code ends here 
    }  
    } 
} 

Answer 6

Вы можете достичь его с помощью TreeMap:

public class NumberOfOccurences { 

    public static void main(String[] args) { 
     String[] testArr = {"cats", "cats", "cats", "dog", "dog", "fish"}; 
     String output = countNumberOfChild(testArr); 

     System.out.println(output); 

    } 


    public static String countNumberOfChild(String[] list){ 
     Arrays.sort(list); 

     TreeMap<String,Integer> noOfOccurences = new TreeMap<String,Integer>(); 


     for(int i=0;i<list.length;i++){ 
      if(noOfOccurences.containsKey(list[i])){ 
       noOfOccurences.put(list[i], noOfOccurences.get(list[i])+1); 
      } 
      else{ 
       noOfOccurences.put(list[i], 1); 
      } 
     } 

     String outputString = null; 
     while(!noOfOccurences.isEmpty()){ 
      String key = noOfOccurences.firstKey(); 
      Integer value = noOfOccurences.firstEntry().getValue(); 
      if(outputString==null){ 
       outputString = key+"="+value; 
      } 
      else{ 
       outputString = outputString + ";" + key+"="+value; 
      } 
      noOfOccurences.remove(key); 
     } 

     return outputString; 
    } 
} 

Answer 7

String s[] = {"Arranged", "Administered", "Advised", "Administered", "Adapted"}; // Сохраняет предварительно определенное количество слов

String k="I have administered and advised him to stay away."; // строка, которую вы хотите, чтобы соответствовать, если он содержит эти слова

String ka[]=k.split("\\s"); // Сплит-й е строка на Эври пространстве появления так, что он извлекает каждое слово

for(i=0;i<ka.length;i++)

{for(j=0;j<s.length;j++){

if(ka[i].equalsIgnoreCase(s[j]))

{System.out.println("The occurred words are:" +s[j]);

continue; // Продолжить используется для поиска, если более, что одно слово имеет произошло

}

}

}