Ilustrar o quadrado de um binômio

28

Dado (por qualquer meio) dois números naturais diferentes (de qualquer tamanho razoável), produza (por qualquer meio) o quadrado de sua soma, como nos exemplos abaixo:

Dados 4 e 3, saída:

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

Dados 1 e 3, saída:

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

O espaço em branco pode variar de acordo com o motivo, mas as colunas devem estar alinhadas à esquerda, alinhadas à direita ou (pseudo-) centralizadas.

Uma nova linha à direita é boa, mas as brechas padrão não são.

Isso é código-golfe, portanto inclua um cabeçalho como # LanguageName, 123na sua resposta, onde o número é chars (bytes para idiomas que não são baseados em texto). O código de embalagem para caracteres Unicode grandes não é permitido.

Bônus: -3 se seu código gerar apenas um quadrado quando um dos números for 0; por exemplo, dado 0 e 3, saída:

9 9 9
9 9 9
9 9 9
code-golf math arithmetic array-manipulation grid Adão
fonte
qual é o valor máximo dos números de entrada? obrigado.
don brilhante
1
@donbright Sem limite artificial. O único limite é o que o computador e a linguagem podem suportar quando se trata de representação, computação (com o algoritmo escolhido) e resultado. Potencialmente, um computador moderno equipado com uma impressora que aceita dados linha por linha, não teria quase nenhum limite ... :-)
Adám
A orientação do quadrado é um dado, ou podemos girá-lo 90 graus?
John Dvorak
1
Por que o bônus para 0 valores? Qual seria o resultado esperado se não fosse apenas um quadrado?
March Ho
@MarchHo É por isso que o bônus é tão pequeno. Ainda assim, alguns idiomas podem não conseguir lidar com matrizes vazias.
Adám 20/10/2015

Respostas:

14

J, 9 bytes - 3 = 6

#~@|.*/#~

Inspirado pela resposta do @ NBZ no APL , inspirado no @randomra. Isso define um verbo que recebe uma matriz de números. É usado da seguinte maneira:

   (#~@|.*/#~) 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

Eu também reivindico o bônus de 3 bytes, uma vez que uma entrada 0 produz sub-matrizes de tamanho zero:

   (#~@|.*/#~) 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

Explicação

J tem uma vantagem definitiva nesse desafio. Além de comer problemas de manipulação de matriz no café da manhã, imprime matrizes 2D no formato correto por padrão.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table
Zgarb
fonte
Isso me faz sentir em casa.
Adám
3
Esta solução parece uma variação obscura do table flipperemoticon ASCII (╯ ° □ °） ╯︵ ┻━┻
Pete TNT
10

Oitava, 45 bytes - 3 = 42

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

Explicação

Isso constrói dois vetores (vamos assumir m = 4e n = 3):

ones(n, 1)constrói uma matriz de tamanho n x 1, multiplicando os valores 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

Em seguida, os vetores são multiplicados de maneira elemento a elemento, com expansão de transmissão automática para que os vetores de 7 elementos produzam uma matriz de 7x7 elementos:

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

Por exemplo, a multiplicação da primeira linha de apor bfornece:

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

E da mesma forma para as linhas restantes de a.

Saída:

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

Você pode tentar aqui no ideone

taça
fonte
Você pode remover o s=. Temos a convenção de que funções anônimas / lambdas não precisam ser armazenadas em uma variável.
flawr
6
@flawr mas então a resposta não seria 42 ...
copo
OK.
Adám
9

Dyalog APL , 10-3 = 7

Inspirado * por esta resposta em que os argumentos são replicados e usados ​​em uma tabela de multiplicação:

⊖∘.×⍨(/⍨⎕)

⎕Emite um prompt ( ⎕:) e avalia qualquer expressão inserida então. (Por motivos de segurança, isso não funciona no TryAPL, mas no NGN / APL .)
/⍨Replica o próprio argumento vezes ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Cria uma tabela de multiplicação.
⊖Vira de cabeça para baixo.

Isso funciona em qualquer entrada de comprimento (a entrada é recuada 6 espaços, a saída está na margem esquerda):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ 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, eu tinha uma solução diferente em mente: cada retângulo é criado separadamente, criando uma tabela de multiplicação para cada combinação dos dois argumentos. Em seguida, os quatro quadrados são reparados juntos vertical e horizontalmente. Se parece com isso:

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

⎕Prompt, como acima.
,⍴×<Combine ( ,) os argumentos e use-os para modelar ( ⍴) um retângulo preenchido com seu produto ( ×).
∘.(… )⍨Crie uma tabela em que cada célula seja o que for especificado em (… )
⊖Vire verticalmente.
⍪⌿Combine células verticalmente.
,/Combine células horizontalmente.

Adão
fonte
1
Agradável! A mesma idéia em J com a mesma pontuação:(|.*/])@#~
Zgarb
@ Zgarb Atualize sua resposta e coloque uma nota de rodapé como a minha. J merece isso!
Adám 20/10/2015
7

R, 31-3 = 28

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

Explicação:

           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

Isso também funciona para mais de dois números. Por exemplo, a saída para (5,3,2) fica assim:

      [,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
fonte
Você provavelmente precisará envolvê-lo catou writeser uma resposta válida.
precisa
@DavidArenburg Não vejo por que? Ele diz "Saída (por qualquer meio)". Levei apenas um meio para produzir, o que me colocou dentro dos requisitos.
Freekvd #
Sim, talvez você esteja certo. Não tenho certeza do que eles querem dizer com isso.
precisa
@DavidArenburg Sim, está tudo bem. Este é um desafio de dados / texto, não um desafio de entrada / saída.
Adám 20/10/2015
5

Haskell, 153 125 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))

Metade do código é para formatação de saída. Funciona para números inteiros grandes arbitrários. Exemplo de saída:

> 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

Às vezes, há um espaço em branco adicional entre os números, porque estou calculando o espaço necessário com base em x*x+y*yvez de max (x*x) (y*y), por exemplo

> 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

Mas é no máximo um espaço em branco.

nimi
fonte
4

Mathematica 56-3 = 53

Atualização : eu adicionei um segundo método, exatamente do mesmo tamanho de código, que usa uma função nomeada. Emprega um Arraye não um Tablemas segue a mesma lógica. (Ver abaixo.)

Método 1

Isso cria uma tabela de produtos, cujos fatores dependem da linha, valores da coluna. O par de números é inserido como uma lista de números inteiros. Funções anônimas, como as seguintes, são mais úteis se forem usadas apenas uma vez em um programa. Caso contrário, faz mais sentido usar uma função nomeada.

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

Cada fator é uma instrução If-then:

  • If[r>#2,#,#2] significa "Se o número da linha for maior que a segunda entrada, use a primeira entrada como fator, caso contrário, use a segunda entrada.
  • If[c>#,#2,#] significa "Se o número da coluna for maior que a primeira entrada, use a segunda entrada como fator, caso contrário, use a primeira entrada.

Exemplo 1

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

ex1

Exemplo 2

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

ex2

Método 2 (também 56-3 = 53)

Isso funciona de maneira semelhante ao método 1. Mas requer menos código quando chamado. E as células são endereçáveis, ao contrário das células de uma tabela. Este método é melhor usar se a função for usada mais de uma vez.

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

Os exemplos acima são produzidos pelo seguinte:

Ex 1:

f[4,3]

Ex 2:

f[0,3]
DavidC
fonte
1
Isso é engenhoso. Com esse método, posso reduzir minha própria solução em 4 caracteres.
Adám 19/10/2015
Obrigado. Acabei de perceber que a mesma abordagem funciona com uma função nomeada. Veja o método 2 acima.
21815
4

Oitava, 34 - 3 = 31

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

Exemplos:

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
alefalpha
fonte
Uau, eu não tinha ideia de que repelemsexistia. Impressionante!
copo
4

CJam, 27 bytes - 3 = 24

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

Recebe entrada como uma matriz de estilo CJam. Ele usa um pouco mais de espaçamento do que o necessário, mas acho que está "dentro da razão" e sempre está alinhado corretamente.

Teste aqui.

Explicação

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
fonte
Legal, mas o que causa tanto espaço em branco e o que seria necessário para reduzi-lo?
Adám 19/10/2015
1
@NBZ A maneira mais curta que eu encontrei até agora para calcular um limite superior confiável na largura da célula é usar o dobro do comprimento da string de entrada (porque o número maior ao quadrado não terá mais que o dobro do número de dígitos que o número próprio). É claro que eu poderia calcular a quantidade real necessária com base nos números resultantes, mas isso seria um pouco mais longo.
Martin Ender
4

Função C (usando glibc), 122 bytes - 3 = 119

Implementação principalmente direta com 2 loops. Espero que haja algumas oportunidades de golfe que perdi aqui:

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));}

As entradas são passadas nos dois primeiros parâmetros da função, os outros dois são manequins. As colunas estão alinhadas à direita.

Observe que o glibc puts()sempre parece retornar o número de bytes escritos, incluindo a nova linha implícita à direita, que é o que precisamos aqui. Não há garantias de que isso funcione com qualquer outra libc.

Em um 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]));
    }
}

Compile como gcc sqrbin.c -o sqrbin(ou make sqrbin). Os avisos podem ser ignorados com segurança.

Exemplo de saída:

$ ./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
fonte
Com base na minha experiência, o valor de retorno de puts()depende da máquina. São 10 no meu, por exemplo. Além disso, aqui está uma dica: você geralmente pode compactar dois loops em um se incrementar condicionalmente o contador no loop externo. Minha solução demonstra como isso pode ser feito.
Xsot #
@xsot Sim, o puts()código de retorno só é garantido como + ve para o sucesso. No entanto, meus testes com glibc parecem mostrar que o valor de retorno é o número de bytes gravados. Quanto à consolidação do loop - sim, eu conheço essa técnica e tentei isso aqui, até agora sem redução neste caso.
Digital Trauma
2

Ruby, (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

para 0,3

9   9   9   
9   9   9   
9   9   9
Golgappa
fonte
2
Bem-vindo ao PPCG! Não acho que seu preenchimento seja suficiente para grandes números. Considere ter um 1e um grande número como 9999. Como ssairá como 4, então você está preenchendo uma largura de, s+3 = 7mas 9999^2precisa de 8 dígitos. Você pode usar em seu 2*slugar.
Martin Ender
2
Independentemente disso, aqui estão algumas dicas de golfe: não vejo por que você precisa rjustantes de fazer ljust. Você pode reduzir printpara $><<(e se livrar do espaço após ele). ARGVtem um alias $*. Você pode evitar isso flattenconstruindo sua matriz com algo como isto: codegolf.stackexchange.com/a/19493/8478 . Além disso, respostas somente de função são definitivamente permitidas por aqui (mesmo funções sem nome), para que a função possa usar os números inteiros como entradas, e você não precisaria fazer nada .to_i.
Martin Ender
@ MartinBüttner, obrigado pelas dicas.
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,

Isso usa funções de string do Python para criar uma grade de caracteres, substitui os caracteres por números inteiros e imprime a saída formatada.

não brilhante
fonte
Método interessante.
Adám 20/10/2015
1

Matlab, 58 - 3 = 55

Usando uma função anônima:

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

Exemplo:

>> @(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

(Solução antiga) 59 - 3 = 56

Usando uma função anônima:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]
Luis Mendo
fonte
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));}

A entrada é tomada como dois números inteiros separados por espaço na mesma linha. Cada célula é preenchida com espaços para o dobro do comprimento da sequência de entrada.

xsot
fonte
im tendo problemas para fazer isso para compilar com gcc (4.8.4) ...
don brilhante
1
Eu testei isso no golf.shinh.org/check.rb, que usa o pacote debian gcc-4.6.1-2. Quais erros de compilação você está recebendo?
xsot
desculpe, eu tentei novamente como todos uma linha e funcionou, ... mas quando eu corro eu recebo um segfault. i entrou na corda 2 3 e hit retorno e ele diz que falha de segmentação (núcleo)
don brilhante
Desculpe, mas não sei por que não funcionará para você. Pelo menos você ainda pode experimentar o código no local I ligado mais cedo :)
xsot
1

Pitão, 39-3 = 36

Pyth não possui formatação matricial incorporada, o que aumenta muito o tamanho, pois é necessário preencher manualmente os números de saída. Aqui está o que eu criei.

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

Experimente online.

PurkkaKoodari
fonte
1

Blocos , 51 bytes 52 62 82 87 (não concorrente)

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

Ungolfed:

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

Tente

Downgoat
fonte