Sustitución del imán de nevera

29

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

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

code-golf string decision-problem substitution maxb
fuente
2
Creo que 48 horas es un poco corto. ¿Qué pasa con las personas que solo juegan golf los fines de semana?
Adám
Buen punto, le daré una semana.
maxb
1
Otras sustituciones que podría considerar permitir son 7 para T, H para I (pero no 1 para H) y 2 para N o Z
Jeff Zeitlin
1
@JeffZeitlin Tuvimos una discusión sobre esto en el entorno limitado del desafío, y elegí excluir todas las sustituciones que no son reversibles. Dado Ty Lno son intercambiables, no puedo añadir T = 7. Lo mismo se aplica N = Z = 2, lo que implicaría eso N = Z = R = 2. Sin embargo, el tipo de sustituciones que sugiera haría una versión más difícil de este desafío, que podría publicar en otro momento. Solo quería ver si este tipo de desafíos serían bien recibidos primero.
maxb
1
@ 3D1T0R sí, la sustitución debe ir en ambos sentidos. La comprobación es si dos cadenas son reorganizaciones válidas entre sí . Tu ejemplo volvería false.
maxb

Respuestas:

4

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
Lanudo
fuente
¡Agradable, actualmente superando a Jelly! Creo que puedes hacer r¶al final para guardar 3 bytes.
ETHproductions
Oh, sí, me estaba olvidando de eso. Gracias, @ETHproductions.
Shaggy
10

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!

TFeld
fuente
10

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.

Kirill L.
fuente
Me gusta este enfoque! Espolvorea un poco más !para guardar un byte
benj2240
Sí, eso funciona, gracias.
Kirill L.
9

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.

Arnauld
fuente
6

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.

Neil
fuente
5

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)

Adán
fuente
''-> ⍬
ngn
@ngn No estoy seguro de por qué eso funciona, pero gracias de todos modos.
Adám
5

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.

Chas Brown
fuente
4

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
Kevin Cruijssen
fuente
2
"A4B8CUEMEWE3G6G9I1L7NZO0R2S5".split("(?<=\\G.{2})")parece funcionar ... aunque ni siquiera estoy seguro exactamente cómo. : p
Arnauld
@Arnauld Gracias, -2 bytes, y {2}puede ser .por otros -2 bytes. Tampoco estoy 100% seguro de cómo funciona. Sé que (?<= ... )se usa para dividir, pero sigue delimitador final por elemento . Pero estoy un poco confundido por qué (?=\\G..)(seguir delimitador principal) no funciona en ese sentido. Y tampoco sé realmente cómo actúa el \\G..vs ..en la división aquí. Veré si puedo resolverlo en alguna parte, porque no tengo curiosidad. ; p Gracias de cualquier manera por los bytes guardados. Es necesario recordar \\Gcuando se divide en bloques de tamaño par. :)
Kevin Cruijssen
1
@Arnauld Si quieres un poco de información sobre (?<=\\G..)una división, he hecho una pregunta de StackoverFlow que arroja algo de luz. Básicamente es un comportamiento indefinido que funciona de manera diferente en casi todos los idiomas. Aunque \Ges de longitud cero, en Java con el aspecto positivo dentro de la división, entra en conflicto con ambas reglas causando el comportamiento que vemos aquí. Todavía es un poco vago para mí personalmente, pero al menos ahorró 4 bytes en esta respuesta. ;)
Kevin Cruijssen
1
217 bytes . Sin embargo, puede guardar más bytes.
Olivier Grégoire
1
174 bytes .
Olivier Grégoire
3

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.

ngm
fuente
¡Muy agradable! Creo que necesita !anyen lugar de !sdcomo los elementos podrían ser todos iguales, pero para 1. Pruebe:f(list("BCDEF","ABCDE"))
JayCe
2

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?

Galen Ivanov
fuente
2

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.

nwellnhof
fuente
2

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!

Lynn
fuente
1

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.

Kevin Cruijssen
fuente