-2
votes

Scala Process Listes de chaînes et de la carte ["combinaison", nombre de listes avec cette combinaison]

J'ai une SEQ [Liste [String]]]. Exemple:

Map(
""A","B","F"" -> 10,
""A","B","D"" -> 4,
""A","B","P"" -> 2,
...
...
..
)

list dictionary scala consolidation

2 commentaires

Chaque clé doit-elle être la concaténation de 3 chaînes? Pas intéressé par 2 ou 4 combinaisons de chaînes? Pourquoi inclure toutes les marques de devis et les virgules dans chaque clé? Pourquoi pas "abf" ou "a, b, f" au lieu de "\" a \ ", \" f \ ", \" f \ " "?


                                        
                                                                            Si vous dites  seq [liste]]]  L'exemple des données doit être: SEQ (Liste ("B", "D", "A", "P", "F"), Liste ("B", "A", "F"), liste ("B", "D", "A", "F"), liste ("B", "D", "A", " "," F "), liste (" B "," A "," P "," F "), liste (" B "," D "," A "," P "," F "), Liste ("B", "A", "F"), liste ("B", "A", "F"), liste ("B", "A", "F"), liste ("B", "UN F")     )



                                    
                    3 Réponses :
                    
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Le format de votre vecteur n'est pas correct Syntaxe Scala, que je pense que vous voulez dire quelque chose comme ceci:  xxx  pré> 
 Il ressemble à ce que vous essayez d'accomplir est deux   code> clauses. Premièrement, vous souhaitez obtenir toutes les combinaisons à partir de chaque liste, puis obtenir les combinaisons les plus fréquentes d'accrocher les ensembles, obtenez la fréquence à laquelle ils se produisent, puis pour les groupes qui se produisent à la même fréquence, font un autre groupe  par  code > et fusionner ceux ensemble.  p> 
 Pour cela, vous aurez besoin de la fonction suivante pour effectuer la double réduction après la double groupe.  P> 
 Étapes:  P> 

 Ramassez toutes les séquences de groupes. Articles intérieurs, nous calculons les combinaisons totales d'éléments à l'intérieur de cette liste d'éléments générant un  SEQ [SEQ [String]]  code> des groupes où le  SEQ [String]  code> est unique combinaison. Ceci est aplatie car le  (1 à group.length)  code> fonctionne génère un  SEQ  code> de  SEQ [SEQ [String]]  code>. Nous aplâtons ensuite tous les mappages ensemble accrocher toutes les listes du vecteur que vous devez obtenir un  SEQ [SEQ [String]]  CODE>  LI>
 La fonction  groupmapreduce  code> est utilisée pour calculer la fréquence à laquelle une certaine combinaison apparaît, puis chaque combinaison est donnée une valeur de 1 à résumer. Cela donne une fréquence sur la fréquence à laquelle une certaine combinaison apparaît.  Li>
 Les groupes sont regroupés à nouveau, mais cette fois par le nombre de seventions. Donc, si "A" et "B" se produisent tous les deux 10 fois, ils seront regroupés.  Li>
 La carte finale réduit les groupes accumulés  li>
 OL> List(List(B, D, P), List(A, D, P), List(D, F, P)): 2
List(List(A, B, F)): 10
List(List(B, D, F), List(A, D, F), List(A, B, D)): 4
List(List(A, F, P), List(B, F, P), List(A, B, P)): 3
List((List(B, D, T), List(A, F, T), List(B, F, T), List(A, D, T), List(A, B, T), List(D, F, T)): 1

As you can see in your example, `List(B, D, F)` and `List(A, D, F)` are also associated with your second line "A,B,D".

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     Assumer les données avec une commande différente comptée comme un groupe, par exemple: BAF et ABF dans un groupe, la solution serait. 
res1: scala.collection.immutable.Map[List[String],Int] = HashMap(List(A, B, F, P) -> 1, List(A, B, D, F) -> 1, List(A, B, D, F, T) -> 1, List(A, B, D, F, P) -> 2, List(A, B, F) -> 5)


                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     ici c'est:  xxx  
 comme vous pouvez le constater, les "A, B, D" et "A, B, P" sont réduits dans le résultat, car le sous-ensemble est sous-ensemble "ABDF" et "ABPDF" ...                                  

                                                                    
                                    
                                    
                                        0 commentaires