Al escribir un mensaje con imanes de nevera, a menudo te encontrarás sustituyendo a 1por un I. En este desafío, su objetivo es averiguar si un mensaje puede escribirse usando las letras de otro mensaje. Las sustituciones permitidas son:

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 ejemplo, el mensaje CIRCA 333se puede reorganizar para deletrear ICE CREAM, donde los primeros dos 3s se giran 180 grados para formar dos E, y el último 3se gira 90 grados en sentido antihorario para formar un M. Se pueden incluir espacios en blanco en los mensajes, pero no se deben tener en cuenta en su solución, ya que se hacen colocando los imanes en el refrigerador.

Entrada

Dos cadenas (o matrices de caracteres). Todos los mensajes coincidirán^[A-Z0-9 ]+$

Salida

Verdad si las dos cadenas de entrada son reorganizaciones válidas entre sí, de lo contrario falsey

Ejemplos

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

Más ejemplos veraces

Estas son todas las palabras de más de 15 letras que se asignan a otra palabra. Algunas son sustituciones triviales, pero incluí todo lo que encontré.

["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 se trata de un desafío de código de golf, ¡la solución más corta gana! Aceptaré la solución más corta en 7 días desde la publicación. ¡Feliz golf!

Solución de muestra, sin golf

Relacionado

• El alfabeto de mi hija

• Cartas de baño de espuma

EDITAR : cometió un error en las sustituciones, tenía G = 6y, 6 = 9como sustituciones separadas, las fusionó en una sola.

Japt , 38 36 33 30 bytes

Toma la entrada como una matriz de 2 cadenas.

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

Pruébalo o ejecuta todos los casos de prueba

3 bytes guardados gracias a 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'))

Pruébalo en línea!

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

Pruébalo en línea!

Ruby , 99 72 71 bytes

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

Pruébalo en línea!

Toma una serie de cadenas, asume la entrada en mayúsculas como en todos los casos de prueba.

-1 byte golfizado por benj2240.

JavaScript (ES6), 102100 bytes

Toma datos como dos matrices de caracteres en la sintaxis de curry (a)(b). Devuelve un booleano.

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

Pruébalo en línea!

¿Cómo?

Usando la función auxiliar g () , para cada entrada s :

• Los dígitos del 0 al 8 y las letras X , Y y Z no se modifican. Todo lo demás está traducido explícitamente.

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

  Código:

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

• Ordenamos los caracteres (que trae todos los espacios al principio), los unimos y eliminamos todos los espacios en blanco iniciales.

  Código:

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

Finalmente, comparamos ambas salidas.

Retina 0.8.2 , 42 bytes

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

Pruébalo en línea! Toma información en líneas separadas, pero Link incluye casos de prueba y encabezado. Explicación:

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

Asigna todas las letras a un conjunto mínimo, eliminando los espacios.

%O`.

Ordenar cada cadena en orden.

^(.*)¶\1$

Compara los dos valores.

APL (Dyalog Unicode) , ^{SBCS de} 49 bytes

-1 gracias a ngn.

Función de prefijo tácito anónimo.

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

Pruébalo en línea!

⎕R PCRE R eplace:
 'UMWZ ' estos cinco caracteres
 ⎕D, precedidos por los dígitos por
 ,¨ separado (cada uno en una cadena en lugar de ser un solo carácter)
 con:
 ⊂⍬ nada
 'OIREASGLBGCEEN', precedido por estos caracteres

(… ) Aplica la siguiente función tácita a eso:

 (… )¨ Aplique la siguiente función tácita a cada uno:

  ⊂ adjuntarlo (para tratarlo como un todo)

  ⍋⌷¨ use cada uno de los índices que lo ordenarían para indexar en toda la cadena (ordena)

 ≡/ son idénticos? (lit. reducción de partido)

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)

Pruébalo en línea!

Hay 23 clases de equivalencia de caracteres. Usando la cadena de 36 caracteres '85930A4614012B3C4D5EF6378GH9AI2J3KL7', asignamos cada carácter a su clase de equivalencia (ignorando espacios), luego ordenamos la matriz resultante. Dos cadenas son equivalentes si las listas resultantes son iguales.

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 gracias a @Arnauld .
-76 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

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

Pruébalo en línea!

utf8ToInt convierte una cadena en un vector de puntos de código Unicode.

!sd(a-b)es un byte más corto queall(a==b) eso, pero eso no ayuda aquí porque en realidad estoy tratando con números enteros y no lógicos.

J , 56 bytes

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

Pruébalo en línea!

Explicación:

& para los argumentos izquierdo y derecho

-.&' ' elimina espacios de la entrada,

rplc reemplaza

'0123456789UMWZ';"0'OIREASGLBGCEEN'"1 los caracteres en la entrada por sustitución de los caracteres en la columna de la izquierda con los de la derecha: (aquí transpuesta para ahorrar espacio)

      |:'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│
└─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┴─┘

/:~@ y ordena las cadenas resultantes

-: son iguales las cuerdas ordenadas?

Mi solución inicial:

J , 77 73 bytes

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

Pruébalo en línea!

Explicación:

(' '-.~]) elimina espacios de ambos argumentos y

e."1 prueba cada personaje para pertenecer a la siguiente tabla:

[:(,a.,.@-.,)'EMW3','G69',9 2$'A4B8CUI1L7NZO0R2S5'"1 la referencia:

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

1#. suma las tablas de comparación para cada argumento

-:& ¿se complementan?

Perl 6 , 55 bytes

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

Pruébalo en línea!

Funciona con un número arbitrario de cadenas.

Python 2 , 111 bytes

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

Pruébalo en línea!

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)

Pruébalo en línea!

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)

Pruébalo en línea!

Jalea , 39 34 bytes

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

Pruébalo en línea!

05AB1E , 38 33 bytes

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ε                   # 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)

Vea esta sugerencia mía 05AB1E (secciones ¿Cómo comprimir cadenas que no forman parte del diccionario? Y ¿Cómo comprimir enteros grandes? ) Para comprender por qué .•2Θ`ĆĀÑεÉ•es "abemwgilorsuz"y •B/óÕ¦•es 48333917025.