valeurs de tableau 2D de fréquence

Question

Si j'ai un tableau 2D qui est agencé comme suit:

String X[][] = new String [][] {{"127.0.0.9", "60", "75000","UDP", "Good"}, 
           {"127.0.0.8", "75", "75000","TCP", "Bad"}, 
         {"127.0.0.9", "75", "70000","UDP", "Good"}, 
         {"127.0.0.1", "", "70000","UDP", "Good"}, 
         {"127.0.0.1", "75", "75000","TCP", "Bad"} 
            }; 

Je veux connaître la fréquence de chaque valeur .. si I27.0.0.9 obtient 2. Comment puis-je faire une solution générale pour cela? En Java ou n'importe quel algorithme pour n'importe quelle langue?

Answer 1

Il semble que vous ayez besoin d'un type de données personnalisé pour encapsuler chaque ligne plutôt que d'utiliser un String[][], mais pour répondre plus directement à votre question, vous pouvez utiliser un Map<String,Integer> pour chaque colonne. On peut s'attendre à ce qu'un HashMap<String,Integer> le fasse dans le temps optimal.

---

Voici un extrait de démontrer l'idée:

import java.util.*; 

public class Frequency { 
    static void increment(Map<String,Integer> map, String key) { 
     Integer count = map.get(key); 
     map.put(key, (count == null ? 0 : count) + 1); 
    } 
    public static void main(String[] args) { 
     String table[][] = new String[][] { 
      {"127.0.0.9", "60", "75000","UDP", "Good"}, 
      {"127.0.0.8", "75", "75000","TCP", "Bad"}, 
      {"127.0.0.9", "75", "70000","UDP", "Good"}, 
      {"127.0.0.1", "", "70000","UDP", "Good"}, 
      {"127.0.0.1", "75", "75000","TCP", "Bad"} 
     }; 
     final int M = table.length; 
     final int N = table[0].length; 
     List<Map<String,Integer>> maps = new ArrayList<Map<String,Integer>>(); 
     for (int i = 0; i < N; i++) { 
      maps.add(new HashMap<String,Integer>()); 
     } 
     for (String[] row : table) { 
      for (int i = 0; i < N; i++) {    
       increment(maps.get(i), row[i]); 
      } 
     } 
     for (Map<String,Integer> map : maps) { 
      System.out.println(map); 
     } 
     System.out.println(maps.get(0).get("127.0.0.9")); 
    } 
} 

Ceci produit la sortie suivante: chaque ligne est une carte de fréquence pour chaque colonne:

{127.0.0.9=2, 127.0.0.8=1, 127.0.0.1=2} 
{=1, 60=1, 75=3} 
{75000=3, 70000=2} 
{UDP=3, TCP=2} 
{Good=3, Bad=2} 
2 

---

Note: Si vous ne vous souciez pas de mélanger les valeurs de toutes les colonnes, vous n'avez besoin que d'un Map, au lieu d'un List<Map> un pour chaque colonne. Cela rendrait la conception encore pire, cependant. Vous devriez vraiment encapsuler chaque ligne dans un type personnalisé, au lieu d'avoir tout mélangé comme String[][]. Par exemple, certaines de ces colonnes semblent vraiment être enum.

enum Protocol { UDP, TCP; } 
enum Condition { Good, Bad; } 
//... 

Answer 2

Vous pouvez utiliser la carte pour Java comme question ci-dessus, utilisez Dictionnaire C# L'algorithme général est que vous avez une table/tableau de clé - valeur. Et vous pouvez donner à la structure de données une clé, elle trouvera pour vous la valeur correcte pour cette clé.

Answer 3

Ne stockez pas tout en tant que chaînes. Cela ralentit le traitement et n'est pas élégant. Pourquoi stocker un numéro de port (qui est un int) en tant que chaîne? ou une valeur booléenne "bonne" "mauvaise" en tant que chaîne? Créez une classe personnalisée dont les champs ont des types correspondant à leur sémantique.

Answer 4

// I think this is an example of what Vodkhang is describing 

public static void main(String[] args){ 
    String X[][] = new String [][] {{"127.0.0.9", "60", "75000","UDP", "Good"}, 
          {"127.0.0.8", "75", "75000","TCP", "Bad"}, 
        {"127.0.0.9", "75", "70000","UDP", "Good"}, 
        {"127.0.0.1", "", "70000","UDP", "Good"}, 
        {"127.0.0.1", "75", "75000","TCP", "Bad"} 
           }; 

    final int M = X.length; 
    final int N = X[0].length; 

    HashMap<Object, ArrayList> map = new HashMap(); 

    for(int i = 0; i < M; i++){ 
     for(int j = 0; j < M; j++){ 
      String s = X[i][j]; 
      if(map.containsKey(s)){ 
       // add the string to the existing array list 
       ArrayList al = map.get(s); 
       al.add(s); 
       map.put(s,al); 
      } else { 
       // make a new node 
       ArrayList al = new ArrayList(); 
       al.add(s); 
       map.put(s, al); 
      } 
     } 
    } 

    // now loop through each pair in the map 
    // for each arraylist print out the size 
    Set<Object> set = map.keySet(); 
    for(Object s: set){ 
     ArrayList al = map.get(s); 
     System.out.println(s.toString() + " " + al.size()); 
    } 

}