Nel minor numero di byte possibile, determinare se i due valori indicati corrispondono a uno dei seguenti:

Primo valore

2      string or integer - whichever you prefer
to     case insensitive
too    case insensitive
two    case insensitive
t0     case insensitive (t zero)

Secondo valore

b      case insensitive
be     case insensitive
bee    case insensitive
b3     case insensitive

Esempi

2          'Bee'            true
'2'        'b'              true
'not to'   'be'             false
'that is'  'the question'   false

Shakespeare , 4778 byte

Nota: questa risposta non vuole essere un serio concorrente

To Be or Not To Be, This is the Answer.

Hamlet, the main player in our story.
Horatio, Hamlet's guide through his internal struggles.
The Ghost, a handsome honest bold fair gentle king.
Claudius, the worthless usurper of the throne.
Ophelia, who Hamlet always writes two.
Polonius, the unfortunate third man caught between Hamlet and Claudius.
Brabantio, the greater.
Banquo, the lesser.
Emilia, the greater.
Egeus, the lesser.
Othello, the greater.
Orsino, the lesser.
Tybalt, the greater.
Titania, the lesser.
Valentine, who doubled is greater.
Viola, who doubled is lesser.

Act I: A simple question in so many words.

Scene I: Hamlet passes judgment over the cast.

[Enter Hamlet and Horatio]
Hamlet:
    Thou art the sum of a good healthy sunny warrior and a lovely day.
[Exit Horatio]
[Enter Claudius]
Hamlet:
    Thou art the sum of The Ghost and warm cute brave trustworthy hero.
[Exit Claudius]
[Enter Ophelia]
Hamlet:
    Thou art the sum of Claudius and a smooth spaceman.
[Exit Ophelia]
[Enter Polonius]
Hamlet:
    Thou art the sum of Ophelia and a plum.
[Exit Polonius]
[Enter Brabantio]
Hamlet:
    Thou art the sum of The Ghost and the sum of The Ghost and a rich kingdom.
[Exit Brabantio]
[Enter Banquo]
Hamlet:
    Thou art the sum of Brabantio and The Ghost.
[Exit Banquo]
[Enter Emilia]
Hamlet:
    Thou art the sum of Brabantio and the sum of joy and a gentle girl.
[Exit Emilia]
[Enter Egeus]
Hamlet:
    Thou art the sum of Emilia and The Ghost.
[Exit Egeus]
[Enter Othello]
Hamlet:
    Thou art the sum of Emilia and the sum of a cunning lover and the sweetest golden embroidered rose.
[Exit Othello]
[Enter Orsino]
Hamlet:
    Thou art the sum of Othello and The Ghost.
[Exit Orsino]
[Enter Tybalt]
Hamlet:
    Thou art the sum of Othello and the sum of happiness and fair fine heaven.
[Exit Tybalt]
[Enter Titania]
Hamlet:
    Thou art the sum of Tybalt and The Ghost.
[Exit Titania]
[Enter Valentine]
Hamlet:
    Thou art the sum of Tybalt and the sum of a happy day and a pony.
[Exit Valentine]
[Enter Viola]
Hamlet:
    Thou art the sum of Valentine and The Ghost.
[Exeunt]

Scene II: The beginning of Horatio's interrogation.
[Enter Hamlet and Horatio]
Hamlet:
Horatio:
    Open your mind.
    Art thou as good as Tybalt?  If so, let us proceed to Scene IV.
    Art thou as good as Titania?  If so, let us proceed to Scene IV.
    Art thou as good as Ophelia?  If not, let us proceed to Scene XII.


Scene III: Are we to?
Horatio:
    Open your mind.
    Art thou as good as The Ghost?  If so, let us proceed to Scene VII.
    Let us proceed to Scene XII.

Scene IV: Can we go further than t?
Horatio:
    Open your mind.
    Art thou as good as Claudius?  If so, let us proceed to Scene III.
    Art thou as good as Valentine?  If so, let us proceed to Scene VI.
    Art thou as good as Viola?  If so, let us proceed to Scene VI.
    Art thou as good as Othello?  If so, let us proceed to Scene V.
    Art thou as good as Orsino?  If not, let us proceed to Scene XII.

Scene V: Oone oor twoo?
Horatio:
    Open your mind.
    Art thou as good as The Ghost?  If so, let us proceed to Scene VII.
    Art thou as good as Othello?  If so, let us proceed to Scene III.
    Art thou as good as Orsino?  If so, let us proceed to Scene III.
    Let us proceed to Scene XII.

Scene VI: Hamlet desperately searches for whOo?.
Horatio:
    Open your mind.
    Art thou as good as Othello?  If so, let us proceed to Scene III.
    Art thou as good as Orsino?  If so, let us proceed to Scene III.
    Let us proceed to Scene XII.

Scene VII: Knowing to, what to do?
Horatio:
    Open your mind.
    Art thou as good as Brabantio?  If so, let us proceed to Scene VIII.
    Art thou as good as Banquo?  If not, let us proceed to Scene XII.

Scene VIII: Learning what to Bleive.
Horatio:
    Open your mind.
    Art thou as good as me?  If so, let us proceed to Scene XI.
    Art thou as good as Emilia?  If so, let us proceed to Scene X.
    Art thou as good as Egeus?  If so, let us proceed to Scene X.
    Art thou as good as Polonius?  If not, let us proceed to Scene XII.

Scene IX: The Eend is nigh?
Horatio:
    Open your mind.
    Art thou as good as me?  If so, let us proceed to Scene XI.
    Let us proceed to Scene XII.

Scene X: Wee may havee succeeeedeed.
Horatio:
    Open your mind.
    Art thou as good as Emilia?  If so, let us proceed to Scene IX.
    Art thou as good as Egeus?  If so, let us proceed to Scene IX.
    Art thou as good as me?  If not, let us proceed to Scene XII.

Scene XI: Hamlet is at peace.
Horatio:
    Thou art a beacon of happiness. 
    Let us proceed to Scene XIII

Scene XII: The demons have won.
Horatio:
    Thou art nothing.

Scene XIII: Hamlet opens up.
Horatio:
    Hamlet! Open your heart.
[Exeunt]

Emette 0 se falso, 1 se vero.

Questo potrebbe facilmente essere più breve (e se la gente lo vuole davvero, la lunghezza delle parole potrebbe essere ridotta), ma farlo sarebbe uno schiaffo di fronte al buon vecchio Will. Ho sempre pensato che Horatio fosse l'eroe non celebrato di Amleto, quindi mi sono assicurato che fosse lui a consegnare l'intenso monologo ad Amleto, dove Amleto alla fine doveva dimostrare di essere bravo come Orazio (che rappresenta la nuova linea).

Il codice stesso è piuttosto semplice. Tutti i caratteri senza Hamlet sono valori ASCII (nell'ordine:) newline,space,0,2,3,B,b,E,e,O,o,T,t,V,ve quindi il codice è una semplice macchina a stati (in particolare un DFA ) che passa a Scene XIuno stato di accettazione e Scene XIIa uno di rifiuto.

.

Dopo averlo fatto, l'ho appena inserito in Shakespeare, usando il fatto che potevo passare allo stato successivo quando erano numericamente adiacenti. L'ho testato solo con la versione di Shakespeare che ho collegato nel titolo, ma credo che definiamo un linguaggio con un iirc di implementazione.

Retina , 28

• 1 byte salvato grazie a @ MartinBüttner.

Molto probabilmente la mia risposta di golf da codice più veloce di sempre - 9 minuti dopo l'OP.

I parametri di input sono separati da virgola. L'output è 1 per verità e 0 per falsità.

i`^(2|t[ow]?o|t0),b(e?e?|3)$

Provalo online.

Pyth, 34 byte

.A}Lrw1c2c." Wô-WûÄæ­§Òé
}

Provalo online: dimostrazione

Spiegazione:

          ."...   packed string, gets decoded to: "2 TO TOO TWO T0 B BE BEE B3"
         c        split by spaces
       c2         split into 2 lists: [['2', 'TO', 'TOO', 'TWO', 'T0'], 
                                       ['B', 'BE', 'BEE', 'B3']]
   L              for each list:
     w               read a line
    r 1              convert it to uppercase
  }                  and test if it is part of this list list
.A                test if both return true

Pyth, 41 byte

&xrw0c"2 to too two t0"dxrw0c"b be bee b3

Provalo qui!

Ricerca elenco semplice. Stampa un elenco vuoto come valore errato e un elenco non vuoto come valore attendibile.

Guardando o un modo migliore, non mi piace proprio questo.

Oracle SQL 11.2, 86 byte

SELECT 1 FROM DUAL WHERE:1 IN('2','to','too','two','t0')AND:2 IN('b','be','bee','b3');

Restituisce una riga per verità e nessuna riga per falso.

05AB1E , 39 45 byte

Codice:

“2€„…«Œ† t0“' ¡)Ilrk\U“b€ïÍÝ b3“' ¡)Ilrk\>X>*

Provalo online!

Utilizza la codifica CP-1252. La verità è quando viene emesso un numero e la falsità è quando non viene emesso nulla.

Versione non competitiva (39 byte) , funziona con la versione più recente:

“2€„…«Œ† t0“ð¡)IlkU“b€ïÍÝ b3“ð¡)Ilk>X>*

ES6, 56 48 45 byte

(...a)=>/^(2|t0|t[wo]?o),b(ee?|3)?$/i.test(a)

5 byte salvati grazie a @ user81655. Salvato 3 byte da qualche ulteriore ottimizzazione. Salvati altri 3 byte grazie a @Patrick Roberts.

t[wo]?o è la regex più corta che mi viene in mente di abbinare tutti e tre gli omofoni.

Se è consentito passare i due valori come un singolo array di parametri, il parametro restante può diventare un parametro normale, salvando altri 5 byte.

Perl 6, 45 44 byte

Grazie alla gente dell'IRC per avermi aiutato a giocare a golf

{@_~~(~2|/:i^t[0|oo?|wo]$/,/:i^b[ee?|3]?$/)}

uso

> my &f = {@_~~(~2|/:i^t[0|oo?|wo]$/,/:i^b[ee?|3]?$/)}
-> *@_ { #`(Block|309960640) ... }
> f("2", "Bee")
True
> f("2", "b")
True
> f("not to", "be")
False
> f("that is", "the question")
False

Alternativa non competitiva, 54 byte

Questa è una buona alternativa a quanto sopra se pensi che le regex siano grossolane, ma è un po 'più lunga. Potrebbe essere golfato un altro paio di byte, ma poiché non è in competizione, lo lascerò così com'è.

{@_».lc~~(qw<to too two t0 2>.any,<b be bee b3>.any)}

Python 2.7, 133 byte

def e(a, b):
        c, d = """2,too,to,t0,two""","""be,b,bee,b3"""
        return a.lower() in c and b.lower() in d

print e('2', 'bee')

Non sono sicuro se dovremmo pubblicare soluzioni se c'è una versione più piccola nei commenti, ma ecco la mia versione in Python.

Modifica: senza la funzione sono solo 73 byte (e non è nemmeno vicino alle migliori risposte. Perdonami, sono nuovo

a, b = "to", "bee"
print a in "2 too to t0 two" and b in "be b bee b3"

Rubino, 53 55 52 byte

f=->(a,b){/^(2|t[wo]?o|t0)$/i=~a&&/^b(e?e?|3)$/i=~b}

Sarò onesto, questo è il mio primo tentativo di provare a golf un problema.

Chiamata di funzione sotto forma di f.call(firstValue, secondValue)

0è la verità, nilè la falsità.

Provalo qui

Japt, 36 byte

!Uv r"2|t(0|wo|oo?)" «Vv r"b(e?e?|3)

Forse mi sono perso qualcosa, ma questo dovrebbe funzionare completamente. Provalo online!

Pyth, 39 byte

-3 byte di @FryAmtheEggman

.A.b}rN1cY\@Q,."0Wѳ5YYÅJB"."3EW´l¢ï

Provalo qui .

Python, 85 83 byte

@Manatwork mi ha salvato due byte.

Questa è una forza piuttosto bruta, esaminerò in seguito le soluzioni regex.

lambda a,b:a.lower()in'2 to too two t0'.split()and b.lower()in['b','be','bee','b3']

PowerShell v3 +, 74 70 byte

param($a,$b)+($a-in-split'2 to too two t0')*($b-in-split'b be bee b3')

Non usa regex. Prende due input, controlla se il primo è -inl'array che è stato creato dinamicamente -splitdall'operatore, converte quel booleano in un int con +, quindi lo moltiplica *verificando se il secondo è -inil secondo array (che lancerà automaticamente il booleano come int ). Questo funziona perché x*y == x&yse xe ypuò essere solo 1o 0.

PowerShell per impostazione predefinita non fa distinzione tra maiuscole e minuscole, quindi lo otteniamo gratuitamente. Sarà in uscita 0o 1, rispettivamente, per Falsey / truthy,. Richiede v3 o più recente per-in operatore.

_{Modifica: salvato 4 byte utilizzando unary -split}

Groovy, 52 byte

f={x,y->"$x $y"==~"(?i)(2|t([wo]o?|0)) (b(ee?|3)?)"}

==~ è un ottimo operatore regex in groovy che controlla l'uguaglianza.

test:

Test Regex101 .

assert f('2', 'Bee') == true
assert f('2', 'b') == true
assert f('not to', 'be') == false
assert f('that is', 'the question') == false

MATL , 32 41 43 byte

jk'^(2|t[ow]?o|t0),b(e?e?|3)$'XX

Stesso approccio della risposta Retina di @ DigitalTrauma . Gli input sono separati da una virgola. L'output vero è una stringa con i due input minuscoli; la falsità non viene emessa.

Provalo online!

j                                % input as a string
k                                % convert to lowercase
'^(2|t[ow]?o|t0),b(e?e?|3)$'     % regular expression to match the two inputs
XX                               % match regular expression

C # 6, 132 byte

bool t(string x,string y)=>new[]{"2","to","too","two","t0"}.Contains(x.ToLower())&&new[]{"b","be","bee","b3"}.Contains(y.ToLower());

Versione non golfata (solo leggermente più leggibile):

bool t(string x, string y) => new[] { "2", "to", "too", "two", "t0" }.Contains(x.ToLower()) && new[] { "b", "be", "bee", "b3" }.Contains(y.ToLower());

Python 2, 67 byte

Usa la regex di Digital Trauma. L'input è una singola stringa separata da una virgola. Non sono sicuro che quel formato sia consentito per l'input ...

import re
f=lambda x:bool(re.match('^(2|t[ow]?o|t0),b(e?e?|3)$',x))