290. Word Pattern

LeetCode easy original: C# #csharp #easy #hash-table #leetcode #string

Der Aufgabentext wird für die gewählte Sprache aus dem Russischen übersetzt. Code bleibt unverändert.

LeetCode Static

Дан шаблон и Zeichenkette s, необходимо определить, следует ли Zeichenkette s этому шаблону.

Здесь "следует" означает полное соответствие, такое что существует биекция между буквой в шаблоне и непустым словом в строке s.

Beispiel:

Input: pattern = "abba", s = "dog cat cat dog"

Output: true

C# Lösung

zugeordnet/original

using System;
using System.Collections.Generic;
public class Solution {
    public bool WordPattern(string pattern, string s) {
        var mapChar = new Dictionary<char, string>();
        var mapWord = new Dictionary<string, char>();
        var words = s.Split(new char[] { ' ' });
        if (words.Length != pattern.Length) {
            return false;
        }
        for (int i = 0; i < pattern.Length; i++) {
            char c = pattern[i];
            string w = words[i];
            if (!mapChar.ContainsKey(c)) {
                if (mapWord.ContainsKey(w)) {
                    return false;
                } else {
                    mapChar[c] = w;
                    mapWord[w] = c;
                }
            } else {
                if (mapChar[c] != w) {
                    return false;
                }
            }
        }
        return true;
    }
}

C++ Lösung

Auto-Entwurf, vor dem Einreichen prüfen

#include <bits/stdc++.h>
using namespace std;

// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
    public bool WordPattern(string pattern, string s) {
        var mapChar = new unordered_map<char, string>();
        var mapWord = new unordered_map<string, char>();
        var words = s.Split(new char[] { ' ' });
        if (words.size() != pattern.size()) {
            return false;
        }
        for (int i = 0; i < pattern.size(); i++) {
            char c = pattern[i];
            string w = words[i];
            if (!mapChar.count(c)) {
                if (mapWord.count(w)) {
                    return false;
                } else {
                    mapChar[c] = w;
                    mapWord[w] = c;
                }
            } else {
                if (mapChar[c] != w) {
                    return false;
                }
            }
        }
        return true;
    }
}

Java Lösung

zugeordnet/original

import java.util.HashMap;

public class Solution {
    public boolean wordPattern(String pattern, String s) {
        HashMap<Character, String> mapChar = new HashMap<>();
        HashMap<String, Character> mapWord = new HashMap<>();
        String[] words = s.split(" ");

        if (words.length != pattern.length()) {
            return false;
        }

        for (int i = 0; i < pattern.length(); i++) {
            char c = pattern.charAt(i);
            String w = words[i];
            if (!mapChar.containsKey(c)) {
                if (mapWord.containsKey(w)) {
                    return false;
                } else {
                    mapChar.put(c, w);
                    mapWord.put(w, c);
                }
            } else {
                if (!mapChar.get(c).equals(w)) {
                    return false;
                }
            }
        }

        return true;
    }
}

JavaScript Lösung

zugeordnet/original

class Solution {
    wordPattern(pattern, s) {
        const mapChar = new Map();
        const mapWord = new Map();
        const words = s.split(" ");

        if (words.length !== pattern.length) {
            return false;
        }

        for (let i = 0; i < pattern.length; i++) {
            const c = pattern[i];
            const w = words[i];
            if (!mapChar.has(c)) {
                if (mapWord.has(w)) {
                    return false;
                } else {
                    mapChar.set(c, w);
                    mapWord.set(w, c);
                }
            } else {
                if (mapChar.get(c) !== w) {
                    return false;
                }
            }
        }

        return true;
    }
}

Python Lösung

zugeordnet/original

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        map_char = {}
        map_word = {}
        words = s.split()

        if len(words) != len(pattern):
            return False

        for c, w in zip(pattern, words):
            if c not in map_char:
                if w in map_word:
                    return False
                else:
                    map_char[c] = w
                    map_word[w] = c
            else:
                if map_char[c] != w:
                    return False

        return True

Go Lösung

zugeordnet/original

package main

import (
    "strings"
)

func wordPattern(pattern string, s string) bool {
    mapChar := make(map[rune]string)
    mapWord := make(map[string]rune)
    words := strings.Split(s, " ")

    if len(words) != len(pattern) {
        return false
    }

    for i, c := range pattern {
        w := words[i]
        if _, ok := mapChar[c]; !ok {
            if _, ok := mapWord[w]; ok {
                return false
            } else {
                mapChar[c] = w
                mapWord[w] = c
            }
        } else {
            if mapChar[c] != w {
                return false
            }
        }
    }

    return true
}

Algorithm

Разделение строки на слова:

Разделите строку s на отдельные слова.

Если количество слов не равно длине шаблона, возвращаем false.

Создание отображений:

Создайте два словаря: один для отображения букв шаблона на слова, другой для слов на буквы шаблона.

Проверка биекции:

Пройдите по каждому символу шаблона и соответствующему слову.

Если символ уже в словаре и не соответствует текущему слову или слово уже в словаре и не соответствует текущему символу, возвращаем false.

Иначе добавляем символ и слово в словари и продолжаем проверку. Если все проверки пройдены, возвращаем true.

😎

Stellen zu dieser Aufgabe

aktive Stellen with overlapping task tags are angezeigt.

Alle Stellen

Es gibt noch keine aktiven Stellen.