Somma le facce di un cubo cubico

13

Sommare manualmente le facce di un cubo cubico è noioso e richiede molto tempo, un po 'come scrivere codice in Cubicamente stesso.

Nel cubificatore più efficiente , ti ho chiesto di tradurre ASCII in sorgente cubica. Una delle risposte usa una sequenza di inizializzazione del cubo e quindi modifica il cubo risultante in base alle somme del cubo pre-inizializzato. Da allora questo metodo è stato utilizzato in molti programmi cubicamente correlati. Quando si verifica una nuova sequenza di inizializzazione, è necessario sommare tutti i valori su tutte le facce, che in genere richiedono due o tre minuti.

Il tuo compito è automatizzare questo processo per noi!

Prenderai due input, un numero intero ne una stringa c. Questi possono essere letti da argomenti della riga di comando, argomenti di funzioni, input standard, un file o qualsiasi combinazione di questi. csarà un cubo di memoria cubicamente di dimensioni ncome stampato dall'interprete.

L'interprete cubico scarica il suo cubo su STDERR al termine del programma, formattato piacevolmente per una semplice visualizzazione. Esegui un programma vuoto nell'interprete cubico e apri la sezione debug per vedere il dump del cubo di un cubo inizializzato. Aggiungi un argomento 4per vedere un 4x4x4 o 5per vedere un 5x5x5, ecc.

Se nè 3, cseguirà questo formato (i numeri interi saranno variabili):

   000
   000
   000
111222333444
111222333444
111222333444
   555
   555
   555

Spazi, newline e tutti. Se nè 4, capparirà così (anche con numeri interi variabili):

    0000
    0000
    0000
    0000
1111222233334444
1111222233334444
1111222233334444
1111222233334444
    5555
    5555
    5555
    5555

Eccetera.

Il tuo programma genererà sei numeri interi. Il primo numero intero sarà la somma di tutti i numeri nella faccia superiore.

   000
   000          top face
   000
111222333444    left, front, right, and back faces, respectively
111222333444
111222333444
   555
   555          bottom face
   555

Il secondo numero intero sarà la somma della faccia sinistra, il terzo il fronte, il quarto il diritto, il quinto il retro e il sesto il fondo.

Quindi se nfosse 3 ed cera questo:

   242
   202
   242
000131555313
010121535343
000131555313
   424
   454
   424

Il tuo programma verrebbe prodotto 20 1 14 43 24 33.

Regole aggiuntive:

  • Gli interi di output devono essere delimitati da caratteri non interi. Puoi anche scegliere di restituire un array.
  • Si può presumere che l'input sia corretto: nè un numero intero ed cè un cubo dall'output di debug di Cubically . Quindi, se nfosse 3.0ed cera foo bar, il tuo programma potrebbe interrompersi ed essere ancora valido.
  • Il tuo programma deve funzionare solo per n > 1e n < 1260. Si può (tentare di) gestire dimensioni del cubo più o meno grandi, ma non è necessario.

Questo è code-golf , quindi vince il codice più corto! Se hai bisogno di aiuto, sentiti libero di chiedere nella chat di Cubically .

code-golf  rubiks-cube  cubically 
— MD XF
fonte
Possiamo supporre che l'input includa tutti gli spazi finali in modo da essere un rettangolo?
— fireflame241
@ fireflame241 se vuoi dire n spazi dopo ogni riga, no. Non sono inclusi nella discarica.
— MD XF,
1
Abbiamo davvero bisogno di un tag "cubico".
— Sig. Xcoder
@ Completato lo stato di Mr.Xcoder :) Ci avevo pensato anch'io, e sto lavorando su altri quattro sportelli cubici.
— MD XF

Risposte:

5

Python 2 , 155 150 147 123 121 120 byte

Probabilmente potrebbe essere un po 'golfato

Modifica: -5 byte usando un metodo migliore per rimuovere gli spazi bianchi

Modifica: -3 byte grazie a @Leaky Nun

Modifica: -24 byte non rimuovendo gli spazi bianchi

Modifica: -2 byte sfruttando la precedenza

lambda n,a:[sum(sum(map(int,b[j*n:][:n]))for b in a.split("\n")[i*n:][:n])for i in range(3)for j in range(~i%2,i%2*2+2)]

Provalo online!

— Halvard Hummel
fonte
3

buccia , 15 byte

3 se ṁ2 ms

mṁṁiṁoC⁰TC⁰mf±¶

Provalo online!

Spiegazione

                  Takes input as two arguments, the first being n, the second, the cube
              ¶   Split second argument into a list of lines
           m      For each line
            f±    keep only the digits (remove spaces)
         C⁰       Cut into lists of length n
    ṁ             Map then concatenate
        T           transpose
     oC⁰            then cut into lists of length n
mṁṁi              Takes list of lists of strings (or, in Husk, a list of lists of lists of chars) and returns the sum of the digits in each list
m                 Map function over list of lists
 ṁ                  map then sum
  ṁ                   map then sum
   i                  convert character to integer
— H.PWiz
fonte
1
mṁṁiè davvero bello!
— Zgarb,
3

Ottava, 64 59 54 byte

@(c,n)sum(im2col(c'-48,[n n],'distinct'))([2 5:8 10])

Provalo online!

Risposta precedente:

@(c,n)sparse(kron((1:4)+[0;4;8],!!e(n)),1,c-48)([2 5:8 10])

Provalo online!

Restituisce un array come output.

— rahnema1
fonte
Non è quello che mi aspettavo, ma perfettamente valido, e ad essere sincero non mi aspettavo nessuna risposta. +1
— MD XF,
@MDXF Cosa ti aspettavi?
— rahnema1
Non mi aspettavo una risposta così breve, né questa forma di accettazione delle stringhe. Ma è proprio come Octave lo fa; Non ho mai usato Octave.
— MD XF,
1

Haskell, 128 byte

s n c=filter(>=0)$map(\[x,y]->sum$map(\[v,w]->fromEnum((lines c)!!(x*n+v)!!(y*n+w))-48)$n%n)$3%4
n%m=sequence[[0..n-1],[0..m-1]]

Accetta una stringa con interruzioni di riga.

— Leif Willerts
fonte
1

PowerShell , 236 byte

param($n,$z)
function f($y){$y-replace' '-split'(.)'-ne''-join'+'|iex}
$a=$z-split"`n"
f $a[0..($n-1)]
$a[$n..(2*$n-1)]|%{$x="($('.'*$n))";$1,$2,$3,$4=$_-split$x-ne'';$h+=$1;$i+=$2;$j+=$3;$k+=$4}
$h,$i,$j,$k|%{f $_}
f $a[(2*$n)..(3*$n)]

Provalo online!

Ooof, questo è lungo. Tuttavia, dividere e tagliare le stringhe non è uno dei semi forti di PowerShell, quindi immagino che ci si aspetti. Anche - So. Molti. Dollari.

Accetta i parametri $ne rispettivamente $zla dimensione e la rete del cubo. Quindi crea una funzione che viene utilizzata dappertutto. Qui, stiamo rimuovendo gli spazi, dividendo su ogni singola cifra, rimuovendo i caratteri vuoti in mezzo, unendo tutti i caratteri con un +, e quindi eseguendo l'istruzione risultante per ottenere un numero. Ad esempio, questo si trasforma "123"in 1+2+3quando viene eseguito 6.

La riga successiva splitè la rete del cubo di input su newline, memorizzando il risultato in array$a . Quindi eseguiamo la funzione sulle prime $nrighe e produciamo la faccia superiore del cubo.

Per il prossimo set, dobbiamo unire le stringhe in base alla dimensione del cubo. Quindi, eseguiamo il ciclo attraverso ogni linea, costruendo $xcome il modello regex appropriato (ad esempio, per la dimensione $n=3sarà "(...)"), dividere la stringa in base a quel modello, rimuovendo nuovamente gli elementi vuoti e memorizzandoli in quattro variabili che rappresentano le quattro facce. Questi sono poi stringa concatenato hattraverso k.

La riga successiva quindi le navi hattraverso kattraverso la funzione di uscita ai lati (a sinistra, davanti, a destra, di nuovo) del cubo.

Finalmente, eseguiamo l'ultimo $n righe attraverso la funzione per generare la faccia inferiore del cubo.

Tutti i numeri vengono lasciati sulla pipeline e l'output è implicito.

— AdmBorkBork
fonte
1

APL (Dyalog Classic) , 30 27 byte

{+/⍎¨6(⍺*2)⍴⍉⊃,⌿3⍺⍴⍵⊂⍨⍵∊⎕D}

Eliminato 3 byte grazie a @ Adám

⍺è n ⍵è c

Spiegazione

                        ⍵⊂⍨⍵∊⎕D   c partitioned by ⎕D (digits 0..9)
                    3⍺⍴           reshape into 3 by n matrix
                 ,⌿              concatenate on first axis (results in n vectors)
              ⍉⊃                  ravel transpose mix (results in a simple string with all digits in side order)
      6(⍺*2)⍴                     reshape into 6 by n squared matrix (one row per side)
 +/⍎¨                            sum rows execute each (execute will turn characters into numbers)

Provalo online!

— Gil
fonte
A me sembrano 59 byte . La sostituzione ⊆con ⎕U2286aggiungerà solo 5 byte.
— Adám,
Mio male, stavo giocando con e senza il partizionamento racchiuso e ho usato solo il conteggio dei byte per la versione classica. Modificherò la mia risposta per utilizzare il livello di migrazione 3 :)
— Gil
1
Inoltre, è possibile rimuovere lo spazio tra 3e ⍺.
— Adám,
1
(6,⍺*2) → 6(⍺*2)
— Adám,
1
IFAICT, non è necessario ,dopo ⍴che ⍴usa sempre l'argomento giusto in ordine ravvicinato.
— Adám,
0

Cubicamente , 19 byte

r%0@%1@%2@%3@%4@%5@

Prende il cubo da STDIN e la dimensione come argomento della riga di comando per l'interprete. Emette la somma della faccia superiore, un byte null, la faccia sinistra, un byte null, ... la faccia inferiore e un byte null.

Provalo online! ... che apparentemente mostra byte nulli come una sorta di spazio bianco sul mio browser.

Questa lingua non è stata creata per questa sfida, ma la sfida è stata fatta per la lingua ... sta ancora tradendo? ;)

— MD XF
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.