Dans le moins d'octets possible, déterminez si les deux valeurs données correspondent chacune à l'une des suivantes:

Première valeur

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

Deuxième valeur

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

Exemples

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

Shakespeare , 4778 octets

Remarque: cette réponse n'est pas censée être un concurrent sérieux

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]

Affiche 0 si faux, 1 si vrai.

Cela pourrait facilement être plus court (et si les gens le veulent vraiment, la longueur des mots pourrait être réduite), mais cela serait une gifle pour le bon vieux Will. J'ai toujours pensé que Horatio était le héros méconnu de Hamlet, alors je me suis assuré qu'il était le seul à livrer l'intense monologue à Hamlet où Hamlet doit finalement prouver qu'il est aussi bon que Horatio (qui représente la nouvelle ligne).

Le code lui-même est assez simple. Tous les caractères sans Hamlet sont des valeurs ascii (dans l'ordre:) newline,space,0,2,3,B,b,E,e,O,o,T,t,V,v, puis le code est une machine à états simple (en particulier, un DFA ) qui passe en Scene XItant qu'état d'acceptation et en Scene XIItant qu'état de rejet.

.

Après avoir fait cela, je l'ai simplement connecté à Shakespeare, en utilisant le fait que je pouvais passer à l'état suivant lorsqu'ils étaient numériquement adjacents. Je ne l'ai testé qu'avec la version de Shakespeare que j'ai liée dans le titre, mais je crois que nous définissons un langage par une implémentation iirc.

Rétine , 28

• 1 octet enregistré grâce à @ MartinBüttner.

Peut-être ma réponse la plus rapide de code-golf jamais - 9 minutes après OP.

Les paramètres d'entrée sont séparés par des virgules. La sortie est 1 pour true et 0 pour falsey.

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

Essayez-le en ligne.

Pyth, 34 octets

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

Essayez-le en ligne: Démonstration

Explication:

          ."...   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 octets

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

Essayez-le ici!

Recherche de liste simple. Imprime une liste vide comme valeur falsifiée et une liste non vide comme valeur véridique.

Vous cherchez ou mieux, je n'aime pas vraiment celui-ci.

Oracle SQL 11.2, 86 octets

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

Renvoie une ligne pour true et aucune ligne pour falsey.

05AB1E , 39 45 octets

Code:

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

Essayez-le en ligne!

Utilise l'encodage CP-1252. La vérité est quand un nombre est sorti et la fausseté est quand rien n'est sorti.

Version non concurrente (39 octets) , fonctionne avec la dernière version:

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

ES6, 56 48 45 octets

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

5 octets enregistrés grâce à @ user81655. Enregistré 3 octets d'une optimisation supplémentaire. Sauvegardé encore 3 octets grâce à @Patrick Roberts.

t[wo]?o est l'expression la plus courte à laquelle je pouvais penser pour correspondre aux trois homophones.

S'il est permis de passer les deux valeurs en tant que tableau de paramètres unique, le paramètre reste peut devenir un paramètre normal, économisant encore 5 octets.

Perl 6, 45 44 octets

Merci aux gens d'IRC de m'avoir aidé à jouer au golf

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

usage

> 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

Alternative non concurrente, 54 octets

C'est une bonne alternative à ce qui précède si vous pensez que les regex sont grossières, mais c'est un peu plus long. Il pourrait être joué sur quelques octets de plus, mais comme il n'est pas en compétition, je le laisse tel quel.

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

Python 2.7, 133 octets

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')

Je ne sais pas si nous sommes censés publier des solutions s'il y a une version plus petite dans les commentaires, mais voici ma version en Python.

Edit: Sans la fonction, ce n'est que 73 octets (et ce n'est même pas près des meilleures réponses. Pardonnez-moi, je suis nouveau

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

Rubis, 53 55 52 octets

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

Je vais être honnête, c'est ma première tentative d'essayer de jouer au golf avec un problème.

Appel de fonction sous forme de f.call(firstValue, secondValue)

0est Truthy, nilest Falsy.

Testez-le ici

Japt, 36 octets

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

Peut-être que j'ai raté quelque chose, mais cela devrait fonctionner complètement. Testez-le en ligne!

Pyth, 39 octets

-3 octets par @FryAmtheEggman

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

Essayez-le ici .

Python, 85 83 octets

@Manatwork m'a sauvé deux octets.

Ceci est assez brutal, je vais ensuite examiner les solutions d'expression rationnelle.

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

PowerShell v3 +, 74 70 octets

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

N'utilise pas l'expression régulière. Prend deux entrées, vérifie si le premier est -inle tableau créé dynamiquement par l' -splitopérateur, convertit ce booléen en entier avec +, puis multiplie cela *en vérifiant si le second est -inle deuxième tableau (qui convertira automatiquement le booléen en int ). Cela fonctionne parce que x*y == x&ysi xet yne peut être que 1ou 0.

Par défaut, PowerShell ne respecte pas la casse, nous l'obtenons donc gratuitement. Sortira 0ou 1pour falsey / truey, respectivement. Nécessite la version 3 ou plus récente pour l' -inopérateur.

_{Édition - 4 octets enregistrés en utilisant unaire -split}

Groovy, 52 octets

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

==~ est un opérateur regex cool dans groovy qui vérifie l'égalité.

Tests:

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 octets

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

Même approche que la réponse Retina de @ DigitalTrauma . Les entrées sont séparées par une virgule. La sortie véridique est une chaîne avec les deux entrées en minuscules; la falsification n'est pas sortie.

Essayez-le en ligne!

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 octets

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

Version non golfée (seulement un peu plus lisible):

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 octets

Utilise l'expression régulière de Digital Trauma. L'entrée est une chaîne unique séparée par une virgule. Je ne sais pas si ce format est autorisé pour la saisie ...

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