PHP Plusieurs occurrences de mots dans une chaîne

Question

J'ai besoin de vérifier une chaîne pour voir si un mot contient plusieurs occurrences. Donc, fondamentalement, j'accepterai:

"google fait l'amour"

mais je n'accepte pas:

"Google fait google amour" ou "Google fait l'amour l'amour google", etc.

Des idées? Je ne sais vraiment pas comment aborder cela, toute aide serait grandement appréciée.

Answer 1

Basé sur le code de puces Wicked:

function single_use_of_words($str) { 
    $words = explode(' ', trim($str)); //Trim to prevent any extra blank 
    if (count(array_unique($words)) == count($words)) { 
     return true; //Same amount of words 
    } 
    return false; 
} 

Answer 2

function Accept($str) 
{ 
    $words = explode(" ", trim($str)); 
    $len = count($words); 
    for ($i = 0; $i < $len; $i++) 
    { 
     for ($p = 0; $p < $len; $p++) 
     { 
      if ($p != $i && $words[$i] == $words[$p]) 
      { 
       return false; 
      } 
     } 
    } 
    return true; 
} 

EDIT

script test. Notez, lors de l'impression "faux" php imprime rien mais vrai est imprimé comme "1".

<?php 

    function Accept($str) 
    { 
      $words = explode(" ", trim($str)); 
      $len = count($words); 
      for ($i = 0; $i < $len; $i++) 
      { 
        for ($p = 0; $p < $len; $p++) 
        { 
          if ($p != $i && $words[$i] == $words[$p]) 
          { 
            return false; 
          } 
        } 
      } 
      return true; 
    } 

echo Accept("google makes love"), ", ", Accept("google makes google love"), ", ", 
    Accept("google makes love love google"), ", ", Accept("babe health insurance babe"); 


?> 

imprime la sortie correcte:

1, , , 

Answer 3

La méthode la plus simple consiste à boucle à travers chaque mot et vérifier contre tous les mots précédents pour les doublons.

Answer 4

Expression régulière avec les références arrières

http://www.regular-expressions.info/php.html

http://www.regular-expressions.info/named.html

Answer 5

Essayez ceci:

function single_use_of_words($str) { 
    $words = explode(' ', $str); 
    $words = array_unique($words); 
    return implode(' ', $words); 
} 

Answer 6

<?php 
$words = preg_split('\b', $string, PREG_SPLIT_NO_EMPTY); 
$wordsUnique = array_unique($words); 
if (count($words) != count($wordsUnique)) { 
    echo 'Duplicate word found!'; 
} 
?> 

Answer 7

Cela semble assez rapide. Il serait intéressant de voir (pour toutes les réponses) comment l'utilisation de la mémoire et le temps pris augmentent à mesure que vous augmentez la longueur de la chaîne d'entrée.

function check($str) { 
    //remove double spaces 
    $c = 1; 
    while ($c) $str = str_replace(' ', ' ', $str, $c); 

    //split into array of words 
    $words = explode(' ', $str); 
    foreach ($words as $key => $word) { 
     //remove current word from array 
     unset($words[$key]); 
     //if it still exists in the array it must be duplicated 
     if (in_array($word, $words)) { 
      return false; 
     } 
    } 
    return true; 
} 

Modifier

de Correction d'un problème avec plusieurs espaces. Je ne suis pas sûr s'il est préférable de les supprimer au début (comme je l'ai fait) ou de vérifier que chaque mot est non vide dans le foreach.

Answer 8

Pas besoin de boucles ou de tableaux:

<?php 

$needle = 'cat'; 
$haystack = 'cat in the cat hat'; 

if (occursMoreThanOnce($haystack, $needle)) { 
    echo 'Success'; 
} 

function occursMoreThanOnce($haystack, $needle) { 
    return strpos($haystack, $needle) !== strrpos($haystack, $needle); 
} 

?> 

Answer 9

La façon d'expression régulière serait certainement mon choix.

J'ai fait un petit test sur une chaîne de 320 mots avec la fonction de Veynom et une expression régulière

function preg($txt) { 
    return !preg_match('/\b(\w+)\b.*?\1/', $txt); 
} 

est ici le test

$time['preg'] = microtime(true); 

for($i = 0; $i < 1000; $i++) { 
    preg($txt); 
} 

$time['preg'] = microtime(true) - $time['preg']; 


$time['veynom-thewickedflea'] = microtime(true); 

for($i = 0; $i < 1000; $i++) { 
    single_use_of_words($txt); 
} 

$time['veynom-thewickedflea'] = microtime(true) - $time['veynom-thewickedflea']; 

print_r($time); 

Et voici le résultat que je suis

Array 
(
    [preg] => 0.197616815567 
    [veynom-thewickedflea] => 0.487532138824 
) 

Ce qui suggère que la solution RegExp, tout en étant beaucoup plus concis, est plus de deux fois plus vite. (Pour une chaîne de 320 mots 1000 itérations) anr

Quand je lance le test de plus de 10 000 itérations je reçois

Array 
(
    [preg] => 1.51235699654 
    [veynom-thewickedflea] => 4.99487900734 
) 

La solution non RegExp utilise aussi beaucoup plus de mémoire.

So .. expressions régulières pour moi cos ils ont un réservoir plein de gaz

EDIT
Le texte que je teste contre a des mots en double, Dans le cas contraire, les résultats peuvent être différents . Je posterai un autre ensemble de résultats.

Mise à jour
Avec les doublons dépouillé (maintenant 186 mots) les résultats pour 1000 itérations est:

Array 
(
    [preg] => 0.235826015472 
    [veynom-thewickedflea] => 0.2528860569 
) 

A propos Evens