Ilustra el cuadrado de un binomio.

28

Dado (por cualquier medio) dos números naturales diferentes (de cualquier tamaño razonable), genera (por cualquier medio) el cuadrado de su suma como en los ejemplos a continuación:

Dado 4 y 3, salida:

12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

Dado 1 y 3, salida:

3 9 9 9
3 9 9 9
3 9 9 9
1 3 3 3

El espacio en blanco puede variar dentro de lo razonable, pero las columnas deben estar alineadas a la izquierda, a la derecha o (pseudo-) centradas.

Una nueva línea final está bien, pero las lagunas estándar no lo están.

Este es el código de golf, por lo tanto, incluya un encabezado como # LanguageName, 123en su respuesta, donde el número son caracteres (bytes para idiomas que no están basados ​​en texto). El código de embalaje para caracteres Unicode grandes no está permitido.

Bonificación: -3 si su código genera solo un cuadrado cuando uno de los números es 0; Por ejemplo, dado 0 y 3, salida:

9 9 9
9 9 9
9 9 9
code-golf  math  arithmetic  array-manipulation  grid 
— Adán
fuente
¿Cuál es el valor máximo de los números de entrada? Gracias.
— Don brillante
1
@donbright Sin límite artificial. El único límite es lo que su computadora e idioma pueden manejar cuando se trata de representación, computación (con el algoritmo elegido) y resultado. Potencialmente, una computadora moderna equipada con una impresora que acepta datos línea por línea, casi no tendría límite ... :-)
— Adám
¿La orientación cuadrada es un hecho, o podemos rotarla 90 grados?
— John Dvorak
1
¿Por qué la bonificación por 0 valores sin embargo? ¿Cuál sería el resultado esperado si no fuera un solo cuadrado?
— Marzo Ho
@MarchHo Por eso la bonificación es tan pequeña. Aún así, algunos idiomas pueden no ser capaces de manejar matrices vacías.
— Adám

Respuestas:

14

J, 9 bytes - 3 = 6

#~@|.*/#~

Inspirado por la respuesta APL de @ NBZ, jugado por @randomra. Esto define un verbo que toma una matriz de números. Se usa de la siguiente manera:

   (#~@|.*/#~) 4 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

También reclamo el bono de 3 bytes, ya que una entrada de 0 produce submatrices de tamaño cero:

   (#~@|.*/#~) 4 0
16 16 16 16
16 16 16 16
16 16 16 16
16 16 16 16
   (#~@|.*/#~) 0 3
9 9 9
9 9 9
9 9 9

Explicación

J tiene una ventaja definitiva en este desafío. Además de los problemas de manipulación de la matriz para el desayuno, imprime matrices 2D en el formato correcto de forma predeterminada.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table
— Zgarb
fuente
Esto me hace sentir como en casa.
— Adám
3
Esta solución parece una variación oscura del table flipperemoticón ASCII (╯ ° □ °） ╯︵ ┻━┻
— Pete TNT
10

Octava, 45 bytes - 3 = 42

s=@(m,n)[a=ones(n,1)*n;b=ones(m,1)*m].*[b;a]'

Explicación

Esto construye dos vectores (supongamos m = 4yn = 3 ):

ones(n, 1)construye una serie de unidades de tamaño n x 1, por lo que multiplicando las unidades por n:

ones(n, 1) * n => [3 3 3]' (where ' is transpose... n x 1 is a column vector)

a = [3 3 3  4 4 4 4]'   %// a is a column vector
b = [4 4 4 4  3 3 3]    %// b is a row vector

Luego, los vectores se multiplican en forma de elementos, con expansión de difusión automática para que los vectores de 7 elementos produzcan una matriz de 7x7 elementos:

    [3] .* [4 4 4 4 3 3 3]
    [3]
    [3]
    [4]
    [4]
    [4]
    [4]

Por ejemplo, la multiplicación de la primera fila de apor bda:

    [3] .* [4 4 4 4 3 3 3] = [12 12 12 12  9  9  9]

Y de manera similar para las filas restantes de a.

Salida:

>> s(4,3)
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

>> s(3,0)
ans =

   9   9   9
   9   9   9
   9   9   9

Puedes probarlo aquí en ideone

— cubilete
fuente
Puedes eliminar el s=. Tenemos la convención de que las funciones / lambdas anónimas no tienen que almacenarse en una variable.
— flawr
66
@flawr pero la respuesta no sería 42 ...
— vaso
OK.
— Adám
9

Dyalog APL , 10-3 = 7

Inspirado * por esta respuesta donde los argumentos se replican y luego se usan en una tabla de multiplicar:

⊖∘.×⍨(/⍨⎕)

⎕Emite un prompt ( ⎕:) y evalúa cualquier expresión ingresada en ese momento. (Por razones de seguridad, esto no funciona en TryAPL pero funciona en NGN / APL ).
/⍨Replica su argumento en sí veces ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Crea una tabla de multiplicación.
⊖Voltea boca abajo.

Esto sucede para trabajar en cualquier entrada de longitud (la entrada está sangrada 6 espacios, la salida está en el margen izquierdo):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ Empty list (the square of nothing)
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0      ⍝ 0​² = 0
      ⊖∘.×⍨(/⍨⎕)
⎕:
      0 1      ⍝ (0+1)​² = 1²
1
      ⊖∘.×⍨(/⍨⎕)
⎕:
      2 3      ⍝ (2+3)​² = 2² + 3²
6 6 9 9 9
6 6 9 9 9
6 6 9 9 9
4 4 6 6 6
4 4 6 6 6
      ⊖∘.×⍨(/⍨⎕)
⎕:
      1 2 3      ⍝ (1+2+3)​² = 1² + 2(1×2) + 2(1×3) + 2² + 2(2×3) + 3²
3 6 6 9 9 9
3 6 6 9 9 9
3 6 6 9 9 9
2 4 4 6 6 6
2 4 4 6 6 6
1 2 2 3 3 3
      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍳4    ⍝ Integers 1 through 4
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
4 8 8 12 12 12 16 16 16 16
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
3 6 6  9  9  9 12 12 12 12
2 4 4  6  6  6  8  8  8  8
2 4 4  6  6  6  8  8  8  8
1 2 2  3  3  3  4  4  4  4

* Originalmente, tenía una solución diferente en mente: cada rectángulo se crea por separado creando una tabla de multiplicación para cada combinación de los dos argumentos. Luego, los cuatro cuadrados se reparan vertical y horizontalmente. Se parece a esto:

,/⍪⌿⊖∘.(,⍴×)⍨⎕

⎕Rápido, como arriba.
,⍴×<Combina ( ,) los args y úsalo para dar forma ( ⍴) a un rectángulo lleno de su producto ( ×).
∘.(... )⍨Cree una tabla donde cada celda sea lo que se especifica en (... )
⊖Voltee verticalmente.
⍪⌿Combina celdas verticalmente.
,/Combina las celdas horizontalmente.

— Adán
fuente
1
¡Agradable! Misma idea en J con igual puntaje:(|.*/])@#~
— Zgarb
@Zgarb Actualiza tu respuesta y escribe una nota al pie como la mía. J se lo merece!
— Adám
7

R, 31-3 = 28

rev(b<-rep(a<-scan(),a))%*%t(b)

Explicación:

           a<-scan()            # take numeric input and store as vector a
    b<-rep(         ,a)         # repeat each numeric input by itself and store as vector b
rev(                   )        # the reverse of vector b
                        %*%     # matrix multiplication
                           t(b) # the transposed of vector b

Esto también funciona para más de dos números. Por ejemplo, la salida para (5,3,2) se ve así:

      [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
 [1,]   10   10   10   10   10    6    6    6    4     4
 [2,]   10   10   10   10   10    6    6    6    4     4
 [3,]   15   15   15   15   15    9    9    9    6     6
 [4,]   15   15   15   15   15    9    9    9    6     6
 [5,]   15   15   15   15   15    9    9    9    6     6
 [6,]   25   25   25   25   25   15   15   15   10    10
 [7,]   25   25   25   25   25   15   15   15   10    10
 [8,]   25   25   25   25   25   15   15   15   10    10
 [9,]   25   25   25   25   25   15   15   15   10    10
[10,]   25   25   25   25   25   15   15   15   10    10
— Freekvd
fuente
Es probable que necesita envolverlo en cato writecon el fin de que sea una respuesta válida.
— David Arenburg
@DavidArenburg ¿No veo por qué? Dice "Salida (por cualquier medio)". Me tomó solo un medio de salida, lo que me pone dentro de los requisitos.
— Freekvd
Sí, tal vez tengas razón. No estoy seguro de lo que quieren decir con eso.
— David Arenburg
@DavidArenburg Sí, está bien. Este es un desafío de datos / texto, no un desafío de entrada / salida.
— Adám
5

Haskell, 153125 bytes - 3 = 122

(#)=replicate
d=length.show
y%x=unlines$(>>= \n->(1+d(x*x+y*y)-d n)#' '++show n)<$>x#(y#(x*y)++x#(x*x))++y#(y#(y*y)++x#(x*y))

La mitad del código es para formatear la salida. Funciona para enteros grandes arbitrarios. Salida de ejemplo:

> putStrLn $ 4 % 3
12 12 12 12  9  9  9
12 12 12 12  9  9  9
12 12 12 12  9  9  9
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12
16 16 16 16 12 12 12

> putStrLn $ 6 % 0
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36
36 36 36 36 36 36

A veces hay un espacio en blanco adicional entre los números, porque estoy calculando el espacio necesario en x*x+y*ylugar de max (x*x) (y*y), por ejemplo

> putStrLn $ 2 % 3
  6  6  9  9  9
  6  6  9  9  9
  6  6  9  9  9
  4  4  6  6  6
  4  4  6  6  6

Pero es como máximo un espacio en blanco.

— nimi
fuente
4

Mathematica 56-3 = 53

Actualización : agregué un segundo método, precisamente del mismo tamaño de código, que usa una función con nombre. Emplea un en Arraylugar de un Tablepero sigue la misma lógica. (Vea abajo.)

Método 1

Esto crea una tabla de productos, cuyos factores dependen de los valores de la fila y la columna. El par de números se ingresa como una lista de enteros. Las funciones anónimas como las siguientes son más útiles si se usan solo una vez en un programa. De lo contrario, tiene más sentido usar una función con nombre.

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&

Cada factor es una declaración If-then:

  • If[r>#2,#,#2] significa, "Si el número de fila es mayor que la segunda entrada, use la primera entrada como factor, de lo contrario use la segunda entrada.
  • If[c>#,#2,#] significa, "Si el número de columna es mayor que la primera entrada, use la segunda entrada como factor, de lo contrario use la primera entrada.

Ejemplo 1

 Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{5,3}

ex1

Ejemplo 2

Grid@Table[If[r>#2,#,#2]If[c>#,#2,#],{r,#+#2},{c,#+#2}]&@@{0,3}

ex2

Método 2 (también 56-3 = 53)

Esto funciona de manera similar al Método 1. Pero requiere menos código cuando se llama. Y las celdas son direccionables, a diferencia de las celdas de una tabla. Este método es mejor si la función se usará más de una vez.

a_~f~b_:=Grid@Array[If[#>a,a,b]If[#2>a,b,a]&,{a+b,a+b}]

Los ejemplos de arriba son producidos por lo siguiente:

Ej 1:

f[4,3]

Ej 2:

f[0,3]
— DavidC
fuente
1
Eso es ingenioso. Con ese método puedo reducir mi propia solución en 4 caracteres.
— Adám
Gracias. Me acabo de dar cuenta de que el mismo enfoque funciona con una función con nombre. Ver Método 2 arriba.
— DavidC
4

Octava, 34 - 3 = 31

@(a)rot90(b=repelems(a,[1,2;a]))*b

Ejemplos:

octave:1> f = @(a)rot90(b=repelems(a,[1,2;a]))*b;
octave:2> f([4,3])
ans =

   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   12   12   12   12    9    9    9
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12
   16   16   16   16   12   12   12

octave:3> f([0,3])
ans =

   9   9   9
   9   9   9
   9   9   9
— alephalpha
fuente
Wow, no tenía idea de que repelemsexistía. ¡Increíble!
— vaso
4

CJam, 27 bytes - 3 = 24

q:L~_]ze~_ff{*sL,2*Se[}W%N*

Toma datos como una matriz de estilo CJam. Utiliza un poco más de espacio del necesario, pero creo que está "dentro de lo razonable", y siempre está correctamente alineado.

Pruébalo aquí.

Explicación

q:L    e# Read the input and store it in L.
~_     e# Evaluate the input, pushing [A B] onto the stack and duplicate it.
]z     e# Wrap both in an array and transpose it to get [[A A] [B B]].
e~     e# Run-length decode, getting A copies of A and B copies of B.
_ff{   e# Double map over each pair of entries in this new array...
  *s   e#   Multiply the two values.
  L,2* e#   Push twice the length of the input string.
  Se[  e#   Pad the result to this width with spaces (from the left).
}
W%     e# Reverse the resulting matrix to get the correct orientation.
N*     e# Join the rows with linefeed characters.
— Martin Ender
fuente
Bien, pero ¿qué causa tanto espacio en blanco y qué se necesitaría para reducirlo?
— Adám
1
@NBZ La forma más corta que he encontrado hasta ahora para calcular un límite superior confiable en el ancho de la celda es usar el doble de la longitud de la cadena de entrada (porque el número mayor al cuadrado no tendrá más del doble de dígitos que el número sí mismo). Por supuesto, podría calcular la cantidad real necesaria en función de los números resultantes, pero eso sería un poco más largo.
— Martin Ender
4

Función C (usando glibc), 122 bytes - 3 = 119

Implementación principalmente directa con 2 bucles. Espero que haya algunas oportunidades de golf que he perdido aquí:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

Las entradas se pasan en los dos primeros parámetros de la función, los otros dos son dummies. Las columnas están alineadas a la derecha.

Tenga en cuenta que glibc puts()siempre parece devolver el número de bytes escritos, incluida la nueva línea final implícita, que es lo que necesitamos aquí. No hay garantías de que esto funcione con cualquier otra libc.

En un programa completo:

f(n,m,x,y){for(x=0;x<n+m;x+=puts(""))for(y=0;y<n+m;y++)printf(" %*d",snprintf(0,0,"%d",n>m?n*n:m*m),(x<m?m:n)*(y<n?n:m));}

int main (int argc, char **argv) {
    if (argc == 3) {
        f(atoi(argv[1]),atoi(argv[2]));
    }
}

Compilar como gcc sqrbin.c -o sqrbin(o make sqrbin). Las advertencias pueden ser ignoradas de manera segura.

Salida de ejemplo:

$ ./sqrbin 4 3
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 12 12 12 12  9  9  9
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
 16 16 16 16 12 12 12
$ ./sqrbin 4 0
 16 16 16 16
 16 16 16 16
 16 16 16 16
 16 16 16 16
$
— Trauma digital
fuente
Según mi experiencia, el valor de retorno de puts()depende de la máquina. Son las 10 de la mía, por ejemplo. Además, aquí hay un consejo: por lo general, puede comprimir dos bucles en uno si incrementa condicionalmente el contador en el bucle externo. Mi solución demuestra cómo se puede hacer.
— xsot
@xsot Sí, el puts()código de retorno solo se garantiza que será + ve para el éxito. Sin embargo, mis pruebas con glibc parecen mostrar que el valor de retorno es el número de bytes escritos. En cuanto a la consolidación del bucle, sí, soy consciente de esa técnica y lo he intentado aquí, hasta ahora sin acortamiento en este caso.
— Trauma digital
2

Rubí, (133 - 3) = 130 bytes

s=1
a=ARGV.map{|e|s*=(e=e.to_i);[e]*e}.flatten
s=s.to_s.size
a.reverse.each{|i|a.each{|j|print (i*j).to_s.rjust(s).ljust(s+3)};puts}

para 4,3

12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
12   12   12   12    9    9    9   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12   
16   16   16   16   12   12   12

para 1,3

3   9   9   9   
3   9   9   9   
3   9   9   9   
1   3   3   3

por 0,3

9   9   9   
9   9   9   
9   9   9
— Golgappa
fuente
2
Bienvenido a PPCG! No creo que tu relleno sea suficiente para grandes números. Considere tener un 1y un gran número como 9999. De lo que ssaldrá como 4, por lo que está rellenando a un ancho de s+3 = 7pero 9999^2necesita 8 dígitos. Es posible que desee utilizar 2*sen su lugar.
— Martin Ender
2
De todos modos, aquí hay algunos consejos de golf: no veo por qué necesita el rjustantes de hacerlo ljust. Se puede acortar printa $><<(y deshacerse del espacio después de ella). ARGVtiene un alias $*. Es posible que pueda evitarlo flattencreando su matriz con algo como esto: codegolf.stackexchange.com/a/19493/8478 . Además, las respuestas solo de función definitivamente están permitidas por aquí (incluso funciones sin nombre), por lo que esa función podría tomar los enteros como entradas, y no tendría que hacer nada .to_i.
— Martin Ender
@ MartinBüttner, gracias por los consejos.
— Harsh Gupta
2

Python 2, 176 bytes - 3 = 173

def g(m,n):
 y,x,z,l,f='y','x','z','l','%'+str(len(str(max(m*m,n*n))))+'s'
 d={y:m*n,x:n*n,z:m*m,l:'\n'}
 for i in map(lambda x:d[x],(y*m+x*n+l)*n+(z*m+y*n+l)*m): print f % i,

Esto utiliza funciones de cadena de Python para crear una cuadrícula de caracteres, luego reemplaza los caracteres con enteros e imprime la salida formateada.

— don brillante
fuente
Método interesante
— Adám
1

Matlab, 58-3 = 55

Usando una función anónima:

@(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)

Ejemplo:

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(4,3)
ans =
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    12    12    12    12     9     9     9
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12
    16    16    16    16    12    12    12

>> @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
ans = 
    @(a,b)flipud(blkdiag(a^2*ones(a)-a*b,b^2*ones(b)-a*b)+a*b)
>> ans(0,3)
ans =
     9     9     9
     9     9     9
     9     9     9

(Solución anterior) 59-3 = 56

Usando una función anónima:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]
— Luis Mendo
fuente
1

C, (125-3) bytes

i,j,a;main(b,s){for(sscanf(gets(s),"%d %d",&a,&b);j<a+b;)printf(++i>a+b?i=!++j,"\n":"%*d",strlen(s)*2,(i<a?a:b)*(j<b?b:a));}

La entrada se toma como dos enteros separados por espacios en la misma línea. Cada celda se rellena con espacios al doble de la longitud de la cadena de entrada.

— xsot
fuente
Tengo problemas para hacer que esto se compile con gcc (4.8.4) ...
— don bright
1
Probé esto en golf.shinh.org/check.rb que usa el paquete debian gcc-4.6.1-2. ¿Qué errores de compilación estás obteniendo?
— xsot
lo siento, intenté nuevamente como una sola línea y funcionó, pero cuando ejecuto me sale un segfault. Ingresé a la cadena 2 3 y presioné el botón de retorno y dice Falla de segmentación (núcleo volcado)
— don brillante
Lo siento, pero no sé por qué no funcionará para ti. Al menos aún puedes probar el código en el sitio que
— vinculé
1

Pyth, 39-3 = 36

Pyth no tiene un formato de matriz incorporado, lo que aumenta enormemente el tamaño, ya que uno tiene que rellenar manualmente los números de salida. Esto es lo que se me ocurrió.

JAQL*b]jdm.[`d\ l`eS^R2Jsm*d]*bdJj+yHyG

Pruébalo en línea.

— PurkkaKoodari
fuente
1

Bloques , 51 bytes 52 62 82 87 (no competitivos)

::`+`1|U;{`*`1}|A;`+`1,0+`1={`1^2}|;0+`,`1+`={`^2}|

Sin golf:

::
  ` + `1                    | Expand;
  {` * `1}                  | SetAll;
  ` + `1, 0 + `1 = {`1 ^ 2} | Set;
  0 + `, `1 + `  = {` ^ 2}  | Set

Intentalo

— Downgoat
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.