859. Buddy Strings

LeetCode easy оригинал: C# #array #csharp #easy #leetcode #string

LeetCode Static

Даны две строки s и goal. Верните true, если вы можете поменять местами две буквы в s так, чтобы результат был равен goal, в противном случае верните false.

Обмен буквами определяется как взятие двух индексов i и j (нумерация с 0), таких что i != j, и обмен символов в s[i] и s[j].

Например, обмен символов на индексах 0 и 2 в строке "abcd" приводит к "cbad".

Пример:

Input: s = "ab", goal = "ba"

Output: true

Explanation: You can swap s[0] = 'a' and s[1] = 'b' to get "ba", which is equal to goal.

C# решение

сопоставлено/оригинал

public class Solution {
    public bool BuddyStrings(string s, string goal) {
        if (s.Length != goal.Length) return false;
        if (s == goal) {
            var freq = new int[26];
            foreach (var ch in s) {
                if (++freq[ch - 'a'] > 1) return true;
            }
            return false;
        }
        int firstIndex = -1, secondIndex = -1;
        for (int i = 0; i < s.Length; ++i) {
            if (s[i] != goal[i]) {
                if (firstIndex == -1) firstIndex = i;
                else if (secondIndex == -1) secondIndex = i;
                else return false;
            }
        }
        return secondIndex != -1 &&
               s[firstIndex] == goal[secondIndex] &&
               s[secondIndex] == goal[firstIndex];
    }
}

C++ решение

auto-draft, проверить перед отправкой

#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 BuddyStrings(string s, string goal) {
        if (s.size() != goal.size()) return false;
        if (s == goal) {
            var freq = new int[26];
            foreach (var ch in s) {
                if (++freq[ch - 'a'] > 1) return true;
            }
            return false;
        }
        int firstIndex = -1, secondIndex = -1;
        for (int i = 0; i < s.size(); ++i) {
            if (s[i] != goal[i]) {
                if (firstIndex == -1) firstIndex = i;
                else if (secondIndex == -1) secondIndex = i;
                else return false;
            }
        }
        return secondIndex != -1 &&
               s[firstIndex] == goal[secondIndex] &&
               s[secondIndex] == goal[firstIndex];
    }
}

Java решение

сопоставлено/оригинал

class Solution {
    public boolean buddyStrings(String s, String goal) {
        if (s.length() != goal.length()) return false;
        if (s.equals(goal)) {
            int[] freq = new int[26];
            for (char ch : s.toCharArray()) {
                if (++freq[ch - 'a'] > 1) return true;
            }
            return false;
        }

        int firstIndex = -1, secondIndex = -1;
        for (int i = 0; i < s.length(); ++i) {
            if (s.charAt(i) != goal.charAt(i)) {
                if (firstIndex == -1) firstIndex = i;
                else if (secondIndex == -1) secondIndex = i;
                else return false;
            }
        }

        return secondIndex != -1 &&
               s.charAt(firstIndex) == goal.charAt(secondIndex) &&
               s.charAt(secondIndex) == goal.charAt(firstIndex);
    }
}

JavaScript решение

сопоставлено/оригинал

var buddyStrings = function(s, goal) {
    if (s.length !== goal.length) return false;
    if (s === goal) {
        const freq = new Map();
        for (const ch of s) {
            if (freq.has(ch)) return true;
            freq.set(ch, 1);
        }
        return false;
    }

    let firstIndex = -1, secondIndex = -1;
    for (let i = 0; i < s.length; ++i) {
        if (s[i] !== goal[i]) {
            if (firstIndex === -1) firstIndex = i;
            else if (secondIndex === -1) secondIndex = i;
            else return false;
        }
    }

    return secondIndex !== -1 &&
           s[firstIndex] === goal[secondIndex] &&
           s[secondIndex] === goal[firstIndex];
};

Python решение

сопоставлено/оригинал

class Solution:
    def buddyStrings(self, s: str, goal: str) -> bool:
        if len(s) != len(goal):
            return False
        if s == goal:
            freq = {}
            for ch in s:
                if ch in freq:
                    return True
                freq[ch] = 1
            return False

        firstIndex = -1
        secondIndex = -1
        for i in range(len(s)):
            if s[i] != goal[i]:
                if firstIndex == -1:
                    firstIndex = i
                elif secondIndex == -1:
                    secondIndex = i
                else:
                    return False

        return secondIndex != -1 and \
               s[firstIndex] == goal[secondIndex] and \
               s[secondIndex] == goal[firstIndex]

Go решение

сопоставлено/оригинал

func buddyStrings(s string, goal string) bool {
    if len(s) != len(goal) {
        return false
    }
    if s == goal {
        freq := make(map[rune]int)
        for _, ch := range s {
            freq[ch]++
            if freq[ch] > 1 {
                return true
            }
        }
        return false
    }

    firstIndex, secondIndex := -1, -1
    for i := range s {
        if s[i] != goal[i] {
            if firstIndex == -1 {
                firstIndex = i
            } else if secondIndex == -1 {
                secondIndex = i
            } else {
                return false
            }
        }
    }

    return secondIndex != -1 &&
           s[firstIndex] == goal[secondIndex] &&
           s[secondIndex] == goal[firstIndex]
}

Algorithm

Если количество символов в строках s и goal разное, возвращаем false. Если s == goal, используем хеш-таблицу или массив из 26 элементов для хранения частоты каждого символа в строке s. Если какой-либо символ встречается более одного раза, можно поменять местами две одинаковые буквы, возвращаем true. Иначе возвращаем false.

Иначе, если s != goal, инициализируем firstIndex и secondIndex значениями -1 для хранения индексов символов в строке s, которые отличаются от символов в строке goal на тех же индексах. Итерируем по каждому индексу i в строке s: если символы s[i] и goal[i] разные, сохраняем текущий индекс. Если firstIndex == -1, обновляем firstIndex = i. Если firstIndex != -1, но secondIndex == -1, обновляем secondIndex = i. Если оба индекса уже обновлены, возвращаем false.

Если обновлен только firstIndex, возвращаем false. Иначе, все символы обеих строк одинаковы, кроме двух индексов. Поэтому s[firstIndex] должен быть равен goal[secondIndex], и s[secondIndex] должен быть равен goal[firstIndex], чтобы строки стали равны после обмена.

😎

Вакансии для этой задачи

Показаны активные вакансии с пересечением по тегам задачи.

Все вакансии

Активных вакансий пока нет.