Sumar manualmente las caras de un cubo cúbico es tedioso y requiere mucho tiempo, como escribir código en el propio cubo.

En Cubifier más eficiente , le pedí que tradujera ASCII a Cubically source. Una de las respuestas allí utiliza una secuencia de inicialización del cubo y luego modifica el cubo resultante en función de las sumas del cubo preinicializado. Este método se ha utilizado en muchos programas relacionados con el Cubic desde entonces. Al probar una nueva secuencia de inicialización, uno tiene que sumar todos los valores en todas las caras, lo que generalmente toma dos o tres minutos.

¡Su tarea es automatizar este proceso para nosotros!

Tomarás dos entradas, un entero ny una cadena c. Estos pueden leerse desde argumentos de línea de comando, argumentos de función, entrada estándar, un archivo o cualquier combinación de ellos. cserá un cubo de memoria de tamaño cúbicon tal como lo imprime el intérprete.

El intérprete Cubically volca su cubo a STDERR al finalizar el programa, formateado muy bien para una visualización simple. Ejecute un programa vacío en el intérprete Cubically y abra la sección de depuración para ver el volcado de cubo de un cubo inicializado. Agregue un argumento 4para ver un 4x4x4, o 5para ver un 5x5x5, etc.

Si nes 3, cseguirá este formato (los enteros serán variables):

   000
   000
   000
111222333444
111222333444
111222333444
   555
   555
   555

Espacios, líneas nuevas y todo. Si nes 4, cse verá así (también con enteros variables):

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

Etcétera.

Su programa generará seis enteros. El primer entero será la suma de todos los números en la cara superior.

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

El segundo número entero será la suma de la cara izquierda, el tercero al frente, el cuarto al derecho, el quinto al reverso y el sexto al final.

Entonces si nfue 3 y cfue esto:

   242
   202
   242
000131555313
010121535343
000131555313
   424
   454
   424

Su programa saldría 20 1 14 43 24 33.

Reglas adicionales:

• Los enteros de salida deben estar delimitados por caracteres no enteros. También puede optar por devolver una matriz.
• Puede suponer que la entrada es correcta: nes un número entero y ces un cubo de la salida de depuración de Cubically . Entonces si nfue 3.0y cfuefoo bar , su programa podría romperse y seguir siendo válido.
• Su programa solo necesita trabajar para n > 1y n < 1260. Se puede (intentar) manejar tamaños de cubos grandes o más pequeñas, pero no es necesario.

Este es el código de golf , por lo que gana el código más corto. Si necesita ayuda, no dude en preguntar en la sala de chat de Cubically .

Jalea , 16 14 13 bytes

3 bytes gracias a Erik the Outgolfer.

ḟ⁶ỴV€€sS€ẎsS€

Pruébalo en línea!

Pitón 2 , 155 150 147 123 121 120 bytes

Probablemente podría jugar al golf bastante

Editar: -5 bytes utilizando un método mejor para eliminar los espacios en blanco

Editar: -3 bytes gracias a @Leaky Nun

Editar: -24 bytes al no eliminar espacios en blanco

Editar: -2 bytes explotando la precedencia

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

Pruébalo en línea!

05AB1E , 16 bytes

¹|ðм€Sôεø¹ô€OO}˜

Pruébalo en línea!

Casco , 15 bytes

3 ṁsy 2 ms

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

Pruébalo en línea!

Explicación

                  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

Octava, 64 59 54 bytes

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

Pruébalo en línea!

Respuesta anterior:

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

Pruébalo en línea!

Devuelve una matriz como salida.

Perl 5 , 66 + 1 (-n) = 67 bytes

$j=$k<6?$k++/3:5;s/\d{3}/';$r[$j++]+='.$&=~s|.|+$&|gr/gee}{say"@r"

Pruébalo en línea!

Python 2 , 137127 bytes

-10 bytes gracias a @Halvard Hummel

lambda x,n:[sum(sum(map(int,x.split('\n')[b+j][a:a+n]))for j in range(n))for a,b in[[n,0],[0,n],[n,n],[2*n,n],[3*n,n],[n,2*n]]]

Pruébalo en línea!

Haskell, 128 bytes

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]]

Acepta una cadena con saltos de línea.

PowerShell , 236 bytes

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

Pruébalo en línea!

Ooof, esto es largo. Pero dividir y cortar cuerdas no es uno de los puntos fuertes de PowerShell, así que supongo que es algo esperado. Asi mismo. Muchos. Dólares

Toma en parámetros $ny $zcomo el tamaño y el cubo neto, respectivamente. Luego construye una función que se utiliza en todo momento. Aquí, estamos eliminando espacios, dividiendo cada dígito individual, eliminando los caracteres vacíos intermedios, uniendo todos los caracteres junto con un +, y luego ejecutando la declaración resultante para obtener un número. Por ejemplo, esto se convierte "123"en 1+2+3que cuando se ejecuta es 6.

La siguiente línea splites la red del cubo de entrada en las nuevas líneas, almacenando el resultado en una matriz$a . Luego realizamos la función en el primer$n líneas y sacamos la cara superior del cubo.

Para el siguiente conjunto, necesitamos empalmar las cadenas según el tamaño del cubo. Entonces, recorremos cada línea, construyendo $xcomo el patrón de expresión regular apropiado (por ejemplo, para el tamaño $n=3que será "(...)"), dividimos la cadena en función de ese patrón, nuevamente eliminamos elementos vacíos y los almacenamos en cuatro variables que representan las cuatro caras. Esos son entonces cadenas concatenadas a htravés k.

La siguiente línea se envía a htravés dek través de la función para generar los lados (izquierdo, frontal, derecho, posterior) del cubo.

Finalmente, corremos el último $n líneas a través de la función para generar la cara inferior del cubo.

Todos los números se dejan en la tubería, y la salida es implícita.

APL (Dyalog Classic) , 30 27 bytes

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

Afeitado 3 bytes gracias a @ Adám

⍺ es n ⍵ es c

Explicación

                        ⍵⊂⍨⍵∊⎕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)

Pruébalo en línea!

Cúbicamente , 19 bytes

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

Toma el cubo de STDIN y el tamaño como argumento de línea de comandos para el intérprete. Emite la suma de la cara superior, un byte nulo, la cara izquierda, un byte nulo, ... la cara inferior y un byte nulo.

Pruébalo en línea! ... que aparentemente muestra bytes nulos como una especie de espacio en blanco en mi navegador.

• Pruébalo en línea! (4x4x4)
• Pruébalo en línea! (5x5x5)

Este lenguaje no fue hecho para este desafío, pero el desafío fue hecho para el idioma ... ¿sigue siendo trampa? ;)