Hash Table
String
Description
A sentence is a string of single-space separated words where each word consists only of lowercase letters.
A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.
Given two sentences s1
and s2
, return a list of all the uncommon words . You may return the answer in any order .
Example 1:
Input: s1 = "this apple is sweet", s2 = "this apple is sour"
Output: ["sweet","sour"]
Example 2:
Input: s1 = "apple apple", s2 = "banana"
Output: ["banana"]
Constraints:
1 <= s1.length, s2.length <= 200
s1
and s2
consist of lowercase English letters and spaces.
s1
and s2
do not have leading or trailing spaces.
All the words in s1
and s2
are separated by a single space.
Solutions
Solution 1: Hash Table
According to the problem description, as long as a word appears once, it meets the requirements of the problem. Therefore, we use a hash table cnt
to record all words and their occurrence counts.
Then we traverse the hash table, and take out all strings that appear only once.
The time complexity is $O(m + n)$, and the space complexity is $O(m + n)$. Here, $m$ and $n$ are the lengths of strings s1
and s2
, respectively.
Python3 Java C++ Go TypeScript Rust JavaScript
class Solution :
def uncommonFromSentences ( self , s1 : str , s2 : str ) -> List [ str ]:
cnt = Counter ( s1 . split ()) + Counter ( s2 . split ())
return [ s for s , v in cnt . items () if v == 1 ]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 class Solution {
public String [] uncommonFromSentences ( String s1 , String s2 ) {
Map < String , Integer > cnt = new HashMap <> ();
for ( String s : s1 . split ( " " )) {
cnt . merge ( s , 1 , Integer :: sum );
}
for ( String s : s2 . split ( " " )) {
cnt . merge ( s , 1 , Integer :: sum );
}
List < String > ans = new ArrayList <> ();
for ( var e : cnt . entrySet ()) {
if ( e . getValue () == 1 ) {
ans . add ( e . getKey ());
}
}
return ans . toArray ( new String [ 0 ] );
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 class Solution {
public :
vector < string > uncommonFromSentences ( string s1 , string s2 ) {
unordered_map < string , int > cnt ;
auto add = [ & ]( string & s ) {
stringstream ss ( s );
string w ;
while ( ss >> w ) ++ cnt [ move ( w )];
};
add ( s1 );
add ( s2 );
vector < string > ans ;
for ( auto & [ s , v ] : cnt )
if ( v == 1 ) ans . emplace_back ( s );
return ans ;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 func uncommonFromSentences ( s1 string , s2 string ) ( ans [] string ) {
cnt := map [ string ] int {}
for _ , s := range strings . Split ( s1 , " " ) {
cnt [ s ] ++
}
for _ , s := range strings . Split ( s2 , " " ) {
cnt [ s ] ++
}
for s , v := range cnt {
if v == 1 {
ans = append ( ans , s )
}
}
return
}
1
2
3
4
5
6
7
8
9
10
11
12
13 function uncommonFromSentences ( s1 : string , s2 : string ) : string [] {
const cnt : Map < string , number > = new Map ();
for ( const s of [... s1 . split ( ' ' ), ... s2 . split ( ' ' )]) {
cnt . set ( s , ( cnt . get ( s ) || 0 ) + 1 );
}
const ans : Array < string > = [];
for ( const [ s , v ] of cnt . entries ()) {
if ( v == 1 ) {
ans . push ( s );
}
}
return ans ;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 use std :: collections :: HashMap ;
impl Solution {
pub fn uncommon_from_sentences ( s1 : String , s2 : String ) -> Vec < String > {
let mut map = HashMap :: new ();
for s in s1 . split ( ' ' ) {
map . insert ( s , ! map . contains_key ( s ));
}
for s in s2 . split ( ' ' ) {
map . insert ( s , ! map . contains_key ( s ));
}
let mut res = Vec :: new ();
for ( k , v ) in map {
if v {
res . push ( String :: from ( k ));
}
}
res
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 /**
* @param {string} s1
* @param {string} s2
* @return {string[]}
*/
var uncommonFromSentences = function ( s1 , s2 ) {
const cnt = new Map ();
for ( const s of [... s1 . split ( ' ' ), ... s2 . split ( ' ' )]) {
cnt . set ( s , ( cnt . get ( s ) || 0 ) + 1 );
}
const ans = [];
for ( const [ s , v ] of cnt . entries ()) {
if ( v == 1 ) {
ans . push ( s );
}
}
return ans ;
};