Início / coding / Perguntas / 77921119
Accepted
Fred Hors
Asked: 2024-02-01 22:46:14 +0800 CST

Existe uma maneira de corrigir esse código ou devo pedir para alterar a estrutura de dados?

  • 772

Estou enlouquecendo com isso (porque não sou uma pessoa muito lógica).

Ferrugem Parque Infantil

Não consigo alterar a parte dos dados.

A string retornada do código abaixo é A = 1 AND (B = 2 OR C = 3 OR D = 4 OR )o que eu preciso ( A = 1 AND (B = 2 OR C = 3 OR D = 4)).

O que não entendo é como evitar o último “OU”.

Como posso corrigir o código abaixo?

enum Token {
    Str(&'static str),
    Value(&'static str),
    StartGroup(&'static str),
    EndGroup,
}

fn main() {
    let data: Vec<Vec<Token>> = vec![
        vec![Token::Str("A = "), Token::Value("1")],
        vec![Token::Str(" AND ("), Token::StartGroup(" OR ")],
        vec![Token::Str("B = "), Token::Value("2")],
        vec![Token::Str("C = "), Token::Value("3")],
        vec![Token::Str("D = "), Token::Value("4")],
        vec![Token::EndGroup, Token::Str(")")],
    ];

    let result = construct_string(data);

    assert_eq!("A = 1 AND (B = 2 OR C = 3 OR D = 4)", result);
}

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();

    let mut current = String::new();
    let mut next = String::new();

    for token in tokens {
        for part in token {
            match part {
                Token::Str(str) => {
                    result.push_str(str);
                }
                Token::Value(val) => {
                    result.push_str(val);
                }
                Token::StartGroup(group) => {
                    next = group.to_string();
                }
                Token::EndGroup => {
                    current = String::new();
                    next = String::new();
                }
            }
        }

        if !current.is_empty() {
            result.push_str(&current);
        }

        current = next.to_string();
    }

    result
}
loops

1 respostas

  1. Best Answer

    Mudei EndGrouppara o vetor anterior e funcionou:

    enum Token {
    Str(&'static str),
    Value(&'static str),
    StartGroup(&'static str),
    EndGroup,
}

fn main() {
    let data: Vec<Vec<Token>> = vec![
        vec![Token::Str("A = "), Token::Value("1")],
        vec![Token::Str(" AND ("), Token::StartGroup(" OR ")],
        vec![Token::Str("B = "), Token::Value("2")],
        vec![Token::Str("C = "), Token::Value("3")],
        vec![Token::Str("D = "), Token::Value("4"), Token::EndGroup],
        vec![ Token::Str(")")],
    ];

    let result = construct_string(data);

    assert_eq!("A = 1 AND (B = 2 OR C = 3 OR D = 4)", result);
}

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();

    let mut current = String::new();
    let mut next = String::new();

    for token in tokens {
        for part in token {
            match part {
                Token::Str(str) => {
                    result.push_str(str);
                }
                Token::Value(val) => {
                    result.push_str(val);
                }
                Token::StartGroup(group) => {
                    next = group.to_string();
                }
                Token::EndGroup => {
                    current = String::new();
                    next = String::new();
                }
            }
        }

        if !current.is_empty() {
            result.push_str(&current);
        }

        current = next.to_string();
    }

    result
}

    EDITAR

    Aplicada uma correção dentro do construct_string, dê uma olhada (a ideia é diferenciar se o delimitador tem que aparecer):

    enum Token {
    Str(&'static str),
    Value(&'static str),
    StartGroup(&'static str),
    EndGroup,
}

fn main() {
    let data: Vec<Vec<Token>> = vec![
        vec![Token::Str("A = "), Token::Value("1")],
        vec![Token::Str(" AND ("), Token::StartGroup(" OR ")],
        vec![Token::Str("B = "), Token::Value("2")],
        vec![Token::Str("C = "), Token::Value("3")],
        vec![Token::Str("D = "), Token::Value("4")],
        vec![Token::EndGroup, Token::Str(")")],
    ];

    let result = construct_string(data);

    assert_eq!("A = 1 AND (B = 2 OR C = 3 OR D = 4)", result);
}

fn construct_string(tokens: Vec<Vec<Token>>) -> String {
    let mut result = String::new();

    //let mut current = String::new();
    let mut next = String::new();
    
    let mut new_group = true;

    for token in tokens {
        for part in token {
            match part {
                Token::Str(str) => {
                    if !new_group {
                        result.push_str(&next);
                    }
                    new_group = false;
                    result.push_str(str);
                }
                Token::Value(val) => {
                    result.push_str(val);
                }
                Token::StartGroup(group) => {
                    new_group = true;
                    next = group.to_string();
                }
                Token::EndGroup => {
                    //current = String::new();
                    next = String::new();
                }
            }
        }

        //if !current.is_empty() {
          //  result.push_str(&current);
        //}

        //current = next.to_string();
    }

    result
}
    • 1

relate perguntas