Erinnern Sie sich an meine Matte, die richtig nach Farben sortiert ist ?

Gestern habe ich es mir angesehen und festgestellt, dass einige Buchstaben in andere passen. Beispiel: Ein Brief Ppasst an die Stelle, an der der Brief Rhingeht. Hier ist eine einfache Herausforderung: Geben Sie bei zwei Buchstaben einen Wahrheitswert zurück, wenn einer der Buchstaben in den anderen passt (direkt oder gedreht, aber nicht gespiegelt), oder einen Falschwert, wenn dies nicht der Fall ist. Das heißt, wenn die Eingabe [P,R]oder ist [R,P], müssen Sie die Wahrheit zurückgeben, da in beiden Fällen ein Buchstabe in den anderen passt. Wenn Sie bekommen [L,U], müssen Sie Falsey zurückgeben, da keiner in den anderen passt.

Regeln

• Die Eingabe muss aus zwei alphanumerischen Zeichen im Bereich [0-9A-Z] bestehen, da sich in der Matte auch Zahlen in beliebiger Form befinden (zwei separate Zeichen als zwei Eingaben, eine Liste mit zwei Zeichen, eine Zeichenfolge mit dem 2 Zeichen, was auch immer).
• Die Ausgabe muss konsistent sein (die Wahrheits- und Falschheitswerte müssen immer gleich sein).

• Im Folgenden finden Sie die Tabelle mit den Beschlägen (beachten Sie, dass ein Buchstabe immer an die richtige Stelle passt, nur für den Fall, dass Sie so etwas wie [Y,Y]eine Eingabe erhalten):

  char fits inside chars
  --------------------------------------------------------
     C             G,O
     F             B,E,P,R
     G             O
     I             0,1,7,B,D,E,F,H,K,L,M,N,O,P,R,T,V,W,X,Z
     L             E
     M             W
     P             R
     S             O
     V             A
     W             M
     0             O
     1             B,E,L
     3             O
     6             9,O
     8             O
     9             6,O
  

Ich schwöre feierlich, dass ich jeden Sitz in der Matte meines Kindes getestet habe. (Trocknet seinen Schweiß von der Stirn.)

Das ist Code-Golf , also kann der kürzeste Code für jede Sprache gewinnen!

Einige Testfälle

input  output
-------------
[C,G]  truthy (C fits inside G)
[G,C]  truthy (C fits inside G)
[F,R]  truthy (F fits inside R)
[M,W]  truthy (both fit inside the other)
[O,S]  truthy (S fits inside O)
[T,T]  truthy (T fits in its place)
[E,V]  falsey (no fit found)
[P,L]  falsey

Sandkastenpfosten . Bitte verzeihen Sie mir, wenn Sie mehr Beschläge entdecken, die ich verpasst habe. Vielen Dank an Οurous für die Hilfe bei der Ausstattungsliste.

Python 2 , 135 130 129 Bytes

-1 Byte danke an Lynn

lambda s:cmp(*s)%2*s[::cmp(*s)|1]in'OIH TIE XI7 RF O8 OGC LI0 O3 O96 VA O6 KI PI WI L1 WMI O0 RIB NI1 FE SOC VID ZIFB1 PF LE1 RP'

Probieren Sie es online!

Python 3 , 143 Bytes

lambda*i:any({*i}&{a,c}=={*i}for a,b in zip('CFGILMPSVW013689','GO BEPR O 017BDEFHKLMNOPRTVWXZ E W R O A M O BEL O 9O O 6O'.split())for c in b)

Probieren Sie es online!

Retina , 93 92 Bytes

O`.
(.)\1|1[BEL]|69|AV|CG|BF|EF|EL|FP|FR|[017BDEFH]I|I[KLMNOPRTVWXZ]|MW|PR|OS|[03689CG]O

^$

Probieren Sie es online! Bearbeiten: 1 Byte dank @ovs gespeichert.

Sauber , 276 226 Bytes

Vage Golf-ish. Wird morgen polieren.

import StdEnv
i a b=isMember b a
t=True
f'C'b=i['GO']b
f'F'b=i['BEPR']b
f'O'b=i['GS03689']b
f'I'b=i['017BDEFHKLMNOPRTVWXZ']b
f'L''E'=t
f'P''R'=t
f'V''A'=t
f'M''W'=t
f'1'b=i['BEL']b
f'6''9'=t
f _ _=False
?a b=a==b||f a b||f b a

Probieren Sie es online!

Haskell , 149 145 Bytes

[]!_=0>1
(a:b:c)!t=(a,b)==t||(b,a)==t||c!t
f x y=x==y||"0I0O1B1E1I1L3O696O7I8O9OAVBFBICGCODIEFEIELFIFPFRGOHIIKILIMINIOIPIRITIVIWIXIZMWOSPR"!(x,y)

Probieren Sie es online!

Javascript 155 153 151 149 Bytes

Ich denke, das funktioniert in allen Fällen, 1/0 für wahr / falsch.

(c,f,q=1)=>"CGO,FBEPR,GO,I017BDEFHKLMNOPRTVWXZ,LE,MW,PR,SO,VA,WM,0O,1BEL,3O,69O,8O,96O".split`,`.some((v=>v[0]==c&v.includes(f)))|c==f|(q?F(f,c,0):0)

Erläuterung:

F=(
c, // input 1
f, // input 2
q=1 // variable used to execute F twice
)=>(
"CGO,FBEPR,GO,I017BDEFHKLMNOPRTVWXZ,LE,MW,PR,SO,VA,WM,0O,1BEL,3O,69O,8O,96O".split`,` 
                              // array of strings where [0] is input 1 and [>0] are the fittings
.some(                        // any element of the array meets:
(v=>v[0]==c&v.includes(f)))|  // input 1 equals [0] and input 2  exists in the lookup string OR
c==f|                         // input 1 equals input 2 OR
(q?F(f,c,0):0)                // input 2 fits inside input 1

let F=(c,f,q=1)=>"CGO,FBEPR,GO,I017BDEFHKLMNOPRTVWXZ,LE,MW,PR,SO,VA,WM,0O,1BEL,3O,69O,8O,96O".split`,`.some((v=>v[0]==c&v.includes(f)))|c==f|(q?F(f,c,0):0);
let tests = [
  ["C","G"],  //truthy (C fits inside G)
  ["G","C"],  //truthy (C fits inside G)
  ["F","R"],  //truthy (F fits inside R)
  ["M","W"],  //truthy (both fit inside the other)
  ["O","S"],  //truthy (S fits inside O)
  ["T","T"],  //truthy (T fits in its place)
  ["E","V"],  //falsey (no fit found)
  ["P","L"]   //falsey
];
tests.forEach((v)=>{console.log("F('"+v[0]+"','"+v[1]+"') = " + F(v[0],v[1]))});

Änderungsprotokoll:

• 2 Bytes gespart dank kamoroso94
• 2 Bytes gespart dank Chris M
• 2 Bytes gespart, indem die Suchmethode auf .some () geändert wurde

Julia 0,6 , 139 Bytes

(a,b)->(a==b)|any(map(x->all(in.((a,b),x))|all(in.((b,a),x)),zip("OCFILMPV16",split("CGS0368 G BEPR 017BDEFHKLMNOPRTVWXZ E W R A BEL 9"))))

Probieren Sie es online!

Durch Gruppieren der Zeichen, die in 'O' passen, wurden einige Bytes gespeichert. Aber beim Testen der umgekehrten Eingabe wird zu viel Code verwendet ...

Erläuterung:

• zip(☐)Zippt die entsprechenden Einzelbuchstaben aus "OCFILMPV16"& einer Folge übereinstimmender Buchstaben.
• .in(☐) wird elementweise angewendet, z (in(a,'O'),in(b,"OCFILMPV16"))
• all(.in(☐)) Beides muss gefunden werden ...
• |für entweder a,boderb,a ...
• any(map(☐)) für mindestens ein Element der gezippten Liste.

Kotlin , 147 139 Bytes

fun p(s:String)=setOf(s,s.reversed()).any{it.matches(Regex("(.)\\1|F[BEPR]|I[017BDEFHKLMNOPRTVWXZ]|1[BEL]|69|CG|LE|MW|PR|VA|O[CG69038S]"))}

Probieren Sie es online!

Das Beispiel auf Try It Online enthält Testfälle für jede positive und einige negative Kombination.

Ich habe die reg.ex nicht optimiert. zu viel, es könnte also länger als nötig sein

BEARBEITEN: speicherte ein paar Bytes auf reg.ex.

C (gcc) , 211 Bytes

Ein erster Versuch. Sehr einfach.

i;char*c="CFGILMPSVW013689",*x[]={"GO","BEPR","O","017BDEFHKLMNOPRTVWXZ","E","W","R","O","A","M","O","BEL","O","9O","O","6O"};h(a,b){return(i=strchr(c,a)-c)>=0&&strchr(x[i],b);}f(a,b){return a==b|h(a,b)|h(b,a);}

Probieren Sie es online!

PHP , 204 Bytes

-147 Bytes, weil ich zurückkam, um 2 Bytes zu entfernen, nur um festzustellen, dass mein Code ein paar Bugs und unbenutzte Variablen hatte! Mein Code ist jetzt viel kürzer.

<?php $a=fgets(STDIN);for($w=0;$w<2;$w++){if(strpos(explode(',','GO,BEPR,O,017BDEFHKLMNOPRTVWXZ,E,W,R,O,A,M,O,BEL,O,9O,O,6O')[strpos(CFGILMPSVW013689,$a[0])],$a[1])!==false){echo"t";break;}$a=strrev($a);}

Probieren Sie es online!

Ruby, 140 Bytes

->c,t{x='CFGILMPSVW013689'.chars.zip('GO BEPR O 017BDEFHKLMNOPRTVWXZ E W R O A M O BEL O 9O O 6O'.split).to_h;p x.key?(c)&&x[c].include?(t)}

Ziemlich genau wie die Antwort in Python 3, aber mit einer anderen Ausführung.