-1
votes

Compter les caractères consécutifs dans une liste?

Je veux créer une méthode Scala qui compte le nombre de caractères consécutifs dans lesquels les valeurs sont les mêmes. J'ai donc cette liste:

Liste ('A', 'A', 'B', 'B')

Et je veux retourner quelque chose comme une liste (('A', 2), 'B' , 1) - parce qu'il y a deux caractères avec les mêmes valeurs à côté de l'autre. J'ai eu une bash à cela avec peu de succès: xxx

reconnaissant pour toutes les directives.

recursion scala

1 commentaires

S'il y a deux ou plusieurs chaînes de caractères répétés, voulez-vous seulement que la chaîne la plus longue ou toutes comptait?

4 Réponses :

1
votes

Cela devrait fonctionner.
Je m'attendrais à ce que le code soit auto-expliquant, mais si vous avez une question, ne doutez pas de demander.

compressList(List.empty[Char])
// res: List[(Char, Int)] = List()

compressList(List('a', 'b'))
// res: List[(Char, Int)] = List(('a', 1), ('b', 1))

compressList(List('a', 'a', 'b'))
// res: List[(Char, Int)] = List(('a', 2), ('b', 1))

compressList(List('a', 'a', 'b', 'b', 'b', 'a', 'c'))
// res: List[(Char, Int)] = List(('a', 2), ('b', 3), ('a', 1), ('c', 1))

0 commentaires

0
votes

Utilisez MainMentiment et Dwwwwwwilesile

comptez consécutif xxx

`scala repl Xxx`



                                                                    
                                    
                                    
                                        0 commentaires


                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Vous n'avez pas spécifié le comportement souhaité s'il existe plusieurs séquences répétitives du même caractère. En supposant que vous souhaitez seulement la plus longue séquence répétée, le code suivant serait un bon point de départ:  xxx  
 exécutant   xxx  
 sortie:   xxx  
 L'idée est juste de regarder le caractère actuel de la liste et du caractère précédent. Lorsque le caractère change, le nombre de séquences est arrêté et la longueur de courant est comparée à ce qui est stocké sur la carte. C'est assez simple quand vous venez penser à cela.  
 Je pense que cela peut être écrit plus élégamment. Mais cela pourrait être un bon point de départ.                                  

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     peut également utiliser  span  au lieu de descendre et à prendre en charge pour éviter une double numérisation  xxx                                  


                                                                    
                                    
                                    
                                        1 commentaires
                                        
                                                                                            
                                                    C'est la solution la plus cool car elle peut être facilement modifiée pour couvrir à la fois le cas que seules des séquences répétitives les plus longues sont nécessaires au cas où toutes les séquences répétitives sont nécessaires.


            
                
		    
                    Articles qui pourrait vous intéresser :
                                            
                            Comment créer un nombre quelconque de boucles imbriquées?                        
                        
                                            
                            Étant donné un tableau d'entiers (de longueur n), trouver et retourner tous les sous-ensembles du tableau d'entrée en utilisant la récursivité en Java                        
                        
                                            
                            Problème de récursivité - cette solution est-elle correcte, et y en a-t-il une plus simple?                        
                        
                                            
                            Comment renvoyer false si le numéro n'est pas trouvé dans la liste