Scrabble a tessere consumate


35

Problema

Sei bloccato in una capanna in mezzo al bosco, con solo un vecchio scarabocchio pronto a divertirti. All'ispezione si vede che le lettere scrabble sono così usurate, che sono visibili solo i punti per ogni lettera.

Tuttavia, decidi di giocare. Prendi sette lettere dalla borsa e le metti sul tuo vassoio, la tua sfida è determinare quali potrebbero essere quelle lettere.

Quindi, in generale, dato un elenco di punti convertirlo in qualsiasi possibile stringa o elenco di lettere.


Piastrelle Scrabble e Distribuzioni

  • 2 tessere vuote (segnando 0 punti)
  • 1 punto: E × 12, A × 9, I × 9, O × 8, N × 6, R × 6, T × 6, L × 4, S × 4, U × 4
  • 2 punti: D × 4, G × 3
  • 3 punti: B × 2, C × 2, M × 2, P × 2
  • 4 punti: F × 2, H × 2, V × 2, L × 2, Y × 2
  • 5 punti: K × 1
  • 8 punti: J × 1, X × 1
  • 10 punti: Q × 1, Z × 1

Quindi, se hai un elenco di punti, [10,10,8,5,1,1,1]allora "QZJKEEE"sarebbe valido ma "QQJKEEE"non sarebbe valido (dal momento che nella borsa c'è solo 1 tessera Q)


Regole specifiche del problema

  • Puoi presumere che tutti gli input siano validi e che ci saranno sempre 7 tessere (cioè non sarà un elenco di sette tessere da 10 punti e non saranno 9 tessere)
  • Si può presumere che nessuna tessera sia stata precedentemente estratta dalla borsa (quindi la distribuzione è la distribuzione standard delle tessere inglesi come definita sopra)
  • Non è necessario generare una parola valida, ma solo una stringa di lettere valida.
  • L'ordine della stringa è irrilevante purché per ogni riquadro sia presente una lettera corrispondente.
  • I punti si basano sui punti standard delle tessere scrabble inglesi come definito sopra.
  • È possibile produrre in maiuscolo o minuscolo, per un riquadro vuoto è possibile generare un carattere spazio o un carattere di sottolineatura '_'
  • La tua risposta può essere prodotta come una rappresentazione ragionevole dei riquadri come Elenco, Stringa, Matrice o Sequenza

Regole generali:

  • Questo è , quindi vince la risposta più breve in byte.
    Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
  • Per la tua risposta valgono regole standard con regole I / O predefinite , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
  • Sono vietate le scappatoie predefinite .
  • Se possibile, aggiungi un link con un test per il tuo codice (ad es. TIO ).
  • Inoltre, si consiglia vivamente di aggiungere una spiegazione per la risposta.

Casi test

Ovviamente, poiché è possibile generare qualsiasi valore possibile, è difficile definire casi di test rigorosi.

Alcuni casi con un possibile valido valore di ritorno :

[10,0,10,5,8,8,0] -> "Q ZKJX "
[1,1,1,1,1,1,1] -> "EEEEEEE"
[1,2,3,4,5,8,0] -> "NDBHKJ "
[2,2,2,2,2,2,2] -> "DGDGDGD"

Alcuni casi con un valore di ritorno non valido :

[10,0,10,5,8,8,0] -> "Q QKJX "  - Too many Qs 
[1,1,1,1,1,1,1] -> "EEEEEE "  - Space is 0 points not 1
[1,2,3,4,5,8,0] -> "NDBH" - Too short
[1,2,3,4,5,8,0] -> "NDBHKJ  I" - Too long
[1,2,3,4,5,8,0] -> "ÉDBHKJ1" - Contains none scrabble characters
[2,2,2,2,2,2,2] -> "GDGDGDG" - Contains too many Gs (case for invalid cycling)

Devo emettere una stringa o è un elenco ok?
Maltysen,

Puoi generare un elenco, aggiornerò la domanda
Dati scaduti il

1
Cosa posso produrre per uno spazio?
Maltysen,

3
Caso di prova suggerito: [2,2,2,2,2,2,2](l'unico caso in cui è importante iniziare con un metodo Danziché con un Gmetodo di ciclismo)
Arnauld

1
Le notifiche sono @, quindi il nome della persona senza spazi. Vale a dire che i dati scaduti diventerebbero @ExpiredData.
Tau,

Risposte:


8

JavaScript (ES6), 72 byte

Una variante più breve suggerita da @supercat

a=>a.map(o=n=>'?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31])

Provalo online!


JavaScript (ES6),  137 ... 84 78 77  76 byte

Salvato 10 byte utilizzando il metodo di ciclismo di Neil

Restituisce un elenco di tessere. usi_ per tessere vuote.

a=>a.map(o=n=>"____FHVWGDGD_K__BCMPEEEE_ZQ__XJ"[n*20%44%32+(o[n]=-~o[n])%4])

Provalo online!

Come?

Per ogni numero di punti, passiamo attraverso un gruppo di esattamente 4 tessere, iniziando con la seconda tessera di ciascun gruppo (questo è importante per Gvs D):

 points | group | max. sequence
--------+-------+---------------
    0   | ____  | __
    1   | EEEE  | EEEEEEE
    2   | GDGD  | DGDGDGD
    3   | BCMP  | CMPBCMP
    4   | FHVW  | HVWFHVW
    5   | _K__  | K         \
    8   | _XJ_  | XJ         }--- these letters may only appear once each
   10   | _ZQ_  | ZQ        /

Tutti questi gruppi sono memorizzati come una singola stringa di 31 caratteri:

____FHVWGDGD_K__BCMPEEEE_ZQ__XJ
^   ^   ^   ^   ^   ^   ^   ^
0   4   8  12  16  20  24  28

NB : Non è necessario archiviare la finale "_"in "_XJ_", poiché non sarà comunque possibile accedervi.

nion

ion=((20×n)mod44)mod32

  n | *20 | mod 44 | mod 32 | group
----+-----+--------+--------+-------
  0 |   0 |    0   |    0   | ____
  1 |  20 |   20   |   20   | EEEE
  2 |  40 |   40   |    8   | GDGD
  3 |  60 |   16   |   16   | BCMP
  4 |  80 |   36   |    4   | FHVW
  5 | 100 |   12   |   12   | _K__
  8 | 160 |   28   |   28   | _XJ_
 10 | 200 |   24   |   24   | _ZQ_

o


Avanzare o [n] di 8 ogni volta costerebbe un carattere in più per l'avanzamento, ma consentirebbe di sostituire% 4 e% 32 entrambi con & 31 per una vittoria netta. Il mio meglio, basato sul tuo, sarebbe a=>a.map(o=n=>('?ED?BWQ?_EG?CFZ?_EDJMH?K?EGXPV'[n*9.4+(o[n]=7-~o[n])&31])). Una versione più "corta" è, a=>a.map(o=n=>("_EDBFK_EDCHJQEGMVXZEGPW"[n+(o[n]=5-~o[n])%24]))ma quell'approccio avrebbe bisogno di un modo compatto per mappare i valori 8 e 10 in 11 e 12, oltre a una leggera regolazione della stringa per risolvere un problema off-by-one.
supercat

@supercat Sembra buono! Lo guarderò più da vicino domani.
Arnauld,

@supercat Un'altra formula interessante è '_??VKWZHQFP?M?CGBGXDJD'[(n*96+(o[n]=32-~o[n]))%68%33]||'E', con una stringa di ricerca di soli 22 caratteri. Tuttavia, il codice completo è ancora 2 byte più lungo della soluzione.
Arnauld,

7

Carbone , 33 byte

⭆觧⪪”&↖“Vh_z↶∕¡⌈∨₂χ¹‖◨⌊″”¶ι№…θκι

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

 θ                  Input array
⭆                   Map over elements and join
     ”...”          Literal string " \nE\nDG\nBCMP\nFHVW\nK\n\n\nJX\n\nQZ"
    ⪪     ¶         Split on newlines
   §       ι        Indexed by current element
  §                 Cyclically indexed by
            №…θκι   Number of times current element has already appeared
                    Implcitly print

5

Gelatina ,  31 30 27  26 byte

“ñẒẎYñ(“Nut¦hß’ṃØA;€⁶ɓṢĖœị

Un collegamento monadico che accetta un elenco di numeri interi che produce un elenco di caratteri.
- un miscuglio del mio precedente, di seguito, e del mio miglioramento di Nick Kennedy

Provalo online!

L'output non viene fornito nello stesso ordine dell'input (ciò è consentito).

L'uso di 2 delle mie aggiunte alla lingua in una risposta non accade spesso! ( eɓ qui).

Come?

“...“...’ṃØA;€⁶ɓṢĖœị - Link: list of integers, V     e.g. [10,1,0,3,2,1,10]
“...“...’            - list of base 250 integers          [28089224382041, 77611203526272]
          ØA         - 'ABC...XYZ'
         ṃ           - base decompress (vectorises)       ["EDMFKZZJZQ", "NGPYKZZXZZ"]
            ;€       - for €ach: concatenate:
              ⁶      -   a space                          ["EDMFKZZJZQ ", "NGPYKZZXZZ "]
               ɓ     - start a new dyadic chain with swapped arguments - i.e. f(V,that)
                Ṣ    - sort                               [0,1,1,2,3,10,10]
                 Ė   - enumerate                          [[1,0],[2,1],[3,1],[4,2],[5,3],[6,10],[7,10]]
                  œị - multi-dimensional index into       " NEGMZQ"
                       (1-based and modular)

precedente @ 30

“²rṛʂṂø5=Ɓṇ^N¥Y»⁾tky;⁶s2ɓṢĖUœị

Un collegamento monadico che accetta un elenco di numeri interi che produce un elenco di caratteri.

Provalo online!

Anche questo output è in maiuscolo (questo è permesso).

Come?

“...»⁾tky;⁶s2ɓṢĖUœị - Link: list of integers, V          e.g. [10,1,0,3,2,1,10]
“...»               - compression of dictionary entries:
                    -   "end", "GMP", "fyttes", "adj", and "xci" and the string "qz"
                    -                                         "endGMPfyttesadjxciqz"
        y           - translate with:
     ⁾tk            -   ['t', 'k']                            "endGMPfykkesadjxciqz"
         ;⁶s2ɓṢĖUœị - ...
                    - ...then like the above method (except U reverses each pair of indices)
                                                              " neGMzq"

Penso che tu abbia fatto un refuso nella tua prima spiegazione. ' NWGMZQ'dopo l'indice multidimensionale in sarebbe un'impresa senza nessuno Wnella stringa. ;)
Kevin Cruijssen l'

1
@KevinCruijssen - yws, typo fixwd; Grazie!
Jonathan Allan l'

4

Pyth - 92 86 83 81 80 75 60 52 49 42 36 byte

Passa attraverso l'input, spuntando le lettere disponibili. Ho solo una lettera per ciascuna che insieme danno 7 per quella categoria di punti. Ora usando la codifica di stringa compressa.

K[M*L7c."B_êº çÑOÒ
7âCkÑ"\Lm.)@K

K                       Assign to K       
 [M                     Map list(for popping). Uses a quirk of M to splat each first
  *L7                   Map repeating each string by 7
   c      \L            Split on occurrences of 'L'
    ."..."              Packed string encoding of the needed letters
m              (Q)      Map on input (input is taken implicitly)
 .)                     Pop. This returns the first element after removing it
  @K                    Index into K
   (d)                  The loop variable is given implicitly

A proposito, questa è la stringa di lettera originale prima della codifica: "_ E DG BCMP FHVW K JX QZ".

Provalo online .



3

05AB1E , 70 52 39 38 29 26 25 byte

{ε.•3Oû}α›ηö‡.ÝŽ{•2ôÁyèNè?

-18 byte grazie a @ExpiredData .
-13 byte utilizzando lo stesso estendono a misura 7 da @Maltysen Pyth risposta s' .
-9 byte creando una porta della risposta Jelly di @JonathanAllan , quindi assicurati di votarlo!
-3 byte grazie a @Emigna .

Risultati in un elenco di caratteri e utilizza lettere minuscole e uno spazio per gli spazi.

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

{                      # Sort the (implicit) input-list
 ε                     # Map each character `y` in this list to:
  .•3Oû}α›ηö‡.ÝŽ{•     #  Push compressed string "endgmpfykkzzzzjxzzqz "
                  2ô   #  Split into parts of size 2
                    Á  #  Rotate it once towards the left so the space is leading
  yè                   #  Use integer `y` to index into the string-pairs
    Nè                 #  Then get the `N`'th character of the string-pair (with automatic
                       #   wraparound), where `N` is the index of the loop

Vedere questo 05AB1E punta del mio (sezione Come stringhe di comprimere che non fanno parte del dizionario? ) Per capire il motivo per cui .•3Oû}α›ηö‡.ÝŽ{•è "endgmpfykkzzzzjxzzqz ".


Risposta precedente 38 byte:

.•Mñ&Àû«ì{₆v*Å+µ-•#ðšε7∍}IvDyèн©?ε®õ.;

Provalo online o verifica alcuni altri casi di test .

Spiegazione:

.•Mñ&Àû«ì{₆v*Å+µ-•    # Push compressed string "e dg bcmp fhvw k   jx  qz"
                  #   # Split on spaces: ["e","dg","bcmp","fhvw","k","","","jx","","qz"]
                   ðš # Prepend a space to this list
 ε7∍}                 # Extend each string to size 7:
                      #  ["       ","eeeeeee","dgdgdgd","bcmpbcm","fhvwfhv","kkkkkkk","","","jxjxjxj","","qzqzqzq"]
     Iv               # Loop `y` over the input-list:
       Dyè            #  Get the `y`'th string from a copy of the list
          н           #  Get it's first character
           ©?         #  Store it in the register, and print it without trailing newline
        ε             #  Then map each string in the list to:
         ®õ.;         #   Remove the first occurrence of the character from the register

Vedere questo 05AB1E punta del mio (sezione Come stringhe di comprimere che non fanno parte del dizionario? ) Per capire il motivo per cui .•Mñ&Àû«ì{₆v*Å+µ-•è "e dg bcmp fhvw k jx qz".


Non puoi usare " 0eeeeeee0ddddggg0bbccmmp0ffhhvvw0k000jx00qz"?
Dati scaduti il

@ExpiredData Ah, certo. Disegna solo 7 lettere .. Grazie! Lo cambierà.
Kevin Cruijssen,

1
Puoi salvare 3 byte usando {vinvece di 7Fe yinvece di I{Nè.
Emigna,

@Emigna Ah, certo .. Grazie!
Kevin Cruijssen l'

2

C (gcc) , 110 byte

_[]={0,7,14,21,0,0,22,0,24};f(char*s){for(;*s+1;s++)*s=*s?*s-1?"DDDDGGGBBCCMMPFFHHVVWKJXQZ"[_[*s-2]++]:69:32;}

Provalo online!

Utilizza l' _array come indice nella stringa statica in "DDDDGGGBBCCMMPFFHHVVWKJXQZ"modo dinamico con eccezioni per 0 e 1.

L'argomento è una -1matrice di punteggi terminata che viene trasformata sul posto in una -1stringa terminata.




1

Gelatina , 34 32 byte

“¿RÇĊƈ⁸⁾%ỵṆþœsṀṂ’ṃØAṣ”A;⁶ẋ€7⁸ịḢ€

Provalo online!

Non avevo visto che c'era una risposta Jelly più breve quando ho scritto questo, e questo utilizza un approccio diverso, quindi ho pensato che valesse la pena pubblicare anche questo.

Grazie a @JonathanAllan per aver salvato 2 byte!


Usando la decompressione di base , puoi salvare 2 byte
Jonathan Allan il

1

Python 3 , 178 142 135 127 112 117 byte

def f(l):
 d=list(map(list,"  _EEEEEEE_DDDDGGG_BBCCMMP_FFHHVVW_K___JX__QZ".split('_')))
 return[d[i].pop()for i in l]

Provalo online!

-1 byte grazie a cdlane

corretto grazie a Mathmandan


in "-> in" per 111
cdlane il

d=list(map(list,"...".split('_')))per salvare un altro byte
cdlane il

fProbabilmente non è necessario assegnare un nome a questa funzione , quindi è possibile salvare 2 byte. Tuttavia, fconsuma le voci di d, quindi non sono sicuro che si adatti al requisito del consenso secondo cui "la funzione deve essere riutilizzabile arbitrariamente spesso, senza ... riaffermare ... qualsiasi altro codice che accompagna la presentazione." (Ad esempio, l'esecuzione f([10,0,10,5,8,8,0])più di una volta comporterebbe un errore.) Consulta la meta discussione qui: codegolf.meta.stackexchange.com/a/7615/36885
mathmandan,

0

Python 2 , 102 byte (o forse 95?)

(Va bene anche per Python 3.)

lambda a:''.join([r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a))

Provalo online!

Non penso che sarebbe accettabile quanto segue:

lambda a:[[r*7for r in'_ E DG BCMP FHVW K * * JX * QZ'.split()][x][:a.count(x)]for x in set(a)]

Questa seconda versione darebbe un output simile ['__', 'JX', 'QZ', 'K']. Quindi le lettere sarebbero corrette, ma sarebbero state raccolte in base al valore in punti. (Se questo fosse accettabile, risparmierebbe 7 byte.)


0

PHP , 101 byte

$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($argv as$t){echo$c=($d=$b[$t])[0];$b[$t]=substr($d,1).$c;}

Come programma autonomo, immettere tramite riga di comando:

$ php s.php 10 0 10 5 8 8 0
"Q_ZKJX_"

Provalo online!

O 112 byte in funzione

function($a){$b=[_,E,DG,BCMP,FHVW,K,8=>JX,0,QZ];foreach($a as$t)$b[$t]=substr($d=$b[$t],1).$c[]=$d[0];return$c;}

Provalo online!

Produzione

[10,0,10,5,8,8,0]   "Q_ZKJX_"
[1,1,1,1,1,1,1]     "EEEEEEE"
[1,2,3,4,5,8,0]     "EDBFKJ_"
[2,2,2,2,2,2,2]     "DGDGDGD"


0

Perl 6 , 63 byte

*>>.&{(<_ E DG BCMP FHVW K _ _ JX _ QZ>[$_]x 7).comb[%.{$_}++]}

Provalo online!

<_ E DG BCMP FHVW K _ _ JX _ QZ> # array indexed on tile value
(<...>[$_] x 7)     # pull letters for this value, repeat 7 times to catch E
          %         # anonymous stateful hash
           .{$_}    # element for this tile value
                ++  # post increment value to move position
       .comb[...]   # characters to array, pull this incrementing index

Quindi essenzialmente mantiene una ricerca degli offset per ogni valore di riquadro e li incrementa secondo necessità, usando l'offset per estrarre un carattere dal set disponibile.

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.