Substituição de imã de geladeira

29

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

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

code-golf string decision-problem substitution maxb
fonte
2
Eu acho que 48 horas é um pouco curto. E as pessoas que só jogam golfe nos finais de semana?
Adám 15/05/19
Bom ponto, vou dar uma semana.
Max15
11
Outras substituições que pode considerar permitindo que são 7 para T, H para I (mas não um de H), e dois para N ou Z
Jeff Zeitlin
11
@JeffZeitlin Tivemos uma discussão sobre isso na sandbox do desafio e escolhi excluir todas as substituições que não são reversíveis. Desde Te Lnão são permutáveis, não posso adicionar T = 7. O mesmo vale para N = Z = 2, o que implicaria isso N = Z = R = 2. No entanto, o tipo de substituição que você sugere tornaria uma versão mais difícil desse desafio, que eu poderia publicar posteriormente. Eu só queria ver se esse tipo de desafio seria bem recebido primeiro.
Max15
11
@ 3D1T0R sim, a substituição deve seguir os dois lados. A verificação é se duas seqüências de caracteres são rearranjos válidos um do outro . Seu exemplo retornaria false.
Max15

Respostas:

4

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
Shaggy
fonte
Bom, atualmente batendo Jelly! Eu acho que você pode fazer r¶no final para salvar 3 bytes.
ETHproductions
Ah, sim, eu estava esquecendo disso. Obrigado, @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'))

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!

TFeld
fonte
10

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.

Kirill L.
fonte
Eu gosto dessa abordagem! Polvilhe em um pouco mais !para salvar um byte
benj2240
Sim, isso funciona, obrigado.
Kirill L.
9

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.

Arnauld
fonte
6

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.

Neil
fonte
5

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)

Adão
fonte
''-> ⍬
NGN
@ngn Não sei por que isso funciona, mas obrigado de qualquer maneira.
Adám 15/05/19
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)

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.

Chas Brown
fonte
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 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
Kevin Cruijssen
fonte
2
"A4B8CUEMEWE3G6G9I1L7NZO0R2S5".split("(?<=\\G.{2})")parece funcionar ... embora eu nem saiba exatamente como. : p
Arnauld 15/05
@ Arnauld Obrigado, -2 bytes, e {2}pode ser .por outro -2 bytes. Também não tenho 100% de certeza de como isso funciona. Eu sei que (?<= ... )é usado para dividir, mas continuo delimitador por item . Mas estou um pouco confuso por que (?=\\G..)(continuar liderando delimitador) não funciona nesse sentido. E também não sei realmente como o \\G..vs ..atua na divisão aqui. Vou ver se consigo descobrir em algum lugar, porque não estou curioso. ; p Agradecemos de qualquer maneira pelos bytes salvos. É necessário lembrar \\Gao dividir em blocos de tamanho uniforme. :)
Kevin Cruijssen
11
@ Arnauld Se você quiser saber mais sobre (?<=\\G..)uma divisão, eu fiz uma pergunta sobre StackoverFlow que esclareceu algumas coisas. Basicamente, é um comportamento indefinido que funciona de maneira diferente em quase todos os idiomas. Embora \Gseja de comprimento zero, em Java, com uma visão positiva por trás da divisão, meio que conflita as duas regras, causando o comportamento que vemos aqui. Ainda é um pouco vago para mim pessoalmente, mas pelo menos salvou 4 bytes nesta resposta. ;)
Kevin Cruijssen 16/05/19
11
217 bytes . Pode salvar mais bytes, no entanto.
Olivier Grégoire
11
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))

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.

ngm
fonte
Muito agradável! Acho que você precisa !anyno lugar de !sdcomo os elementos podem ser todos iguais, mas a 1. Tente:f(list("BCDEF","ABCDE"))
Jayce
2

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?

Galen Ivanov
fonte
2

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.

Nwellnhof
fonte
2

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!

Lynn
fonte
2

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!

RootTwo
fonte
2

Geléia , 39 34 bytes

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

Experimente online!

Erik, o Outgolfer
fonte
1

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.

Kevin Cruijssen
fonte