Uma letra cabe dentro da outra?

23

Você se lembra do meu tapete adequadamente agrupado por cores ?

Meu tapete adequadamente agrupado por cores

Ontem eu estava olhando e percebi que algumas letras cabiam dentro de outras. Exemplo: uma letra Pcabe no local para onde a letra Rvai. Então, aqui está um desafio simples: dadas duas letras, retorne um valor verdadeiro se qualquer uma delas se encaixar dentro da outra (direta ou girada, mas não invertida), ou um valor falsey se não o fizer. Ou seja, se a entrada é [P,R]ou [R,P], você deve retornar a verdade porque, em ambos os casos, uma letra cabe dentro da outra. Se você conseguir, [L,U]você deve retornar o falsey, pois ele não se encaixa dentro do outro.

Regras

  • A entrada deve ter dois caracteres alfanuméricos no intervalo [0-9A-Z], pois também existem números no tapete, de qualquer forma que você precisar (dois caracteres separados como duas entradas, uma lista com dois caracteres, uma sequência com o 2 caracteres, qualquer que seja).
  • A saída deve ser consistente (os valores de verdade e falsey devem ser sempre os mesmos).
  • A seguir, é apresentada a tabela de acessórios (observe que uma letra sempre se encaixa em seu devido lugar, caso você receba algo como [Y,Y]entrada):

    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
    

Juro solenemente que testei todos os encaixes no tapete do meu filho. (Seca o suor da testa.)

Este é o , portanto, pode ganhar o código mais curto para cada idioma!

Alguns casos de teste

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

Postagem na caixa de areia . Por favor, perdoe-me se você encontrar mais acessórios que eu perdi. Muito obrigado a Οurous por me ajudar com a lista de acessórios.

Charlie
fonte
1
Kolmogorov-complexidade .
user202729
1
1não se encaixa F?
user202729
@ user202729 não, porque você precisa virar o 1para encaixá-lo, Fmas isso não é permitido no meu tapete. :-)
Charlie
4
Ilustração Gráfico ASCII-art (é claro que o encaixe é transitivo)
user202729
1
@ Foi difícil nessa outra pergunta quando já tinha duas respostas ... Além disso, o desafio já tem muitos casos para testar, mais casos não acrescentam nada a ele (acho que a parte mais criativa é que as duas entradas são intercambiáveis, pois você deve verificar os dois acessórios).
20917 Charlie

Respostas:

6

Python 2 , 135 130 129 bytes

-1 byte graças a 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'

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

Experimente online!

ovs
fonte
5

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

^$

Experimente online! Editar: salvou 1 byte graças a @ovs.

Neil
fonte
Faz este trabalho para 92 bytes?
ovs
2

Limpo , 276 226 bytes

Vagamente jogou golfe. Vai polir amanhã.

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

Experimente online!

Furioso
fonte
2

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)

Experimente online!

user28667
fonte
2

Javascript 155 153 151 149 bytes

Eu acho que isso funciona em todos os casos, 1/0 para verdadeiro / falso.

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

Explicação:

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]))});

Changelog:

  • economizou 2 bytes graças a kamoroso94
  • economizou 2 bytes graças a Chris M
  • economizou 2 bytes alterando o método de pesquisa para .some ()
Brian H.
fonte
Esse retorno é verdadeiro se cencaixa fou fse encaixa c? Parece que você verifica apenas um caso.
Charlie
Código fixo para retornar verdadeiro se fencaixac
Brian H.
Eu não sou muito boa explicando, se alguém quiser fazê-lo sentir mais clara livre para sugerir uma edição
Brian H.
Você pode usar em includes(f)vez de indexOf(f)>=0salvar 2 bytes.
kamoroso94
incrível, nem sabia que isso era uma coisa: D
Brian H.
1

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

Experimente online!

Salve alguns bytes agrupando os caracteres que se encaixam em 'O'. Mas testar a entrada reversa usa muito código ...

Explicação:

  • zip(☐)fecha as letras únicas correspondentes de "OCFILMPV16"e uma sequência de letras correspondentes.
  • .in(☐) é aplicado elemento a elemento, por exemplo (in(a,'O'),in(b,"OCFILMPV16"))
  • all(.in(☐)) Ambos devem ser encontrados ...
  • |para um a,bou b,a...
  • any(map(☐)) para pelo menos um elemento da lista compactada.
LukeS
fonte
1

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]"))}

Experimente online!

O exemplo do Try It Online inclui casos de teste para todas as combinações positivas e algumas negativas.

Não otimizei o reg.ex. muito, então pode demorar mais do que o necessário

EDIT: salvou alguns bytes no reg.ex.

Damiano
fonte
1

C (gcc) , 211 bytes

Uma primeira tentativa. Muito direto.

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);}

Experimente online!

gastropner
fonte
0

PHP , 204 bytes

-147 bytes porque volto a remover 2 bytes apenas para descobrir que meu código tinha alguns bugs e variáveis ​​não utilizadas! Meu código agora é muito menor.

<?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);}

Experimente online!

NK1406
fonte
0

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

Praticamente o mesmo que a resposta do python 3, mas com uma execução diferente.

Håvard Nygård
fonte