15

Ai fini di questa domanda, un mazzo di carte è formattato in questo modo:

[
  "AS", "2S", "3S", "4S", "5S", "6S", "7S", "8S", "9S", "10S", "JS", "QS", "KS", 
  "AD", "2D", "3D", "4D", "5D", "6D", "7D", "8D", "9D", "10D", "JD", "QD", "KD", 
  "AH", "2H", "3H", "4H", "5H", "6H", "7H", "8H", "9H", "10H", "JH", "QH", "KH", 
  "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "10C", "JC", "QC", "KC", 
  "J", "J"
]

Le carte sono sempre formattate come valore, seguite da semi. Ad esempio ASè l'asso di picche. I due singoli J sono Jolly. Vogliamo mescolare questo mazzo di carte, ma lo shuffle deve essere Superb ™.

Uno Superb Shuffle ™ è uno in cui:

Non sono adiacenti due carte (eccetto i Jolly) dello stesso seme.
Nessuna carta (eccetto i Jolly) è adiacente a uno dello stesso valore.
Nessuna carta (eccetto i Jolly) è adiacente a uno di un valore adiacente (uno superiore o uno inferiore in questo ordine, A, 2, 3, 4, 5, 6, 7, 8, 9, 10, J, Q, K, A. Nota che l'asso non può essere adiacente a un 2 o un Re).
I Jolly possono essere in qualsiasi posizione.
La definizione di Superb Shuffle ™ non richiede che le carte siano in un ordine diverso ogni volta che vengono mescolate. Che non è molto bello, ma è Superb ™.

Perché quello è Superb ™.

Un esempio potrebbe essere:

[
  "AS", "5D", "9H", "KC", "2D", "6H", "10C", "QS", "3H", "7C", "9S", 
  "KD", "4C", "6S", "10D", "AC", "3S", "7D", "JH", "J", "4D", "8H", 
  "QC", "AD", "5H", "9C", "JS", "2H", "6C", "8S", "QD", "3C", "5S", 
  "9D", "KH", "2S", "6D", "10H", "J", "3D", "7H", "JC", "KS", "4H", 
  "8C", "10S", "AH", "5C", "7S", "JD", "2C", "4S", "8D", "QH"
]

La sfida:

Scrivi del codice per eseguire uno shuffle eccezionale
Usa qualsiasi lingua
L'input può essere sia :
- un mazzo di carte come descritto sopra nello stesso ordine , come una matrice o altra struttura di lista.
- Nessun input (il codice genera un mazzo di carte in quell'ordine)
L'output deve essere un mazzo completo di carte in uno Shuffle ™ superbo come descritto sopra.
Tenta di eseguire il tuo Superb Shuffle ™ nel minor numero di byte.
È preferibile un collegamento a un interprete online come Try It Online , ma facoltativo.

Felice mescolando!

code-golf cards

— AJFaraday
fonte

1

In qualche modo correlato

— Shaggy,

Possiamo sostituire Tinvece di 10?

— Jo King,

@JoKing Non puoi. Proprio come la generazione di un mazzo di carte, le diverse lunghezze delle stringhe fanno parte della complessità.

— AJFaraday,

Siamo autorizzati a stampare ogni scheda separatamente come fa la risposta Charcoal o dobbiamo effettivamente restituire un array / elenco?

— Kevin Cruijssen,

@KevinCruijssen Va bene, fintanto che sta notevolmente restituendo un mazzo di carte in quel formato (valore quindi seme).

— AJFaraday,

5

Japt, 6 5 4 byte

Divide l'array di input in sotto-array di ogni 16 ° elemento e si appiattisce.

óG c

Provalo

— ispido
fonte

Devi appiattirlo?

— Oliver,

@Oliver, spero di no; in attesa che AJ confermi.

— Shaggy,

34

Rubino , 31 byte

->x{(0..53).map{|r|x[r*17%54]}}

Provalo online!

Spiegazione:

Prendo una carta, quindi salto le successive 16 e inizio dalla prima carta quando raggiungo l'ultima carta del mazzo. 17 e 54 sono reciprocamente primi, quindi sono sicuro di scegliere tutte le carte.

La 17a posizione è garantita per essere un seme diverso e la differenza di valore è almeno 2: la 13a (o 15a) carta ha lo stesso valore e un seme diverso, quindi saltando altre 4 (o 2), il valore è giusto .

— GB
fonte

6

Ben fatto per trovare il processo usato da ogni altra risposta;)

— AJFaraday,

3

Puoi spiegare come hai trovato * 17% 54? Solo prove ed errori o ci sono alcuni ovvi calcoli che mi mancano?

— Daniel,

@Daniel 17 è la distanza minima richiesta tra due carte diversamente diverse che non sono adiacenti numericamente (tenendo conto dei due jolly; ad esempio, 17 passaggi ti porta dall'asso di fiori al 3 di picche); 54 è il numero di carte nel mazzo.

— Hellion,

11

Python 3 , 21 byte

lambda x:(x*17)[::17]

Provalo online!

Spiegazione:

La stessa idea della mia risposta di Ruby, ma ancora più breve in Python: uso 17 mazzi e scelgo ogni 17 carta.

— GB
fonte

5

JavaScript, 35 byte

x=>x.map((a,i)=>i%2?a:x[(i+20)%54])

Provalo online!

Prendere una matrice di mazzo come input e sostituire ogni valore dispari con un'altra carta che si trova a "20 carte" sul mazzo.

— Il ragazzo a caso
fonte

1

Ah, quando ho detto che "tutti" nel mio post non erano corretti; così è andata anche io!

— Jonathan Allan,

4

Java 10, 72 65 byte

d->{var r=d.clone();for(int i=54;i-->0;r[i*7%54]=d[i]);return r;}

Simile alla risposta di Ruby di @GB , ma usando i*7%54sull'array dei risultati, anziché sull'array di i*17%54input per salvare un byte.

Provalo online.

Spiegazione:

d->{              // Method with String-array as both parameter and return-type
  var r=d.clone();//  Result-String, starting as a copy of the input
  for(int i=54;i-->0;
                  //   Loop `i` in the range (54, 0]
    r[            //    Set an item in the result-array at index:
      i*7%54      //     Index `i` multiplied by 7, and then take modulo-54
     ]=d[i]);     //    To the `i`'th item in the input-Deck
  return r;}      //  Return the result-Array

— Kevin Cruijssen
fonte

Sfortunatamente, il risultato contiene numerose carte adiacenti alle carte dello stesso seme. Comincia con AS, 6S, JS, 3D, 8D, KD,.

— AJFaraday,

@AJFaraday TIO era ancora con 11 invece di 7. Potresti controllarlo di nuovo. Forse mi sono perso qualcos'altro, ma penso che dovrebbe essere corretto ora (spero).

— Kevin Cruijssen,

Adesso ce l'ho. Bel lavoro!

— AJFaraday,

3

Perl 6 , 21 20 18 byte

Grazie a Brad Gilbert b2gills per -2 byte

{.[$++*17%$_]xx$_}

Provalo online!

Ancora un'altra porta della risposta di GB . ~~Si noti che, mentre la variabile globale $!non viene ripristinata tra le funzioni, il valore non ha importanza, poiché qualsiasi ordine dell'output è valido.~~ Tuttavia, $ viene ripristinato.

Spiegazione:

{                } #Anonymous code block
             xx$_  #Repeat size of inputted array (54) times
 .[         ]      #Get from the inputted array, the value at index
    $++*17%$_         #The incremented variable, multiplied by 17, modded by size of the array

— Jo King
fonte

1

Funziona altrettanto bene con uno stato senza nome var $come con $!o $/. Inoltre, se lo hai usato al $_posto @_tuo, potresti avviarlo .[…]invece di @_[…]salvare un altro byte.

— Brad Gilbert b2gills il

2

05AB1E , 9 7 5 byte

ā17*è

Porta della risposta di Ruby di @GB , quindi assicurati di votarlo!

-2 byte stampando ogni scheda con un delimitatore di nuova riga invece di racchiuderlo in un elenco di risultati
-2 byte grazie a @ Mr.Xcoder

Provalo online.

Spiegazione:

ā        # 1-indexed length range [1 ... length_of_input_list (54)]
 17*     #  `k`: Multiply each index by 17
    è    #  And then replace each item with the 0-indexed `k`'th card of the input-list
         #  (with automatic wrap-around)

— Kevin Cruijssen
fonte

1

ā17*èdovrebbe salvare altri 2 byte

— Mr. Xcoder il

2

JavaScript, 27

Un altro basato sulla risposta rubino

d=>d.map((_,i)=>d[i*17%54])

A cura di un accorciamento evidente

— vityavv
fonte

2

T-SQL, 31 byte

SELECT c FROM t ORDER BY i*7%54

Se non ti interessa una colonna aggiuntiva nell'output, posso ottenerla fino a 29 byte :

SELECT*FROM t ORDER BY i*7%54

Quindi puoi verificare che il mio output sia "Superbo", ecco il mazzo che produce:

 J, 5H,  8S, KH, 3D,  8C, JD, AS, 6H,  9S, AC, 4D, 9C, QD, 
2S, 7H, 10S, 2C, 5D, 10C, KD, 3S, 8H,  JS, 3C, 6D, JC, 
AH, 4S,  9H, QS, 4C,  7D, QC, 2H, 5S, 10H, KS, 5C, 8D, 
KC, 3H,  6S, JH, AD,  6C, 9D,  J, 4H,  7S, QH, 2D, 7C, 10D

(Generato utilizzando la nuova aggiunta di SQL 2017 STRING_AGG):

SELECT STRING_AGG(c,', ')WITHIN GROUP(ORDER BY i*7%54)FROM t

La parte difficile per me non era il codice selezionato, stava popolando la tabella di input (che è consentita per SQL secondo le nostre regole di I / O ).

Poiché SQL è intrinsecamente non ordinato (garantisce un certo ordine solo se si include una ORDER BYclausola esplicita ), ho dovuto includere quell'ordine originale come campo i nella tabella di input t . Questo significa anche che posso usarlo per ordinare, usando lo stesso processo fattore / mod "relativamente principale" che tutti gli altri usano. Ho scoperto che ha i*7%54funzionato altrettanto bene i*17%54.

Ecco i comandi per impostare e popolare la tabella di input t , in base alla mia soluzione a questa domanda correlata :

CREATE TABLE t (i INT IDENTITY(1,1), c VARCHAR(5))

--Insert 52 suited cards
INSERT t(c)
SELECT v.value+s.a as c
FROM STRING_SPLIT('A-2-3-4-5-6-7-8-9-10-J-Q-K','-')v,
     (VALUES('S',1),('D',2),('H',3),('C',4))s(a,b)
ORDER BY s.b

--Insert Jokers
INSERT t(c) SELECT 'J'
INSERT t(c) SELECT 'J'

— BradC
fonte

Non isarebbe considerato un input aggiuntivo qui?

— Shaggy,

@Shaggy La domanda dice che posso ottenere il mazzo di input nell'ordine originale (elencato). L'unico modo per garantire ciò in SQL è che l'ordine sia una parte esplicita dell'input, poiché le tabelle SQL non hanno un "ordine predefinito" . Quindi, lo vedo come un componente necessario dell'input. Ma non preoccuparti, SQL è comunque raramente competitivo :)

— BradC,

2

Gelatina , 5 4 byte

s⁴ZẎ

Provalo online!

Risulta il modo in cui ~~tutti~~ gli altri, tranne il ragazzo a caso , salva un byte :(
Credito a GB per il loro metodo .

Il modo in cui sono andato ...

ṙÐe20

Provalo online!

Come?

Ripara ogni altra carta e sparpagliala con una rotazione del mazzo lasciata di 20 posti (funzionano anche 18 e 22 posti; inoltre funziona anche la direzione di rotazione e fissa carte dispari o pari)

ṙÐe20 - Link: list of the card strings (lists of characters)
   20 - place a literal twenty on the right
 Ðe   - apply to even indices:
ṙ     -   rotate left (by 20)

Cioè (usando Tper 10e rj& bjper Ji):

input: AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj
  ṙ20: 8D 9D TD JD QD KD AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC rj bj AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS AD 2D 3D 4D 5D 6D 7D
ṙÐe20: AS 9D 3S JD 5S KD 7S 2H 9S 4H JS 6H KS 8H 2D TH 4D QH 6D AC 8D 3C TD 5C QD 7C AH 9C 3H JC 5H KC 7H bj 9H 2S JH 4S KH 6S 2C 8S 4C TS 6C QS 8C AD TC 3D QC 5D rj 7D

— Jonathan Allan
fonte

2

PowerShell 3.0, 30 26 byte

$args[(0..53|%{$_*17%54})]

^{-4 grazie al}
vecchio codice ^Mazzy a 30 byte

param($d)0..53|%{$d[$_*17%54]}

Un'altra porta del metodo di GB.

— Veskah
fonte

26 byte $args[(0..53|%{$_*17%54})].

— mazzy,

@Mazzy Sento che rompe le specifiche di input. Sicuramente sono raccolti in $ args ma in realtà non ne passi uno.

— Veskah

citare: The input can be either:... in the same order, as *an array*. $argsè un array. e puoi usare uno splatting . per esempio $a=@("AS", ..., "J"); &{} @a. Provalo. :)

— mazzy

inoltre, mi sembra che non sia necessario contare i personaggi &{e }. È possibile salvare param($d)0..53|%{$d[$_*17%54]}in un file. e chiama questo file senza&{...}

— mazzy

1

@mazzy Sì, sono sempre stato un po 'incerto su quali parti di controllo mantenere, quindi di solito sono inadempienti nel renderlo un blocco di script. Lo spogliamo in futuro però.

— Veskah,

1

Carbone , 8 byte

Ｅθ§θ×¹⁷κ

Provalo online! Il collegamento è alla versione dettagliata del codice. Un'altra porta della risposta di Ruby di @ GB. Spiegazione:

 θ          Input array
Ｅ           Map over elements
       κ    Current index
     ¹⁷     Literal 17
    ×       Multiply
   θ        Input array
  §         Cyclically index
            Implicitly print each result on its own line

— Neil
fonte

1

Rosso , 44 byte

func[a][append/dup a a 16 prin extract a 17]

Provalo online!

Un'altra interpetazione del codice di GB. Aggiungo 16 copie del mazzo a se stesso e quindi estraggo ogni 17 carta.

— Galen Ivanov
fonte

Esegui uno Shuffle ™ superbo

Japt, 6 5 4 byte

Rubino , 31 byte

Spiegazione:

Python 3 , 21 byte

Spiegazione:

JavaScript, 35 byte

Java 10, 72 65 byte

Perl 6 , 21 20 18 byte

Spiegazione:

05AB1E , 9 7 5 byte

JavaScript, 27

T-SQL, 31 byte

Gelatina , 5 4 byte

Come?

PowerShell 3.0, 30 26 byte

Carbone , 8 byte

Rosso , 44 byte