0
votes

J'essaie de comprendre comment l'appel de sous-chaîne travaille dans ce code?

Je sais comment fonctionne la sous-chaîne, mais j'essayais de comprendre comment cela fonctionne dans le code ci-dessous. L'objectif était de trouver le préfixe commun le plus long dans une gamme de chaînes. L'entrée de chaîne était {fleur, flux, molleton}. On dirait que la sous-chaîne prend simplement la parole totale de fleur, quand ce n'est pas 0, à chaque fois, de 0 à la longueur-1 va donner le mot entier.

 public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) return "";
    String prefix = strs[0];
    for (int i = 1; i < strs.length; i++)
        while (strs[i].indexOf(prefix) != 0) {
            prefix = prefix.substring(0, prefix.length() - 1);
            if (prefix.isEmpty()) return "";
        }        
    return prefix;
}

java substring indexof

0 commentaires

3 Réponses :

1
votes

0 à la longueur-1 va donner le mot entier

Non, ça retourne le mot sauf le dernier caractère.
De: HTTPS: //docs.oracle.com/javase/7/docs/aPI/java/lang/string.html#substring(int ,%20int)

String String SUBSTRING (INT BeGuinDex, int endindex)
Retours A nouvelle chaîne qui est une sous-chaîne de cette chaîne.
la sous-chaîne commence au débutnindex spécifié et s'étend au personnage à Index endidex - 1.

Alors, quel est le code qui coupe le dernier caractère à chaque itération avec cette ligne: xxx
jusqu'à ce qu'il trouve un préfixe commun.

2 commentaires

Je suis également confondu dans la condition alors que la condition? Si c'est itération jusqu'à ce que 0 est atteint, il est itération jusqu'au début du mot? Quand quelque chose n'est pas trouvé, Indexof retourne négatif 1?

La signification de indexof (préfixe)! = 0 est que le préfixe doit démarrer au 1er caractère (index = 0) du mot que celui-ci est comparé à. Donc, la boucle continue en coupant le dernier char jusqu'à ce que le préfixe soit identique au début du mot, ce qui signifie que sa position de départ est 0.


                        
                                            
                            
                                
                                    1
 votes
                                
                            
                            
                                
                                     L'endindex dans la sous-chaîne () est exclusif. Donc, ce que le code est supprimé le dernier caractère de la variable préfixe. 
String hello = "hello";
System.out.println(hello.substring(0,hello.length));
// hello
System.out.println(hello.substring(0,hello.length - 1));
// hell

                                

                                                                    
                                    
                                    
                                        0 commentaires
                                        
                                                                                    
                                    
                                                            
                        
                        
                                            
                            
                                
                                    0
 votes
                                
                            
                            
                                
                                     Alors que ce n'est pas directement ce que vous demandez, il convient de mentionner que l'utilisation de  indexofof  code> et  la soustrine  code> n'est pas un bon moyen d'approcher cela. 
  Strs [i] .indexof (préfixe)! = 0  code> est un moyen inefficace de vérifier si une chaîne commence avec quelque chose. En effet, si elle trouve la chaîne ne démarre pas par  préfixe  code>, il continue à rechercher une occurrence à d'autres positions - et cela n'a pas d'importance s'il l'apparaît.  P> 
 Une vérification plus efficace serait ! Strges [i] .startswith (préfixe)  code>: dès qu'il trouve la chaîne ne démarre pas avec le préfixe, il s'arrête.  P> 
 Ensuite, en utilisant  substrant  code> pour hacher un caractère éteint l'extrémité de la chaîne est également inefficace: chaque fois qu'il varie hors d'un seul caractère, il crée une nouvelle chaîne, puis vous vérifiez à nouveau; Mais vous devrez peut-être avoir à couper  lots  em> de caractères individuels avant de trouver un préfixe correspondant.  p> 
 Vous pouvez éviter le morceau "Créer des objets" de cela, en utilisant  STRS [i] .regionMatches (0, préfixe, 0, somelength)  code>, où  somelength  code> est un int qui démarre à  préfix.length ()  code>, et vous Décrément jusqu'à ce que  régionMatches  code> renvoie true. Mais cela reste inefficace en ce que vous en décrémentez un à la fois.  P> 
 Il est plus facile si vous le faites d'une autre manière: commencez par  somelength  code> à zéro et  Incrément  em> jusqu'à soit:  p> 

 Il est égal à la longueur du préfixe  code>:  somelength> = préfixe.length ()  code>  li>
 Il est égal à la longueur de  strges [i]  code>:  somelength> = STRS [I] .Longueur ()  code>  li>  li>
 Les caractères correspondants à cette position ne correspondent pas:  préfixe.charat (somelength)! = STR [i] .chard (somelength)  code>  li>  li>
 ul>  Ceci est fondamentalement ce que  startswith  code> fait, mais en le faisant "vous-même", vous découvrez la position où les chaînes diffèrent.  p> 
 alors, utilisez  Préfixe = préfixe.Substring (0, Somelength);  code> pour la couper en une fois. Ou ne le frappe pas du tout: vous pouvez simplement stocker la longueur du préfixe commune et faire la sous-chaîne une fois, à la fin.  P> 
 Le code ressemblerait à quelque chose comme:  p> 
public String longestCommonPrefix(String[] strs) {
    if (strs.length == 0) return "";
    int prefixLength = strs[0].length();
    for (int i = 1; i < strs.length; i++) {
        int s = 0;
        while (s < prefixLength
            && s < strs[i].length()
            && strs[0].charAt(s) == strs[i].charAt(s)) {
          ++s;
        }
        prefixLength = s;
    }
    return strs[0].substring(0, prefixLength);
}

                                

                                                                    
                                    
                                    
                                        0 commentaires