Sfida esotica di arte ASCII

20

Nel gioco di strategia "Esplodi" , i giocatori a turno posizionano i gettoni su una tavola esagonale. Una volta che il numero di token è uguale al numero di tessere adiacenti, quella tessera si esplode e sposta tutti i token su di essa verso i vicini circostanti. Puoi giocare online qui .

Mi piace questo gioco, ma a volte è difficile sapere esattamente quanti token vanno su una tessera specifica; Conto sempre il numero di vicini. Sarebbe davvero conveniente se avessi un'arte ASCII per aiutarmi a ricordare quanti token vanno su ogni tessera.

È necessario scrivere un programma o funzione che prende un intero positivo come input, e produce questa rappresentazione ASCII di esagono di dimensione N . Ogni tessera sarà il numero di vicini che ha la tessera. Poiché 1 è un caso angolare strano con zero vicini, devi solo gestire input maggiori di 1.

Puoi prendere questo numero in qualsiasi formato ragionevole, come STDIN, argomenti di funzione, argomenti della riga di comando, da un file, ecc. L'output può anche essere in qualsiasi formato ragionevole, come stampare su STDOUT, scrivere su un file, restituire un elenco di stringhe, una stringa separata newline, ecc.

Ecco alcuni esempi di output per i primi 5 input:

2)

 3 3
3 6 3
 3 3


3)

  3 4 3
 4 6 6 4
3 6 6 6 3
 4 6 6 4
  3 4 3


4)

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

5)

    3 4 4 4 3
   4 6 6 6 6 4
  4 6 6 6 6 6 4
 4 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 4
  4 6 6 6 6 6 4
   4 6 6 6 6 4
    3 4 4 4 3

6)

     3 4 4 4 4 3
    4 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
 4 6 6 6 6 6 6 6 6 4
3 6 6 6 6 6 6 6 6 6 3
 4 6 6 6 6 6 6 6 6 4
  4 6 6 6 6 6 6 6 4
   4 6 6 6 6 6 6 4
    4 6 6 6 6 6 4
     3 4 4 4 4 3

E il modello continua in modo simile. Come al solito, si applicano scappatoie standard e la risposta con il conteggio di byte più basso verrà incoronata vincitrice!

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

# Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostra snippet di codice

code-golf  ascii-art  hexagonal-grid 
— DJMcMayhem
fonte
1
Correlato (ma chiedendo informazioni sul processo piuttosto che sul numero di vicini).
— trichoplax,
1
Sono tentato di imparare l'esagonia solo per il gusto di questa sfida. ;)
— Kevin Cruijssen,

Risposte:

11

MATL , 39 37 byte

4*3-:!G:+o~YRtP*!tPw4LY)vtI5&lZ+47+*c

Provalo online! O verifica tutti i casi di test .

Spiegazione

Ricomincio a usare la convoluzione!

Considera l'input n = 3. Il codice crea prima una matrice di dimensioni 4*n-3× naggiungendo il vettore di colonna [1; 2; ...; 9]al vettore di riga [1, 2, 3]con broadcast. Ciò significa calcolare una matrice di array 2D di tutte le aggiunte a coppie:

 2  3  4
 3  4  5
 4  5  6
 5  6  7
 6  7  8
 7  8  9
 8  9 10
 9 10 11
10 11 12

Sostituendo i numeri 1pari e i numeri dispari si 0ottiene il motivo a scacchiera

1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

Questo sarà usato per generare (parte di) la griglia esagonale. Quelli rappresenteranno punti nella griglia e gli zeri rappresenteranno gli spazi.

L'angolo in alto a destra viene rimosso azzerando tutte le voci sopra la "diagonale" principale della matrice: 

1 0 0
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1
0 1 0
1 0 1

L'elemento moltiplicando questa matrice per una versione capovolta di se stesso rimuove anche l'angolo in basso a destra. La trasposizione quindi dà

1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Questo inizia ad apparire come un esagono. Usando la simmetria, la griglia viene estesa per produrre la metà superiore:

0 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 0

Ora dobbiamo sostituire ogni voce uguale a una con il numero di vicini. Per questo usiamo la convoluzione con un vicinato 3 × 5 (ovvero, il kernel è una matrice 3 × 5 di quelli). Il risultato,

2 3 4 5 5 5 4 3 2
4 5 7 7 8 7 7 5 4
4 6 7 8 7 8 7 6 4
4 5 7 7 8 7 7 5 4
2 3 4 5 5 5 4 3 2

ha due problemi (che verranno risolti in seguito):

  1. I valori sono stati calcolati per tutte le posizioni, mentre ne abbiamo bisogno solo nelle posizioni di quelle nella griglia zero-one.
  2. Per ciascuna di quelle posizioni, il conteggio dei vicini include il punto stesso, quindi è disattivato da 1.

Il codice ora si aggiunge 47a ciascun valore calcolato. Ciò corrisponde alla sottrazione 1per risolvere il problema (2) e all'aggiunta 48(ASCII per'0' ), che converte ciascun numero nel punto di codice del suo carattere corrispondente.

La matrice risultante viene quindi moltiplicata per una copia della griglia zero-one. Questo risolve il problema (1) sopra, rendendo nuovamente i punti che non fanno parte della griglia esagonale pari a zero:

 0  0 51  0 52  0 51  0  0
 0 52  0 54  0 54  0 52  0
51  0 54  0 54  0 54  0 51
 0 52  0 54  0 54  0 52  0
 0  0 51  0 52  0 51  0  0

Infine, questo array di numeri viene trasmesso a un array di caratteri. I caratteri zero sono visualizzati come spazio, il che dà il risultato finale:

  3 4 3  
 4 6 6 4 
3 6 6 6 3
 4 6 6 4 
  3 4 3
— Luis Mendo
fonte
15

JavaScript (ES6), 118 117 byte

n=>[...Array(m=n+--n)].map((_,i,a)=>a.map((_,j)=>(k=j-(i>n?i-n:n-i))<0?``:k&&++j<m?i/2%n?6:4:3+!i%n).join` `).join`\n`

Dove \nrappresenta un carattere letterale newline. Spiegazione: Supponiamo n=4. Iniziamo con il seguente quadrato di cifre separato da spazi:

0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0

I primi |n-i| 0vengono cancellati, ma gli spazi rimangono:

   0 0 0 0
  0 0 0 0 0
 0 0 0 0 0 0
0 0 0 0 0 0 0
 0 0 0 0 0 0
  0 0 0 0 0
   0 0 0 0

Esagono istantaneo! È quindi sufficiente calcolare il valore appropriato al posto di ciascuno 0controllando se siamo nella prima o nell'ultima riga e / o colonna. Modifica: salvato 1 byte grazie a @Arnauld.

— Neil
fonte
Usando parte della tua formula, sono arrivato a una versione di 107 byte con for / console.log ():n=>{for(i=n+--n;i--;)console.log(' '.repeat(l=i>n?i-n:n-i)+(j=3+!l%n)+` ${l-n?6:4}`.repeat(2*n-l-1)+' '+j)}
— Arnauld
@Arnauld like like that 3+!i%n!
— Neil,
7

Python 2, 125 123 byte

def h(n):m=n-1;t=[' '*(m-r)+' '.join(('46'[r>0]*(r+m-1)).join('34'[r%m>0]*2))for r in range(n)];print'\n'.join(t+t[-2::-1])

I test sono su ideone

Attraversa la fila superiore e centrale for r in range(n), costruendo stringhe:
- creando due angoli o due bordi '34'[r%m>0]*2,;
- riempimento, mediante collegamento con ripetuti '6'o '4', '46'[r>0]*(r+m-1);
- unione di angoli e bordi con ' ';
- anteponendo con spazi ' '*(m-r);

Quindi stampa questo ed è riflesso nella riga centrale unita da nuove linee, print'\n'.join(t+t[-2::-1])

— Jonathan Allan
fonte
4

Python 2, 96 byte

n=input();m=n-1
while n+m:n-=1;j=abs(n);c='34'[0<j<m];print' '*j+c+' '+'46  '[j<m::2]*(2*m+~j)+c

Sembra piuttosto disordinato e un po 'golfabile ...

— SP3000
fonte
3

Java, 375 363 361 339 329 317 293 byte

interface J{static void main(String[]r){int i=0,k,h=Integer.decode(r[0]),a=1,l,n=0;for(;i++<h*2-1;n+=a){if(n==h-1)a=-1;String s="";for(k=0;k<n+h;k++,s+=" ")s+=n==0?k==0||k==n+h-1?3:4:k!=0&&k!=n+h-1?6:n==h-1?3:4;l=(h*4-3-s.trim().length())/2;System.out.printf((l==0?"%":"%"+l)+"s%s\n","",s);}}}

Ungolfed

interface J {
    static void main(String[] r) {
        int i = 0, k, h = Integer.decode(r[0]), a = 1, l, n = 0;
        for (; i++ < h * 2 - 1; n += a) {
            if (n == h - 1) {
                a = -1;
            }
            String s = "";
            for (k = 0; k < n + h; k++, s += " ") {
                s += n == 0 ? k == 0 || k == n + h - 1 ? 3 : 4 : k != 0 && k != n + h - 1 ? 6 : n == h - 1 ? 3 : 4;
            }
            l = (h * 4 - 3 - s.trim().length()) / 2;
            System.out.printf((l == 0 ? "%" : "%" + l) + "s%s\n", "", s);
        }
    }
}

Utilizzo :

$ java J 5
    3 4 4 4 3     
   4 6 6 6 6 4    
  4 6 6 6 6 6 4   
 4 6 6 6 6 6 6 4  
3 6 6 6 6 6 6 6 3 
 4 6 6 6 6 6 6 4  
  4 6 6 6 6 6 4   
   4 6 6 6 6 4    
    3 4 4 4 3

Sono sicuro che l'orribile blocco if-else nidificato possa essere riscritto per essere più piccolo, ma al momento non riesco a capirlo. Eventuali suggerimenti sono benvenuti :-)

Aggiornare

  • Seguì il suggerimento di Kevin Cruijssen e usò la decodifica invece di parseInt.
  • Riscritta alcuni if ​​usando l'operatore ternario.
  • Operatori più ternari.
  • Moar operatori ternari! Penso di aver creato un mostro!
  • Riscrivere il blocco if-else relativo alla stampa.
— Master_ex
fonte
1
Non ho esaminato attentamente il metodo che usi tu stesso, ma alcuni piccoli consigli sul golf per il tuo codice attuale: Integer.parseIntpossono essere giocati a golf Integer.decode. l=(h*4-3-s.trim().length())/2;if(l==0)può essere giocato a golf if((l=(h*4-3-s.trim().length())/2)==0). Inoltre, è del tutto accettabile pubblicare un metodo senza classe (a meno che la domanda non indichi diversamente), quindi al void f(int i){...use i...}posto di interface J{static void main(String[]r){...i=Integer.decode(r[0])...use i...}ciò dovrebbe risparmiare anche parecchi byte. Quando avrò più tempo, guarderò oltre.
— Kevin Cruijssen,
@KevinCruijssen: grazie per i tuoi suggerimenti. l=(h*4-3-s.trim().length())/2;if(l==0)è in realtà la stessa lunghezza con if((l=(h*4-3-s.trim().length())/2)==0).
— Master_ex,
2

05AB1E , 44 byte

FN_i4ë6}ð«¹ÍN+×ðìN_N¹<Q~i3ë4}.ø¹<N-ð×ì})¦«»

Spiegazione

Poiché la parte superiore e inferiore dell'esagono sono specchiate, dobbiamo solo generare la parte superiore.
Quindi per un input di X dobbiamo generare X righe. Questo è ciò che fa il ciclo principale.

F                                        }

Quindi facciamo la parte centrale delle file.
Questo è 4 per la prima fila e 6 per il resto (poiché stiamo facendo solo la parte superiore).
Concateniamo questo numero con uno spazio poiché il modello richiederà una spaziatura tra i numeri.

N_i4ë6}ð«

Ripetiamo quindi questa stringa X-2 + N volte, dove N è la riga corrente indicizzata 0 e anteponiamo un carattere spazio sul lato sinistro.

¹ÍN+×ðì

Dopo questo è il momento degli angoli. Saranno 3 per la prima e l'ultima riga e 4 per le file centrali.

N_N¹<Q~i3ë4}.ø

Ora dobbiamo assicurarci che le righe siano allineate correttamente aggiungendo spazi nella parte anteriore di ogni riga. Il numero di spazi aggiunti sarà X-1-N .

¹<N-ð×ì

Ora che abbiamo terminato la parte superiore della griglia, aggiungiamo le righe a un elenco, creiamo una copia invertita e rimuoviamo il primo elemento da quella copia (poiché abbiamo bisogno solo della riga centrale una volta), quindi uniamo queste 2 liste insieme e Stampa.

)¦«»

Provalo online!

Soluzione aggiuntiva, anche 44 byte:

ÍÅ10.øvN_i4ë6}ð«¹ÍN+×ðìyi4ë3}.ø¹<N-ð×ì})¦«»
— Emigna
fonte
2

Rubino, 87 byte

La funzione anonima prende n come argomento e restituisce una matrice di stringhe.

->n{(1-n..n-=1).map{|i|j=i.abs
" "*j+(e=j%n>0?"4 ":"3 ")+["6 ","4 "][j/n]*(2*n-1-j)+e}}

Non registrato nel programma di test

Ingresso tramite stdin. Scrive l'intera forma su stdout. Abbastanza esplicativo.

f=->n{
  (1-n..n-=1).map{|i|            #reduce n by 1 and iterate i from -n to n
    j=i.abs;                     #absolute magnitude of i
    " "*j+                       #j spaces +
    (e=j%n>0?"4 ":"3 ")+         #start the string with 3 or 4 +
    ["6 ","4 "][j/n]*(2*n-1-j)+  #2*n-1-j 6's or 4`s as appropriate +
    e                            #end the string with another 3 or 4
  }
}

puts f[gets.to_i]
— Level River St
fonte
1

V , 60 byte

Àé x@aA4 xr3^.òhYpXa 6^òkyHç^/:m0
Pç 3.*6/^r4$.
òÍ6 4./6

Provalo online!

Questo è davvero troppo lungo. Ecco un dump esadecimale, poiché contiene caratteri non stampabili:

0000000: c0e9 2078 4061 4134 201b 7872 335e 2ef2  .. x@aA4 .xr3^..
0000010: 6859 7058 6120 361b 5ef2 6b79 48e7 5e2f  hYpXa 6.^.kyH.^/
0000020: 3a6d 300a 50e7 2033 2e2a 362f 5e72 3424  :m0.P. 3.*6/^r4$
0000030: 2e0a f2cd 3620 9334 852e 2f36            ....6 .4../6
— DJMcMayhem
fonte
1

Racchetta, 487 byte

(λ(n c e o)(let((sp(append(range(- n 1)-1 -1)(reverse(range(- n 1)0 -1))))
(mm(append(range(- n 2)(-(+ n(- n 1))2))(range(-(+ n(- n 1))2)(-(- n 1)2)-1)))
(r""))(for((i sp)(j mm))(define str"")(for((ss i))(set! str(string-append str" ")))
(set! str(string-append str(if(or(= i 0)(= i(- n 1))(= i(* 2(- n 1))))c e)" "))
(for((jj j))(set! str(string-append str(if(= j(- n 2))e o)" ")))(set! r(if(or(= i 0)
(= i(- n 1))(= i(* 2(- n 1))))c e))(set! str(string-append str r))(displayln str))))

test: 

(f 4 "3" "4" "6") 

   3 4 4 3
  4 6 6 6 4
 4 6 6 6 6 4
3 6 6 6 6 6 3
 4 6 6 6 6 4
  4 6 6 6 4
   3 4 4 3

(f 5 "o" "*" "-") 

    o * * * o
   * - - - - *
  * - - - - - *
 * - - - - - - *
o - - - - - - - o
 * - - - - - - *
  * - - - - - *
   * - - - - *
    o * * * o

Versione dettagliata: 

(define(f1 n c e o)
  (let ((sp(append(range(sub1 n) -1 -1)
                  (reverse(range(sub1 n) 0 -1))))
        (mm(append(range(- n 2)(-(+ n(sub1 n)) 2))
                  (range(-(+ n(sub1 n)) 2)(-(sub1 n)2) -1) ))
        (r ""))
    (for((i sp)(j mm))
      (define str "")
      (for((ss i))(set! str(string-append str " ")))
      (set! str(string-append str
                              (if(or(= i 0)(= i(sub1 n))
                                    (= i(* 2(sub1 n)))) c e)
                              " "))
      (for((jj j))
        (set! str(string-append str
                                (if(= j(- n 2)) e o)
                                " ")))
      (set! r(if(or(= i 0)
                   (= i(sub1 n))
                   (= i(* 2(sub1 n)))) c e))
      (set! str(string-append str r))
      (displayln str))))
— rnso
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.