2085. 统计出现过一次的公共字符串

2085. 统计出现过一次的公共字符串

给你两个字符串数组 words1 和 words2 ，请你返回在两个字符串数组中 都恰好出现一次 的字符串的数目。

示例

示例 1

输入：words1 = ["leetcode","is","amazing","as","is"], words2 = ["amazing","leetcode","is"]

输出：2

解释：

• "leetcode" 在两个数组中都恰好出现一次，计入答案。
• "amazing" 在两个数组中都恰好出现一次，计入答案。
• "is" 在两个数组中都出现过，但在 words1 中出现了 2 次，不计入答案。
• "as" 在 words1 中出现了一次，但是在 words2 中没有出现过，不计入答案。

所以，有 2 个字符串在两个数组中都恰好出现了一次。

示例 2

输入：words1 = ["b","bb","bbb"], words2 = ["a","aa","aaa"]

输出：0

解释：没有字符串在两个数组中都恰好出现一次。

示例 3

输入：words1 = ["a","ab"], words2 = ["a","a","a","ab"]

输出：1

解释：唯一在两个数组中都出现一次的字符串是 "ab" 。

提示

1. 1 <= words1.length, words2.length <= 1000
2. 1 <= words1[i].length, words2[j].length <= 30
3. words1[i] 和 words2[j] 都只包含小写英文字母。

代码

javascript

// 2085. 统计出现过一次的公共字符串
// https://leetcode.cn/problems/count-common-words-with-one-occurrence/description/

export function countWords (words1, words2) {
  const arrayToObject = (arr) => {
    const res = {}
    arr.forEach(element => {
      res[element] = (res[element] || 0) + 1
    });
    return res
  }
  const wObj1 = arrayToObject(words1)
  const wObj2 = arrayToObject(words2)
  const minLength = Math.min(words1.length, words2.length)
  const resArr = words1.length === minLength ? words1 : words2
  let res = 0
  resArr.forEach(key => {
    if (wObj1[key] === 1 && wObj2[key] === 1) {
      res++
    }
  })
  return res
};

// map实现
export function countWordsMap (words1, words2) {
  const arrayToMap = (arr) => {
    const res = new Map()
    arr.forEach(element => {
      res.set(element, (res.get(element) || 0) + 1)
    });
    return res
  }
  const wMap1 = arrayToMap(words1)
  const wMap2 = arrayToMap(words2)
  const minLength = Math.min(words1.length, words2.length)
  const resMap = words1.length === minLength ? wMap1 : wMap2
  const othMap = words1.length === minLength ? wMap2 : wMap1
  let res = 0
  for (const [key, value] of resMap) {
    if (value === 1 && othMap.get(key) === 1) {
      res++
    }
  }
  return res
};

typescript

// 2085. 统计出现过一次的公共字符串
// https://leetcode.cn/problems/count-common-words-with-one-occurrence/description/

export function countWords (words1: string[], words2: string[]): number {
  interface ObjNumber { 
    [propName: string]: number;
  }

  const arrayToObject = (arr: string[]): ObjNumber => {
    const res: ObjNumber = {}
    arr.forEach(element => {
      res[element] = (res[element] || 0) + 1
    });
    return res
  }
  const wObj1: ObjNumber = arrayToObject(words1)
  const wObj2: ObjNumber = arrayToObject(words2)
  const minLength = Math.min(words1.length, words2.length)
  const resArr = words1.length === minLength ? words1 : words2
  let res = 0
  resArr.forEach(key => {
    if (wObj1[key] === 1 && wObj2[key] === 1) {
      res++
    }
  })
  return res
};

// map实现
export function countWordsMap (words1: string[], words2: string[]): number {
  const arrayToMap = (arr: string[]): Map<string, number> => {
    const res: Map<string, number> = new Map()
    arr.forEach(element => {
      res.set(element, (res.get(element) || 0) + 1)
    });
    return res
  }
  const wMap1 = arrayToMap(words1)
  const wMap2 = arrayToMap(words2)
  const minLength = Math.min(words1.length, words2.length)
  const resMap = words1.length === minLength ? wMap1 : wMap2
  const othMap = words1.length === minLength ? wMap2 : wMap1
  let res = 0
  for (const [key, value] of resMap) {
    if (value === 1 && othMap.get(key) === 1) {
      res++
    }
  }
  return res
};

测试代码

test

import { expect, test } from 'vitest'
import { countWords, countWordsMap } from './typescript.ts'
import { countWords as countWordsJs, countWordsMap as countWordsMapJs } from './javascript.js'

const words1 = ["leetcode","is","amazing","as","is"]
const words2 = ["amazing","leetcode","is"]

const words3 = ["b","bb","bbb"]
const words4 = ["a","aa","aaa"]

const words5 = ["a","ab"]
const words6 = ["a","a","a","ab"]

test(`countWords(words1, words2) toBe 2`, () => {
  expect(countWords(words1, words2)).toBe(2)
})

test(`countWordsJs(words1, words2) toBe 2`, () => {
  expect(countWordsJs(words1, words2)).toBe(2)
})


test(`countWords(words3, words4) toBe 0`, () => {
  expect(countWords(words3, words4)).toBe(0)
})

test(`countWordsJs(words3, words4) toBe 0`, () => {
  expect(countWordsJs(words3, words4)).toBe(0)
})


test(`countWords(words5, words6) toBe 1`, () => {
  expect(countWords(words5, words6)).toBe(1)
})

test(`countWordsJs(words5, words6) toBe 1`, () => {
  expect(countWordsJs(words5, words6)).toBe(1)
})


test(`countWordsMap(words1, words2) toBe 2`, () => {
  expect(countWordsMap(words1, words2)).toBe(2)
})

test(`countWordsMapJs(words1, words2) toBe 2`, () => {
  expect(countWordsMapJs(words1, words2)).toBe(2)
})


test(`countWordsMap(words3, words4) toBe 0`, () => {
  expect(countWordsMap(words3, words4)).toBe(0)
})

test(`countWordsMapJs(words3, words4) toBe 0`, () => {
  expect(countWordsMapJs(words3, words4)).toBe(0)
})


test(`countWordsMap(words5, words6) toBe 1`, () => {
  expect(countWordsMap(words5, words6)).toBe(1)
})

test(`countWordsMapJs(words5, words6) toBe 1`, () => {
  expect(countWordsMapJs(words5, words6)).toBe(1)
})