Sostituzione del magnete del frigorifero

29

Quando scrivi un messaggio con i magneti per il frigo, spesso ti ritroverai a sostituire un 1con un I. In questa sfida, il tuo obiettivo è scoprire se un messaggio può essere scritto usando le lettere di un altro messaggio. Le sostituzioni consentite sono:

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

Ad esempio, il messaggio CIRCA 333può essere riorganizzato in modo da eseguire un incantesimo ICE CREAM, in cui i primi due 3secondi vengono ruotati di 180 gradi per fare due Esecondi e l'ultimo 3viene ruotato di 90 gradi in senso antiorario per creare un M. Gli spazi bianchi possono essere inclusi nei messaggi, ma non devono essere presi in considerazione nella soluzione, poiché vengono realizzati posizionando i magneti sul frigorifero.

Ingresso

Due stringhe (o array di caratteri). Tutti i messaggi corrisponderanno^[A-Z0-9 ]+$

Produzione

Veramente se le due stringhe di input sono riorganizzazioni valide l'una dell'altra, false in caso contrario.

Esempi

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

Esempi più sinceri

Queste sono tutte le parole di oltre 15 lettere associate a un'altra parola. Alcune sono sostituzioni banali, ma ho incluso tutto quello che ho trovato.

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

Dato che si tratta di una sfida del codice golf, vince la soluzione più breve! Accetterò la soluzione più breve tra 7 giorni dalla pubblicazione. Buon golf!

Soluzione campione, non golfata

Relazionato

EDIT : ha commesso un errore nelle sostituzioni G = 6e, 6 = 9come sostituzioni separate, le ha unite in una.

code-golf  string  decision-problem  substitution 
— maxb
fonte
2
Penso che 48 ore siano un po 'brevi. Che dire delle persone che giocano a golf solo nei fine settimana?
— Adám,
Buon punto, lo darò una settimana.
— max
1
Altre sostituzioni che potresti considerare di concedere sono 7 per T, H per I (ma non 1 per H) e 2 per N o Z
— Jeff Zeitlin,
1
@JeffZeitlin Ne abbiamo discusso nella sandbox della sfida e ho scelto di escludere tutte le sostituzioni che non sono reversibili. Dal momento che Te Lnon sono scambiabili, non posso aggiungere T = 7. Lo stesso vale N = Z = 2, il che implicherebbe questo N = Z = R = 2. Tuttavia, il tipo di sostituzioni che suggerisci renderebbe una versione più difficile di questa sfida, che potrei pubblicare in un secondo momento. Volevo solo vedere se questo tipo di sfide sarebbe stato accolto per primo.
— max
1
@ 3D1T0R sì, la sostituzione deve andare in entrambe le direzioni. Il controllo è se due stringhe sono riorganizzazioni valide l' una dell'altra . Il tuo esempio sarebbe tornato false.
— massimo

Risposte:

4

Japt , 38 36 33 30 byte

Accetta l'input come una matrice di 2 stringhe.

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

Provalo o esegui tutti i casi di test

3 byte salvati grazie 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
— ispido
fonte
Bello, attualmente batte Jelly! Penso che r¶alla fine si possa fare per salvare 3 byte.
— ETHproductions
Oh, sì, lo stavo dimenticando. Grazie, @ETHproductions.
— Shaggy,
10

Python 2 , 145 131 130 129 125 byte

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

Provalo online!

alt:

Python 2 , 125 byte

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

Provalo online!

— TFeld
fonte
9

JavaScript (ES6), 102 100 byte

Accetta input come due matrici di caratteri nella sintassi del curry (a)(b). Restituisce un valore booleano.

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

Provalo online!

Come?

Usando la funzione helper g () , per ogni input s :

  • Le cifre da 0 a 8 e le lettere X , Y e Z rimangono invariate. Tutto il resto è esplicitamente tradotto.

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

    Codice:

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

  • Ordiniamo i personaggi (che portano tutti gli spazi all'inizio), li uniamo e rimuoviamo tutti gli spazi bianchi principali.

    Codice:

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

Infine, confrontiamo entrambi gli output.

— Arnauld
fonte
6

Retina 0.8.2 , 42 byte

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

Provalo online! Accetta input su righe separate, ma Link include casi di test e intestazione. Spiegazione:

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

Mappa tutte le lettere su un set minimo, eliminando gli spazi.

%O`.

Ordina ogni stringa in ordine.

^(.*)¶\1$

Confronta i due valori.

— Neil
fonte
5

APL (Dyalog Unicode) , SBCS da 49 byte

-1 grazie a ngn.

Funzione prefisso tacito anonimo.

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

Provalo online!

⎕R PCRE R eplace:
 'UMWZ ' questi cinque caratteri
 ⎕D, preceduti dalle cifre
 ,¨ separatamente (trasformali ciascuno in una stringa anziché essere un singolo carattere)
 con:
 ⊂⍬ nulla
 'OIREASGLBGCEEN', preceduto da questi caratteri

(... ) applica la seguente funzione tacita a quella:

 (... )¨ applica la seguente funzione tacita a ciascuno:

  ⊂ racchiuderlo (per trattarlo nel suo insieme)

  ⍋⌷¨ usa ciascuno degli indici che lo ordinerebbero per indicizzarlo nell'intera stringa (ordinamenti)

 ≡/ sono identici? (lett. riduzione partita)

— Adamo
fonte
''-> ⍬
— ngn,
@ngn Non so perché funzioni, ma grazie comunque.
— Adám,
5

Python 2 , 108 byte

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

Provalo online!

Esistono 23 classi di equivalenza di caratteri. Usando la stringa di 36 caratteri '85930A4614012B3C4D5EF6378GH9AI2J3KL7', mappiamo ogni carattere alla sua classe di equivalenza (ignorando gli spazi), quindi ordiniamo l'array risultante. Due stringhe sono equivalenti se gli elenchi risultanti sono uguali.

— Chas Brown
fonte
4

Java 10, 262 260 258 216 208 174 byte

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

Provalo online.

Spiegazione:

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})")sembra funzionare ... anche se non sono nemmeno sicuro di come. : p
— Arnauld,
@Arnauld Grazie, -2 byte, e {2}può essere .per altri -2 byte. Inoltre, non sono sicuro al 100% di come funzioni. So che (?<= ... )è usato per dividere, ma mantenere il delimitatore finale per elemento . Ma sono un po 'confuso perché (?=\\G..)(continua a guidare il delimitatore) non funziona in questo senso. E inoltre non so davvero come agisca il \\G..vs ..nella divisione qui. Vedrò se riesco a capirlo da qualche parte, perché non sono curioso. ; p Grazie in entrambi i modi per i byte salvati. È necessario ricordare \\Gquando si divide su blocchi di dimensioni pari. :)
— Kevin Cruijssen
1
@Arnauld Se vuoi uno sfondo (?<=\\G..)all'interno di una divisione, ho fatto una domanda StackoverFlow che ha fatto luce. Fondamentalmente è un comportamento indefinito che funziona in modo diverso in quasi tutte le lingue. Sebbene \Gsia di lunghezza zero, in Java con l'aspetto positivo all'interno della divisione, è in conflitto con entrambe le regole che causano il comportamento che vediamo qui. Personalmente è ancora un po 'vago per me personalmente, ma almeno ha salvato 4 byte in questa risposta. ;)
— Kevin Cruijssen
1
217 byte . Può salvare più byte, però.
— Olivier Grégoire,
1
— Olivier Grégoire,
3

R , 123 byte

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

Provalo online!

utf8ToInt converte una stringa in un vettore di punti di codice Unicode.

!sd(a-b)è un byte più breve diall(a==b) ma non aiuta qui perché in realtà ho a che fare con numeri interi e non logici.

— ngm
fonte
Molto bella! Penso che sia necessario !anyal posto di !sdcome gli elementi potrebbero essere tutti uguali, ma per 1. Prova:f(list("BCDEF","ABCDE"))
— JayCe
2

J , 56 byte

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

Provalo online!

Spiegazione:

& per entrambi gli argomenti sinistro e destro

-.&' ' rimuove gli spazi dall'input,

rplc sostituisce

'0123456789UMWZ';"0'OIREASGLBGCEEN'"1 i caratteri nell'input per sostituzione dei caratteri nella colonna di sinistra con quelli in quella di destra: (qui trasposti per risparmiare spazio)

      |:'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 ordina le stringhe risultanti

-: le stringhe ordinate sono uguali?

La mia soluzione iniziale:

J , 77 73 byte

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

Provalo online!

Spiegazione:

(' '-.~]) rimuove gli spazi da entrambi gli argomenti e

e."1 testa ogni personaggio per l'appartenenza alla seguente tabella:

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

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

1#. aggiunge le tabelle di confronto per ciascun argomento

-:& si abbinano?

— Galen Ivanov
fonte
2

Python 2 , 111 byte

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

Provalo online!

116 byte

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)

Provalo online!

— Lynn
fonte
1

05AB1E , 38 33 byte

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

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezioni Come comprimere le stringhe che non fanno parte del dizionario? E Come comprimere numeri grandi? ) Per capire perché .•2Θ`ĆĀÑεÉ•è "abemwgilorsuz"ed •B/óÕ¦•è 48333917025.

— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.