Ao escrever uma mensagem com imãs de geladeira, você geralmente substitui um 1por um I. Neste desafio, seu objetivo é descobrir se uma mensagem pode ser escrita usando as letras de outra mensagem. As substituições permitidas são:

A = 4
B = 8
C = U
E = M = W = 3
G = 6 = 9
I = 1
L = 7
N = Z
O = 0
R = 2
S = 5

Por exemplo, a mensagem CIRCA 333pode ser reorganizada para soletrar ICE CREAM, onde os dois primeiros 3s são girados 180 graus para formar dois Eseo último 3é girado 90 graus no sentido anti-horário para gerar um M. Espaços em branco podem ser incluídos nas mensagens, mas não devem ser considerados na sua solução, pois são feitos colocando os ímãs na geladeira.

Entrada

Duas cadeias (ou matrizes de caracteres). Todas as mensagens corresponderão^[A-Z0-9 ]+$

Saída

Na verdade, se as duas seqüências de entrada são rearranjos válidos um do outro, falsey o contrário.

Exemplos

["CIRCA 333", "ICE CREAM"] => true
["DCLV 00133", "I LOVE CODE"] => true
["WE ARE EMISSARIES", "33   423    3315542135"] => true
["WE WANT ICE CREAM", "MET CIRCA 334 MEN"] => true
["I HAVE ICE CREAM", "HAVE 2 ICE CREAMS"] => false

Mais exemplos profundos

Estas são todas as palavras com mais de 15 letras que mapeiam para outra palavra. Algumas são substituições triviais, mas incluí tudo o que encontrei.

["ANTHROPOMORPHISE","ANTHROPOMORPHISM"]
["ANTIPHILOSOPHIES","ANTIPHILOSOPHISM"]
["CIRCUMSTANTIALLY","ULTRAMASCULINITY"]
["DECENTRALIZATION","DENEUTRALIZATION"]
["DIMETHYLNITROSAMINE","THREEDIMENSIONALITY"]
["INSTITUTIONALISE","INSTITUTIONALISM"]
["INTERCRYSTALLINE","INTERCRYSTALLIZE"]
["INTERNATIONALISE","INTERNATIONALISM"]
["OVERCENTRALIZATION","OVERNEUTRALIZATION"]
["OVERCENTRALIZING","OVERNEUTRALIZING"]
["PREMILLENNIALISE","PREMILLENNIALISM"]
["TRANSCENDENTALIZE","TRANSCENDENTALIZM"]

Como este é um desafio de código de golfe, a solução mais curta vence! Aceitarei a solução mais curta em 7 dias após a postagem. Feliz golfe!

Solução de amostra, sem golfe

Relacionado

• Alfabeto da minha filha

• Letras de banho de espuma

EDIT : Cometeu um erro nas substituições, teve G = 6e 6 = 9como substituições separadas, fundiu-os em um.

Japt , 38 36 33 30 bytes

Recebe a entrada como uma matriz de 2 strings.

®d`z³m`i`oiglbg`í)Ôu)ñ xÃr¶

Experimente ou execute todos os casos de teste

3 bytes salvos graças ao ETHProductions

®d`z...m`i`o...g`í)Ôu)ñ xÃr¶
                                 :Implicit input of array U
®                                :Map each Z
 d                               :  For each pair of characters in the following string,
                                 :  replace all occurrences of the 1st character in Z with the 2nd
  `z...m`                        :    The compressed string "znewem"
         i                       :    Prepend
          `o...g`                :      The compressed string "oireasglbg"
                 í               :      Interleave 0-based indices
                  )              :    End prepend
                   Ô             :    Reverse
                    u            :    Convert to uppercase
                     )           :  End replace
                      ñ          :  Sort
                        x        :  Trim
                         Ã       :End map
                          r      :Reduce
                           ¶     :  By testing equality

Python 2 , 145 131 130 129 125 bytes

lambda*a:all(len({sum(map(w.count,x))for w in a})<2for x in'A4 B8 CU EMW3 G69 I1 L7 NZ O0 R2 S5'.split()+list('DFHJKPQTVXY'))

Experimente online!

Alt:

Python 2 , 125 bytes

lambda*a:len({(x,sum(map(w.count,x)))for x in'A4 B8 CU EMW3 G69 I1 L7 NZ O0 R2 S5'.split()+list('DFHJKPQTVXY')for w in a})<23

Experimente online!

Ruby , 99 72 71 bytes

->a{!!a.map{|x|x.tr("0-9UZMW","OIREASGLBGCNE").chars.sort-[" "]}.uniq!}

Experimente online!

Pega uma matriz de seqüências de caracteres, assume entrada em maiúsculas como em todos os casos de teste.

-1 byte jogado por benj2240.

JavaScript (ES6), 102 100 bytes

Recebe entrada como duas matrizes de caracteres na sintaxe de currying (a)(b). Retorna um booleano.

a=>b=>(g=s=>s.map(c=>'648UD3F6H1JK73Z0PQ25TUV3'[parseInt(c,36)-9]||c).sort().join``.trim())(a)==g(b)

Experimente online!

Quão?

Usando a função auxiliar g () , para cada entrada s :

• Os dígitos 0 a 8 e as letras X , Y e Z permanecem inalterados. Tudo o resto é explicitamente traduzido.

  0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
           ↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓
  .........648UD3F6H1JK73Z0PQ25TUV3...
  

  Código:

  s.map(c => '648UD3F6H1JK73Z0PQ25TUV3'[parseInt(c, 36) - 9] || c)

• Classificamos os caracteres (que trazem todos os espaços no início), juntamos a eles e removemos todos os espaços em branco à esquerda.

  Código:

  .sort().join``.trim()

Finalmente, comparamos as duas saídas.

Retina 0.8.2 , 42 bytes

T` dUZMW`_\OIR\EASG\LBGCN\E
%O`.
^(.*)¶\1$

Experimente online! Recebe entrada em linhas separadas, mas o Link inclui casos de teste e cabeçalho. Explicação:

T` dUZMW`_\OIR\EASG\LBGCN\E

Mapeie todas as letras para um conjunto mínimo, excluindo os espaços.

%O`.

Classifique cada sequência em ordem.

^(.*)¶\1$

Compare os dois valores.

APL (Dyalog Unicode) , 49 bytes ^SBCS

-1 graças a ngn.

Função de prefixo tácito anônimo.

(≡/(⍋⌷¨⊂)¨)(,¨⎕D,'UMWZ ')⎕R('OIREASGLBGCEEN',⊂⍬)

Experimente online!

⎕R PCRE R moran Jr.:
 'UMWZ ' esses cinco caracteres
 ⎕D, precedidos das dígitos
 ,¨ separadamente (fazer cada um em uma corda ao invés de ser um único caractere)
 com:
 ⊂⍬ nada
 'OIREASGLBGCEEN', precedido por esses personagens

(… ) Aplique a seguinte função tácita a isso:

 (… )¨ Aplique a seguinte função tácita a cada um:

  ⊂ coloque-o (para tratá-lo como um todo)

  ⍋⌷¨ use cada um dos índices que a classificariam para indexar em toda a sequência (classificações)

 ≡/ eles são idênticos? (lit. redução de correspondência)

Python 2 , 108 bytes

lambda a,b:g(a)==g(b)
g=lambda s:sorted('85930A4614012B3C4D5EF6378GH9AI2J3KL7'[int(c,36)]for c in s if'!'<c)

Experimente online!

Existem 23 classes de equivalência de caracteres. Usando a cadeia de 36 caracteres '85930A4614012B3C4D5EF6378GH9AI2J3KL7', mapeamos cada caractere para sua classe de equivalência (ignorando espaços) e, em seguida, classificamos a matriz resultante. Duas cadeias são equivalentes se as listas resultantes forem iguais.

Java 10, 262 260 258 216 208 174 bytes

a->b->n(a).equals(n(b));String n(String s){return s.chars().mapToObj(x->x<48?"":"OIREASGLBG.......ABCDEFGHIJKLENOPQRSTCVEXYN".split("")[x-48]).sorted().reduce("",(a,b)->a+b);}

-2 bytes graças a @Arnauld .
-76 bytes graças a @ OlivierGrégoire .

Experimente online.

Explicação:

a->b->                      // Method with two String parameters and boolean return-type
  n(a).equals(n(b))         //  Return if both Strings are equal in the end

String n(String s){         // Separated method with String as both parameter return-type
  return s.chars()          //  Loop over all characters as integers
          .mapToObj(x->x<48?//   If the current character is a space:
             ""             //    Replace it with an empty String to skip it
            :               //   Else:
             "OIREASGLBG.......ABCDEFGHIJKLENOPQRSTCVEXYN".split("")[x-48]
                            //    Convert multi-substitution characters to a single one
          .sorted()         //  Sort all of the converted characters
          .reduce("",(a,b)->a+b);}
                            //  And join all of them together as single String

R , 123 bytes

function(x,y=chartr("48UMW36917Z025","ABCEEEGGILNORS",gsub(" ","",x)))all(g(y[1])==g(y[2]))
g=function(z)sort(utf8ToInt(z))

Experimente online!

utf8ToInt converte uma string em um vetor de pontos de código Unicode.

!sd(a-b)é um byte menor que,all(a==b) mas isso não ajuda aqui, porque na verdade estou lidando com números inteiros e não lógicos.

J , 56 bytes

-:&(-.&' '/:~@rplc'0123456789UMWZ';"0'OIREASGLBGCEEN'"1)

Experimente online!

Explicação:

& para argumentos à esquerda e à direita

-.&' ' remove espaços da entrada,

rplc substitui

'0123456789UMWZ';"0'OIREASGLBGCEEN'"1 os caracteres na entrada substituindo os caracteres na coluna da esquerda pelos caracteres da direita: (aqui transpostos para economizar espaço)

      |:'0123456789UMWZ';"0'OIREASGLBGCEEN'
┌─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│4│5│6│7│8│9│U│M│W│Z│
├─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┼─┤
│O│I│R│E│A│S│G│L│B│G│C│E│E│N│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

/:~@ e classifica as seqüências resultantes

-: as seqüências ordenadas são iguais?

Minha solução inicial:

J , 77 73 bytes

-:&(1#.(' '-.~])e."1[:(,a.,.@-.,)'EMW3','G69',9 2$'A4B8CUI1L7NZO0R2S5'"1)

Experimente online!

Explicação:

(' '-.~]) remove espaços dos argumentos e

e."1 testa cada caractere quanto à associação na tabela a seguir:

[:(,a.,.@-.,)'EMW3','G69',9 2$'A4B8CUI1L7NZO0R2S5'"1 A referência:

EMW3
G69 
A4  
B8  
CU  
I1  
L7  
NZ  
O0  
R2  
S5  
.
.
.  
All other symbols one in a row

1#. adiciona as tabelas de comparação para cada argumento

-:& eles combinam?

Perl 6 , 55 bytes

{[eq] .map:{sort TR/0..9UZMW/OIREASGLBGCNEE/~~m:g/\S/}}

Experimente online!

Funciona com um número arbitrário de seqüências de caracteres.

Python 2 , 111 bytes

lambda*t:2>len({`sorted(s.translate(dict(map(None,map(ord,'48UMW36917Z025 '),u'ABCEEEGGILNORS'))))`for s in t})

Experimente online!

116 bytes

lambda a,b:g(a)==g(b)
g=lambda s,y='4A8BUCMEWE3E6G9G1I7LZN0O2R5S ':y and g(s.replace(y[0],y[1:2]),y[2:])or sorted(s)

Experimente online!

Python 3 , 105 bytes

lambda a,b:X(a)==X(b)
X=lambda s:sorted(("ABCEEEGGILNORS"+c)["48UMW36917Z025".find(c)]for c in s if' '<c)

Experimente online!

Geléia , 39 34 bytes

ØB“¡Œ5a`@ẓRɼ9ẓ“%-/İ"aU5®’ṃyḟ⁶ṢɗⱮ⁸E

Experimente online!

05AB1E , 38 33 bytes

εðK.•2Θ`ĆĀÑεÉ•u6«•B/óÕ¦•…CN9«‡{}Ë

Experimente online ou verifique todos os casos de teste .

Explicação:

ε                   # Map each value in the (implicit) input-list by:
 ðK                 #  Remove all spaces
   .•2Θ`ĆĀÑεÉ•      #  Push compressed string "abemwgilorsuz"
              u     #  To uppercase: "ABEMWGILORSUZ"
               6«   #  Append a 6: "ABEMWGILORSUZ6"
   •B/óÕ¦•          #  Push compressed integer 48333917025
          …CN9«     #  Append "CN9": "48333917025CN9"
   ‡                #  Transliterate; map all characters in "ABEMWGILORSUZ" in the
                    #  map-string to "48333917025CN9" at the same indices
    {               #  Then sort all characters
}                   # Close the map
 Ë                  # And check if both are equal (which is output implicitly)

Veja esta dica 05AB1E (seções Como compactar cadeias de caracteres que não fazem parte do dicionário? E Como compactar números inteiros grandes? ) Para entender por que .•2Θ`ĆĀÑεÉ•é "abemwgilorsuz"e •B/óÕ¦•é 48333917025.