rileva se una combinazione di oggetti stringa da una matrice corrisponde a qualsiasi comando

Question

rileva se una combinazione di oggetti stringa da una matrice corrisponde a qualsiasi comando

#1 da (2 voti)

1

Sii paziente e leggi il mio scenario attuale. La mia domanda è di sotto.

La mia applicazione prende in input la voce e riesce a raggruppare le parole che si combinano insieme per formare una parola o un gruppo di parole - chiamate frasi; sia esso un name , un action , un pet o un time frame.

Ho una lista principale delle frasi che sono permesse e sono memorizzate nei loro rispettivi array. Quindi ho le seguenti matrici validNamesArray , validActionsArray , validPetsArray e validTimeFramesArray .

Una nuova serie di frasi viene restituita ogni volta che l'utente smette di parlare.

NSArray *phrasesBeingFedIn = @[@"CHARLIE", @"EAT", @"AT TEN O CLOCK", 
                                @"CAT", 
                                @"DOG", "URINATE", 
                                @"CHILDREN", @"ITS TIME TO", @"PLAY"];

Sapendo che è ok avere la seguente combinazione per creare un comando:

COMMAND 1: NAME + ACTION + TIME FRAME
COMMAND 2: PET + ACTION 
COMMAND n: n + n, .. + n

//In the example above, only the groups of phrases 'Charlie eat at ten o clock' and 'dog urinate'
//would be valid commands, the phrase 'cat' would not qualify any of the commands
//and will therefor be ignored

Domanda

Qual è il modo migliore in cui posso analizzare le frasi inserite e determinare quali frasi di combinazione soddisfano il mio elenco di comandi?

Soluzione POSSIBILE che ho trovato Un modo è di fare un passo attraverso l'array e avere if e else istruzioni che controllano le frasi future e vedere se soddisfano qualsiasi modello di comando valido dall'elenco, tuttavia la mia soluzione non è dinamica, dovrei aggiungere un nuovo set di if e altre istruzioni per ogni singola nuova permutazione di comando che creo.

La mia soluzione non è efficiente. Qualche idea su come potrei creare qualcosa di simile che funzioni e sia dinamico, non importa se aggiungo una nuova sequenza di comandi della combinazione di frasi?

design-patterns algorithms ios objective-c

posta Pavan 17.01.2014 - 05:00

fonte

1 risposta

Leggi altre domande sui tag design-patterns algorithms ios objective-c

È corretto / utile definire la Complessità Computazionale in questo modo? Comandi / transazioni interaggregati in modo coerente

score 2 · Accepted Answer

Ho una minima esperienza con l'obiettivo-c, quindi ho intenzione di eseguire la soluzione che creerei usando c #, ma spiegherò mentre procedo. Dovrebbe essere facile da replicare in qualsiasi lingua simile.

Vorrei iniziare con la definizione di un enum per specificare i tipi di frase:

enum PhraseTypes {
    name = 0,
    action = 1,
    pet = 2,
    timeFrames = 3
}

Definirei quindi una regola con la seguente struttura:

class Rule {
    List<PhraseTypes> components;
    Action action; //or whatever makes sense for your app
}

Il comando utenti potrebbe quindi essere rappresentato come:

List<String> command;

Le frasi valide potrebbero essere:

List<String> validNamesArray;
List<String> validActionsArray;
// ...

E poi compilato in:

List<List<String>> validPhrases = new List<List<String>>( new List<String>[]
                {validNamesArray, validActionsArray, validPetsArray, validTimeFramesArray}
                                                        );

Eseguendo un controllo contro le regole, e chiamando l'azione corretta potrebbe quindi essere fatto in questo modo:

bool CheckCommandAgainstRules(Rules rules, List<String> command) {
    foreach (Rule rule in rules) {
        if (CheckCommandAgainstRule(rule, command)) {
            rule.Action(command);  //or whatever makes sense for your app
            return true;
        }
    }
    return false;
}

bool CheckCommandAgainstRule(Rule rule, List<String> command) {
    for (i = 0; i < rule.components.length; i++) {
        PhraseType phraseType = rule.components[i];
        String phrase = command[i];
        if(!validPhrases[(int)phraseType].Contains(phrase)) {
            return false;
        }
    }
    return true;
}

Questa struttura generale dovrebbe facilmente adattarsi a qualsiasi numero di regole e / o tipi di frasi.

Modifica:

1) Sì, ho capito che una volta risolto il problema di determinare se un comando è valido, e identificato quale regola corrisponde al prossimo problema, si innesca un qualche tipo di azione. Un modo è lasciare che il Rule sappia quale azione è richiesta. In c # vorrei usare un delegato o una classe con un'interfaccia conosciuta, così potrei chiamarla .run() metodo. Il meglio è probabile che varia da una lingua all'altra.

2) La mia comprensione era che stai usando phrase per indicare un gruppo atomico di una o più parole, ad es. "AT TEN O CLOCK", "DOG" o "PLAY". Ho usato command per rappresentare una lista di frasi come derivate dall'input dell'utente. Rileggendo la tua domanda sembra che tu abbia usato command per fare riferimento a una combinazione valida di tipi di frase, questo qualcosa ho chiamato a Rule .