439. Ternary Expression Parser

public class Solution {
    public string ParseTernary(string expression) {
        bool IsValidAtomic(string s) {
            return (s[0] == 'T' || s[0] == 'F') &&
                   s[1] == '?' &&
                   ("TF0123456789".Contains(s[2])) &&
                   s[3] == ':' &&
                   ("TF0123456789".Contains(s[4]));
        }
        char SolveAtomic(string s) {
            return s[0] == 'T' ? s[2] : s[4];
        }
        while (expression.Length != 1) {
            int j = expression.Length - 1;
            while (!IsValidAtomic(expression.Substring(j-4, 5))) {
                j -= 1;
            }
            expression = expression.Substring(0, j-4) + SolveAtomic(expression.Substring(j-4, 5)) + expression.Substring(j+1);
        }
        return expression;
    }
}

#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 string ParseTernary(string expression) {
        bool IsValidAtomic(string s) {
            return (s[0] == 'T' || s[0] == 'F') &&
                   s[1] == '?' &&
                   ("TF0123456789".Contains(s[2])) &&
                   s[3] == ':' &&
                   ("TF0123456789".Contains(s[4]));
        }
        char SolveAtomic(string s) {
            return s[0] == 'T' ? s[2] : s[4];
        }
        while (expression.size() != 1) {
            int j = expression.size() - 1;
            while (!IsValidAtomic(expression.Substring(j-4, 5))) {
                j -= 1;
            }
            expression = expression.Substring(0, j-4) + SolveAtomic(expression.Substring(j-4, 5)) + expression.Substring(j+1);
        }
        return expression;
    }
}

class Solution {
    public String parseTernary(String expression) {
        boolean isValidAtomic(String s) {
            return s.charAt(0) == 'T' || s.charAt(0) == 'F' &&
                   s.charAt(1) == '?' &&
                   "TF0123456789".indexOf(s.charAt(2)) != -1 &&
                   s.charAt(3) == ':' &&
                   "TF0123456789".indexOf(s.charAt(4)) != -1;
        }

        char solveAtomic(String s) {
            return s.charAt(0) == 'T' ? s.charAt(2) : s.charAt(4);
        }

        while (expression.length() != 1) {
            int j = expression.length() - 1;
            while (!isValidAtomic(expression.substring(j-4, j+1))) {
                j -= 1;
            }
            expression = expression.substring(0, j-4) + solveAtomic(expression.substring(j-4, j+1)) + expression.substring(j+1);
        }

        return expression;
    }
}

var parseTernary = function(expression) {
    const isValidAtomic = (s) => {
        return (s[0] === 'T' || s[0] === 'F') &&
               s[1] === '?' &&
               'TF0123456789'.includes(s[2]) &&
               s[3] === ':' &&
               'TF0123456789'.includes(s[4]);
    };

    const solveAtomic = (s) => {
        return s[0] === 'T' ? s[2] : s[4];
    };

    while (expression.length !== 1) {
        let j = expression.length - 1;
        while (!isValidAtomic(expression.substring(j-4, j+1))) {
            j -= 1;
        }
        expression = expression.substring(0, j-4) + solveAtomic(expression.substring(j-4, j+1)) + expression.substring(j+1);
    }

    return expression;
};

class Solution:
    def parseTernary(self, expression: str) -> str:
        def isValidAtomic(s):
            return s[0] in 'TF' and s[1] == '?' and s[2] in 'TF0123456789' and s[3] == ':' and s[4] in 'TF0123456789'
        
        def solveAtomic(s):
            return s[2] if s[0] == 'T' else s[4]

        while len(expression) != 1:
            j = len(expression) - 1
            while not isValidAtomic(expression[j-4:j+1]):
                j -= 1
            expression = expression[:j-4] + solveAtomic(expression[j-4:j+1]) + expression[j+1:]

        return expression

func parseTernary(expression string) string {
    isValidAtomic := func(s string) bool {
        return (s[0] == 'T' || s[0] == 'F') &&
               s[1] == '?' &&
               (strings.Contains("TF0123456789", string(s[2]))) &&
               s[3] == ':' &&
               (strings.Contains("TF0123456789", string(s[4])))
    }

    solveAtomic := func(s string) byte {
        if s[0] == 'T' {
            return s[2]
        }
        return s[4]
    }

    for len(expression) != 1 {
        j := len(expression) - 1
        for !isValidAtomic(expression[j-4:j+1]) {
            j -= 1
        }
        expression = expression[:j-4] + string(solveAtomic(expression[j-4:j+1])) + expression[j+1:]
    }

    return expression
}

Algorithm

Определите вспомогательную функцию isValidAtomic(s), которая принимает строку s и returns True, если s является допустимым атомарным выражением. В противном случае функция returns False. Функция будет вызываться только с пятисимвольными Zeichenketteми. Если все следующие условия выполнены, функция returns True, иначе - False: s[0] является T или F. s[1] является ?. s[2] является T, F или цифрой от 0 до 9. s[3] является :. s[4] является T, F или цифрой от 0 до 9.

Определите вспомогательную функцию solveAtomic(s), которая принимает строку s и returns значение атомарного выражения. Значение атомарного выражения равно E1, если B - это T, иначе значение равно E2. Функция будет вызываться только с пятисимвольными Zeichenketteми и возвращать один символ:.

Если s[0] является T, функция returns s[2], иначе returns s[4]. В функции parseTernary(expression) уменьшайте выражение до тех пор, пока не останется односимвольная Zeichenkette. Инициализируйте j как expression.size() - 1 (это будет самый правый индекс окна). Пока самое правое окно длиной 5 не является допустимым атомарным выражением, уменьшайте j на 1. Когда будет найдено самое правое допустимое атомарное выражение, решите его и уменьшите до одного символа. Замените самое правое допустимое атомарное выражение одним символом, после чего длина выражения уменьшится на 4. В итоге останется односимвольная Zeichenkette, которую и return.

😎