Решение: неоднозначные координаты

Это является частью серии объяснений решения LeetCode ( index ). Если вам понравилось это решение или нашел его полезным, Пожалуйста, как этот пост и/или УПОТАТЬ Мое решение пост на форумах LeetCode Отказ

Проблема летекода # 816 (средний): неоднозначные координаты

Описание:

( Перейти к : Идея решения Код : JavaScript | Python |. Java |. C ++

У нас были некоторые двумерные координаты, такие как "(1, 3)" или "(2, 0,5)" Отказ Затем мы удалили все запятые, десятичные точки и пробелы и в итоге со строкой S Отказ Верните список строк, представляющих все возможности для того, что могут быть наши оригинальные координаты.

Наше первоначальное представление никогда не имело посторонних нулей, поэтому мы никогда не начали с номерами, как "00" , "0.0" , "0,00" , "1.0" , "001" , "00.01" или любое другое число, которое можно представить с меньшими цифрами. Кроме того, десятичная точка в пределах числа никогда не возникает без по меньшей мере одной цифры, возникающей до нее, поэтому мы никогда не начали с такого типа ".1" Отказ

Окончательный список ответов может быть возвращен в любом порядке. Также обратите внимание, что все координаты в окончательном ответе имеют ровно одно пространство между ними (происходящим после запятой.)

Примеры:

Ограничения:

• 4 длиной
• s [0] , s [s.length - и другие элементы в S цифры.

Идея:

( Перейти к : Описание проблемы Код : JavaScript | Python |. Java |. C ++

Для этой проблемы у нас есть две основные проблемы. Первая задача предотвращает недействительные координаты. Для этого мы можем определить функцию помощника ( Parse ), который займет строку ( str ) и пропускает только на действительные варианты для другого помощника ( процесс ) для обработки.

Мы можем сломать параметры на три категории:

• Нет десятичных : Любой вариант, кроме одного с более чем 1 цифра и ведущий “0” Отказ
• Десятичная после первой цифры : Любой вариант с более чем 1 цифра и без трейлинга “0” Отказ
• Десятичные дроби на всей территории : Любой вариант, который не запускается и заканчивается “0”

После определения нашей первой функции помощника следующая вещь, которую мы должны сделать, – это проиграть, – это проиграть возможные запятыми на нашей входной строке ( S ) и отделите строки сопряжения координат ( XSTR, YSTR ).

Затем мы столкнемся во второй задаче, что следует избегать повторения той же обработки. Если бы мы использовали простой вложенный цикл или рекурсивную функцию, чтобы решить эту проблему, она в конечном итоге утомила одинаковые процессы, поскольку оба координата могут иметь десятичную.

Что мы на самом деле хочем, это продукт двух петель. Основное решение было бы создание двух массивов и итерации через их комбинации, но на самом деле нет необходимости на самом деле создавать второй массив, поскольку мы можем так же легко обрабатывать комбинации, пока мы повторяемся через вторую координату естественным путем.

Таким образом, мы должны сначала построить и подтвердить все десятичные варианты для XSTR данной запятой должности и хранить действительные возможности в массиве ( XPoss ). Как только это завершено, мы должны найти каждую действительный десятичный вариант для YSTR Сочетайте его с каждым значением в xposs И добавьте результаты к нашему массиву ответа ( ANS ) Перед переходом на следующую запятую.

Чтобы помочь в этом, мы можем определить процесс , который будет хранить действительные десятичные параметры из XSTR в xposs или объединить действительные десятичные варианты из YSTR С содержимым xposs и хранить результаты в АНС В зависимости от какой строки координаты в настоящее время мы находимся ( XY ).

Как только мы закончим итерацию через все позиции запятыми, мы можем Вернуть АНС Отказ

Код JavaScript:

( Перейти к : Описание проблемы Идея решения

var ambiguousCoordinates = function(S) {
    let ans = [], xPoss
    const process = (str, xy) => {
        if (xy)
            for (let x of xPoss)
                ans.push(`(${x}, ${str})`)
        else xPoss.push(str)
    }
    const parse = (str, xy) => {
        if (str.length === 1 || str[0] !== "0")
            process(str, xy)
        if (str.length > 1 && str[str.length-1] !== "0")
            process(str.slice(0,1) + "." + str.slice(1), xy)
        if (str.length > 2 && str[0] !== "0" && str[str.length-1] !== "0")
            for (let i = 2; i < str.length; i++)
                process(str.slice(0,i) + "." + str.slice(i), xy)
    }
    for (let i = 2; i < S.length - 1; i++) {
        let strs = [S.slice(1,i), S.slice(i, S.length - 1)]
        xPoss = []
        for (let j = 0; j < 2; j++)
            if (xPoss.length || !j) parse(strs[j], j)
    }
    return ans
};

Код Python:

( Перейти к : Описание проблемы Идея решения

class Solution:
    def ambiguousCoordinates(self, S: str) -> List[str]:
        ans, xPoss = [], []
        def process(st: str, xy: int):
            if xy:
                for x in xPoss:
                    ans.append("(" + x + ", " + st + ")")
            else: xPoss.append(st)
        def parse(st: str, xy: int):
            if len(st) == 1 or st[0] != "0":
                process(st, xy)
            if len(st) > 1 and st[-1] != "0":
                process(st[:1] + "." + st[1:], xy)
            if len(st) > 2 and st[0] != "0" and st[-1] != "0":
                for i in range(2, len(st)):
                    process(st[:i] + "." + st[i:], xy)  
        for i in range(2, len(S)-1):
            strs, xPoss = [S[1:i], S[i:-1]], []
            for j in range(2):
                if xPoss or not j: parse(strs[j], j)
        return ans

Java код:

( Перейти к : Описание проблемы Идея решения

class Solution {
    private List xPoss, ans;
    public List ambiguousCoordinates(String S) {
        ans = new ArrayList<>();
        for (int i = 2; i < S.length() - 1; i++) {
            String[] strs = {S.substring(1,i), S.substring(i, S.length() - 1)};
            xPoss = new ArrayList<>();
            for (int j = 0; j < 2; j++)
                if (xPoss.size() > 0 || j == 0) parse(strs[j], j);
        }
        return ans;
    }
    private void parse(String str, int xy) {
        if (str.length() == 1 || str.charAt(0) != '0')
            process(str, xy);
        if (str.length() > 1 && str.charAt(str.length()-1) != '0')
            process(str.substring(0,1) + "." + str.substring(1), xy);
        if (str.length() > 2 && str.charAt(0) != '0' && str.charAt(str.length()-1) != '0')
            for (int i = 2; i < str.length(); i++)
                process(str.substring(0,i) + "." + str.substring(i), xy);
    }
    private void process(String str, int xy) {
        if (xy > 0)
            for (String x : xPoss)
                ans.add("(" + x + ", " + str + ")");
        else xPoss.add(str);
    }
}

C ++ код:

( Перейти к : Описание проблемы Идея решения

class Solution {
public:
    vector ambiguousCoordinates(string S) {
        for (int i = 2; i < S.size() - 1; i++) {
            string strs[2] = {S.substr(1,i-1), S.substr(i,S.size()-i-1)};
            xPoss.clear();
            for (int j = 0; j < 2; j++)
                if (xPoss.size() > 0 || j == 0) parse(strs[j], j);
        }
        return ans;
    }
private:
    vector ans, xPoss;
    void parse(string str, int xy) {
        if (str.size() == 1 || str.front() != '0')
            process(str, xy);
        if (str.size() > 1 && str.back() != '0')
            process(str.substr(0,1) + "." + str.substr(1), xy);
        if (str.size() > 2 && str.front() != '0' && str.back() != '0')
            for (int i = 2; i < str.size(); i++)
                process(str.substr(0,i) + "." + str.substr(i), xy);
    }
    void process(string str, int xy) {
        if (xy)
            for (auto x : xPoss)
                ans.push_back("(" + x + ", " + str + ")");
        else xPoss.push_back(str);
    }
};

Оригинал: “https://dev.to/seanpgallivan/solution-ambiguous-coordinates-5h03”