Illustra il quadrato di un binomio

28

Dati (con ogni mezzo) due diversi numeri naturali (di qualsiasi dimensione ragionevole), producono (con ogni mezzo) il quadrato della loro somma come negli esempi seguenti:

Dato 4 e 3, output:

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

Dato 1 e 3, output:

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

Gli spazi bianchi possono variare entro limiti ragionevoli ma le colonne devono essere allineate a sinistra, allineate a destra o (pseudo-) centrate.

Una nuova riga finale va bene, ma non lo sono le scappatoie standard.

Questo è code-golf quindi includi un'intestazione come # LanguageName, 123nella tua risposta, dove il numero è caratteri (byte per le lingue che non sono basate su testo). Il codice di impacchettamento in caratteri Unicode di grandi dimensioni non è consentito.

Bonus: -3 se il tuo codice genera solo un quadrato quando uno dei numeri è 0; ad es. dato 0 e 3, uscita:

9 9 9
9 9 9
9 9 9
code-golf  math  arithmetic  array-manipulation  grid 
— Adamo
fonte
qual è il valore massimo dei numeri di input? Grazie.
— don luminoso
1
@donbright Nessun limite artificiale. L'unico limite è ciò che il computer e la lingua possono gestire quando si tratta di rappresentazione, calcolo (con l'algoritmo scelto) e risultato. Potenzialmente, un moderno computer dotato di una stampante che accetta i dati riga per riga, non avrebbe quasi limiti ... :-)
— Adám,
L'orientamento del quadrato è un dato o possiamo ruotarlo di 90 gradi?
— John Dvorak,
1
Perché il bonus per 0 valori però? Quale sarebbe l'output previsto se non solo un quadrato?
— Marzo Ho
@MarchHo Ecco perché il bonus è così piccolo. Tuttavia, alcune lingue potrebbero non essere in grado di gestire array vuoti.
— Adám,

Risposte:

14

J, 9 byte - 3 = 6

#~@|.*/#~

Ispirato dalla risposta APL di @ NBZ , scagliato da @randomra. Questo definisce un verbo che comprende una matrice di numeri. È usato come segue:

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

Richiedo anche il bonus a 3 byte, dal momento che un input di 0 produce sub-matrici di dimensione 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

Spiegazione

J ha un vantaggio definito in questa sfida. Oltre a mangiare problemi di manipolazione dell'array a colazione, per impostazione predefinita stampa matrici 2D nel formato corretto.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table
— Zgarb
fonte
Questo mi fa sentire come a casa.
— Adám,
3
Questa soluzione sembra un'oscura variazione table flipperdell'emoticon ASCII (╯ ° □ °） ╯︵ ┻━┻
— Pete TNT
10

Ottava, 45 byte - 3 = 42

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

Spiegazione

Questo crea due vettori (supponiamo m = 4che n = 3):

ones(n, 1)costruisce una matrice di dimensioni n x 1, quindi moltiplicando quelle notteniamo:

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

Quindi i vettori vengono moltiplicati in modo elementare, con espansione automatica della trasmissione in modo che i vettori a 7 elementi producano una matrice di 7x7 elementi:

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

Ad esempio, la moltiplicazione della prima riga di aper bdà:

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

E allo stesso modo per le restanti file di a.

Produzione:

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

Puoi provarlo qui su ideone

— coppa
fonte
È possibile rimuovere il s=. Abbiamo la convenzione che funzioni / lambda anonime non devono essere archiviate in una variabile.
— flawr,
6
@flawr ma la risposta non sarebbe 42 ...
— Becher
OK.
— Adám
9

Dyalog APL , 10-3 = 7

Ispirato * da questa risposta in cui gli argomenti vengono replicati e quindi utilizzati in una tabella di moltiplicazione:

⊖∘.×⍨(/⍨⎕)

⎕Emette un prompt ( ⎕:) e valuta quindi qualsiasi espressione inserita. (Per motivi di sicurezza, questo non funziona su TryAPL ma funziona su NGN / APL .)
/⍨Replica l'argomento stesso volte ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Crea una tabella di moltiplicazione.
⊖Capovolge.

Questo funziona su qualsiasi input di lunghezza (l'input è rientrato di 6 spazi, l'output è sul margine sinistro):

      ⊖∘.×⍨(/⍨⎕)
⎕:
      ⍬      ⍝ 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

* Inizialmente, avevo in mente una soluzione diversa: ogni rettangolo viene creato separatamente creando una tabella di moltiplicazione per ogni combinazione dei due argomenti. Quindi i quattro quadrati vengono uniti insieme in verticale e in orizzontale. Sembra così:

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

⎕Pronto, come sopra.
,⍴×<Combina ( ,) gli arg e usa quello per modellare ( ⍴) un rettangolo riempito con il loro prodotto ( ×).
∘.(... )⍨Crea una tabella in cui ogni cella è quella specificata in (... )
⊖Capovolgi verticalmente.
⍪⌿Combina le celle in verticale.
,/Combina le celle in orizzontale.

— Adamo
fonte
1
Bello! Stessa idea in J con uguale punteggio:(|.*/])@#~
— Zgarb,
@Zgarb Aggiorna la tua risposta e metti una nota come la mia. J se lo merita!
— Adám,
7

R, 31-3 = 28

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

Spiegazione:

           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

Questo funziona anche per più di due numeri. Ad esempio, l'output di (5,3,2) è simile al seguente:

      [,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
Probabilmente dovrai racchiuderlo cato writeaffinché sia ​​una risposta valida.
— David Arenburg,
@DavidArenburg Non vedo perché? Dice "Output (con ogni mezzo)". Mi è bastato un solo mezzo per emettere in modo che mi mettesse nei requisiti.
— freekvd,
Sì forse hai ragione. Non sono sicuro di cosa significhino.
— David Arenburg,
@DavidArenburg Sì, va bene. Questa è una sfida di dati / testo, non una sfida di input / output.
— Adám,
5

Haskell, 153 125 byte - 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 metà del codice è per la formattazione dell'output. Funziona con interi di grandi dimensioni arbitrari. Esempio di output:

> 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 volte c'è uno spazio bianco aggiuntivo tra i numeri, perché sto calcolando lo spazio necessario basato su x*x+y*yinvece di max (x*x) (y*y), ad es

> 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

Ma è al massimo uno spazio bianco.

— Nome del modello
fonte
4

Mathematica 56-3 = 53

Aggiornamento : ho aggiunto un secondo metodo, esattamente della stessa dimensione del codice, che utilizza una funzione denominata. Impiega un Arraypiuttosto che un Tablema segue la stessa logica. (Vedi sotto.)

Metodo 1

Questo rende una tabella di prodotti, i cui fattori dipendono dalla riga, dai valori di colonna. La coppia di numeri viene inserita come un elenco di numeri interi. Le funzioni anonime come le seguenti sono molto utili se utilizzate una sola volta in un programma. Altrimenti ha più senso usare una funzione con nome.

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

Ogni fattore è un'istruzione If-then:

  • If[r>#2,#,#2] significa "Se il numero di riga è maggiore del secondo input, utilizzare il primo input come fattore, altrimenti utilizzare il secondo input.
  • If[c>#,#2,#] significa "Se il numero di colonna è maggiore del primo input, utilizzare il secondo input come fattore, altrimenti utilizzare il primo input.

Esempio 1

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

EX1

Esempio 2

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

EX2

Metodo 2 (anche 56-3 = 53)

Funziona in modo simile al Metodo 1. Ma richiede meno codice quando viene chiamato. E le celle sono indirizzabili, a differenza delle celle in una tabella. Questo metodo è meglio usare se la funzione verrà utilizzata più di una volta.

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

Gli esempi di cui sopra sono prodotti da quanto segue:

Ex 1:

f[4,3]

Ex 2:

f[0,3]
— DavidC
fonte
1
È geniale. Con questo metodo posso ridurre la mia soluzione di 4 caratteri.
— Adám,
Grazie. Mi sono appena reso conto che lo stesso approccio funziona con una funzione denominata. Vedi il metodo 2 sopra.
— DavidC
4

Ottava, 34-3 = 31

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

Esempi:

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
fonte
Wow, non avevo idea che repelemsesistesse. Eccezionale!
— becher
4

CJam, 27 byte - 3 = 24

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

Accetta input come un array in stile CJam. Usa un po 'più di spazio del necessario, ma penso che sia "entro limiti ragionevoli", ed è sempre correttamente allineato a destra.

Provalo qui.

Spiegazione

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
Bello, ma cosa causa così tanto spazio bianco e cosa sarebbe necessario per ridurlo?
— Adám,
1
@NBZ Il modo più breve che ho trovato finora per calcolare un limite superiore affidabile sulla larghezza della cella è utilizzare il doppio della lunghezza della stringa di input (perché il numero più grande al quadrato non avrà più del doppio delle cifre del numero si). Ovviamente potrei calcolare l'importo effettivo necessario in base ai numeri risultanti, ma sarebbe un po 'più lungo.
— Martin Ender,
4

Funzione C (usando glibc), 122 byte - 3 = 119

Implementazione per lo più semplice con 2 loop. Mi aspetto che ci siano alcune opportunità di golf che mi sono perso qui:

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

Gli input vengono passati nei primi due parametri della funzione, gli altri due sono dummy. Le colonne sono allineate a destra.

Nota che glibc puts()sembra sempre restituire il numero di byte scritti incluso il newline finale implicito, che è ciò di cui abbiamo bisogno qui. Nessuna garanzia che funzionerà con qualsiasi altra libc.

In un programma 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]));
    }
}

Compilare come gcc sqrbin.c -o sqrbin(o make sqrbin). Gli avvisi possono essere tranquillamente ignorati.

Esempio di output:

$ ./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 digitale
fonte
Sulla base della mia esperienza, il valore di ritorno di puts()dipende dalla macchina. Sono le mie 10 per esempio. Inoltre, ecco un suggerimento: di solito è possibile comprimere due loop in uno se si incrementa in modo condizionale il contatore nel loop esterno. La mia soluzione dimostra come si può fare.
— xsot,
@xsot Sì, il puts()codice di ritorno è garantito solo per essere + ve per il successo. Comunque il mio test con glibc sembra mostrare che il valore di ritorno è il numero di byte scritti. Per quanto riguarda il consolidamento del loop - sì, sono a conoscenza di quella tecnica e l'ho provato qui, finora senza accorciamento in questo caso.
— Trauma digitale
2

Rubino, (133-3) = 130 byte

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}

per 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

per 1,3

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

per 0,3

9   9   9   
9   9   9   
9   9   9
— Golgappa
fonte
2
Benvenuti in PPCG! Non penso che la tua imbottitura sia sufficiente per grandi numeri. Considera di avere un 1numero grande come 9999. Che sverrà fuori come 4, quindi stai riempiendo con una larghezza di s+3 = 7ma ha 9999^2bisogno di 8 cifre. Potresti voler usare 2*sinvece.
— Martin Ender,
2
Indipendentemente da ciò, ecco alcuni suggerimenti per il golf: non vedo perché è necessario rjustprima di farlo ljust. È possibile ridurre printa $><<(e sbarazzarsi dello spazio dopo di esso). ARGVha un alias $*. Potresti essere in grado di evitarlo flattencostruendo il tuo array con qualcosa del genere: codegolf.stackexchange.com/a/19493/8478 . Inoltre, le risposte di sola funzione sono sicuramente consentite qui (anche funzioni senza nome), quindi quella funzione potrebbe prendere gli interi come input e non dovresti fare nulla .to_i.
— Martin Ender,
@ MartinBüttner, grazie per i suggerimenti.
— Harsh Gupta,
2

Python 2, 176 byte - 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,

Questo utilizza le funzioni di stringa Python per creare una griglia di caratteri, quindi sostituisce i caratteri con numeri interi e stampa l'output formattato.

— don luminoso
fonte
Metodo interessante.
— Adám,
1

Matlab, 58-3 = 55

Utilizzando una funzione anonima:

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

Esempio:

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

(Vecchia soluzione) 59-3 = 56

Utilizzando una funzione anonima:

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

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

L'input viene preso come due numeri interi separati da spazio sulla stessa riga. Ogni cella è riempita con spazi per due volte la lunghezza della stringa di input.

— xsot
fonte
sto avendo problemi a far compilare questo con gcc (4.8.4) ...
— don luminoso
1
Ho provato questo su golf.shinh.org/check.rb che usa il pacchetto debian gcc-4.6.1-2. Quali errori di compilazione stai ricevendo?
— xsot,
scusate ho provato di nuovo come una sola riga e ha funzionato, ... ma quando corro ottengo un segfault. ho inserito la stringa 2 3 e ho premuto Invio e dice Errore di segmentazione (core scaricato)
— don luminoso
Scusa ma non so perché non funzionerà per te. Almeno puoi ancora provare il codice sul sito che ho collegato in precedenza :)
— xsot
1

Pyth, 39-3 = 36

Pyth non ha una formattazione della matrice integrata, che aumenta notevolmente le dimensioni, in quanto è necessario riempire manualmente i numeri di output. Ecco cosa mi è venuto in mente.

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

Provalo online.

— PurkkaKoodari
fonte
1

Blocchi , 51 byte 52 62 82 87 (non concorrenti)

::`+`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

Provalo

— Downgoat
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.