Проілюструйте квадрат двочлена

28

Враховуючи (будь-якими способами) два різних натуральних чисел (будь-якого розумного розміру), виведіть (будь-якими способами) квадрат їх суми, як у наведених нижче прикладах:

Дано 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

Дано 1 і 3, вихід:

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

Пробіл може змінюватися залежно від причини, але стовпці повинні бути вирівняні ліворуч, вирівняні праворуч або (псевдо-) по центру.

Зростаючий новий рядок - це добре, але стандартні лазівки - ні.

Це код-гольф, тому включіть заголовок, як # LanguageName, 123у свою відповідь, де число - символи (байти для мов, які не текстові). Упаковка коду до великих символів Unicode заборонена.

Бонус: -3, якщо ваш код видає лише один квадрат, коли одне з чисел дорівнює 0; наприклад, задано 0 і 3, вихід:

9 9 9
9 9 9
9 9 9
code-golf  math  arithmetic  array-manipulation  grid 
— Адам
джерело
яке максимальне значення вхідних чисел? Спасибі.
— Дон яскравий
1
@donbright Немає штучних обмежень. Єдиним обмеженням є те, з чим може працювати ваш комп'ютер та мова, коли мова йде про представлення, обчислення (за обраним алгоритмом) та результат. Потенційно сучасний комп’ютер, оснащений принтером, який приймає дані за рядком, майже не обмежував би ... :-)
— Adám
Чи є орієнтація квадрата заданою чи ми можемо повернути її на 90 градусів?
— Джон Дворак
1
Чому бонус за 0 значень, хоча? Яким був би очікуваний вихід, якби не один квадрат?
— Хо-березень
@MarchHo Ось чому бонус такий малий. Проте деякі мови не можуть обробляти порожні масиви.
— Адам

Відповіді:

14

J, 9 байт - 3 = 6

#~@|.*/#~

Натхненний відповіддю на APL @ NBZ , який вдосконалено @randomra. Це визначає дієслово, яке бере масив чисел. Він використовується наступним чином:

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

Я також претендую на 3-байтний бонус, оскільки вхід 0 виробляє підматриці розміру нуль:

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

Пояснення

J має певну перевагу в цьому виклику. Окрім проблем із маніпуляцією масивом на сніданок, він за замовчуванням друкує 2D матриці у правильному форматі.

       #~  Replicate each number n in input n times
#~@|.      The same for reversed input
     */    Compute their multiplication table
— Згарб
джерело
Це змушує мене почувати себе як вдома.
— Адам
3
Це рішення виглядає неясним варіантом table flipperсмайлика ASCII (╯ ° □ °） ╯︵ ┻━┻
— Pete TNT
10

Октава, 45 байт - 3 = 42

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

Пояснення

Це будує два вектори (припустимо m = 4і n = 3):

ones(n, 1)будує масив з розмірів n x 1, тому множачи їх на 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

Потім вектори множуються елементарно, з автоматичним розширенням трансляції, щоб 7-елементні вектори створювали матрицю 7x7 елементів:

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

Наприклад, множення першого ряду aна bдає:

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

І аналогічно для решти рядків a.

Вихід:

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

Ви можете спробувати тут на ideone

— мензурка
джерело
Ви можете видалити s=. У нас є умова, що анонімні функції / лямбда не повинні зберігатися в змінній.
— flawr
6
@flawr, але тоді відповідь не буде 42 ...
— стакан
OK.
— адам
9

Діалог APL , 10-3 = 7

Натхненний * цією відповіддю, де аргументи реплікуються і потім використовуються в таблиці множення:

⊖∘.×⍨(/⍨⎕)

⎕Видає підказку ( ⎕:) і оцінює будь-який введений тоді вираз. (З міркувань безпеки це не працює в TryAPL, але він працює в NGN / APL .)
/⍨Сам час реплікації свого аргументу ( /⍨4 3⇔ 3 3 3 4 4 4 4)
∘.×⍨Створює таблицю множення.
⊖Перевертається догори дном.

Це трапляється на будь-якому введенні довжини (вхід з відступом 6 пробілів, вихід - зліва)

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

* Спочатку я мав на увазі інше рішення: кожен прямокутник створюється окремо, створюючи таблицю множення для кожної комбінації двох аргументів. Потім чотири квадрати згинаються разом вертикально і горизонтально. Це виглядає приблизно так:

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

⎕Підкажіть, як вище.
,⍴×<Поєднайте ( ,) аргументи і використовуйте це для формування ( ⍴) прямокутника, наповненого їх твором ( ×).
∘.(… )⍨Створіть таблицю, де кожна клітинка є якоюсь заданою у (… )
⊖Переверніть вертикально.
⍪⌿Поєднайте клітинки вертикально.
,/Поєднайте клітини горизонтально.

— Адам
джерело
1
Приємно! (|.*/])@#~
— Ця
@ Zgarb Оновіть свою відповідь і поставте виноску, як у мене. J заслуговує цього!
— Adám
7

R, 31 - 3 = 28

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

Пояснення:

           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

Це також працює для більш ніж двох чисел. Наприклад, вихід для (5,3,2) виглядає так:

      [,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
джерело
Ймовірно, вам потрібно буде загорнути його в catабо writeдля того, щоб він був вірною відповіддю.
— Девід Аренбург
@DavidArenburg Я не бачу чому? На ньому написано "Результат (будь-якими способами)". У мене знадобилося лише одне засіб, щоб вивести мене на вимогу.
— freekvd
Так, можливо, ти маєш рацію. Не впевнений, що вони мають на увазі під цим.
— Девід Аренбург
@DavidArenburg Так, це добре. Це виклик даних / тексту, а не виклик введення / виводу.
— Adám
5

Haskell, 153 125 байт - 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))

Половина коду призначена для форматування виводу. Він працює для довільних великих цілих чисел. Приклад виводу:

> 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

Іноді між номерами є додатковий пробіл, тому що я обчислюю необхідний простір x*x+y*yзамість max (x*x) (y*y), наприклад,

> 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

Але це максимум один пробіл.

— німі
джерело
4

Mathematica 56-3 = 53

Оновлення : я додав другий метод, точно такого ж розміру коду, який використовує названу функцію. Він використовує Arrayскоріше, ніж а, Tableале слідує тій же логіці. (Дивись нижче.)

Спосіб 1

Це складає таблицю продуктів, фактори якої залежать від рядка, значення стовпців. Пара чисел вводиться як список цілих чисел. Анонімні функції, такі як наведені нижче, є найбільш корисними, якщо вони використовуються лише один раз у програмі. Інакше має сенс використовувати названу функцію.

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

Кожен фактор є твердженням If-then:

  • If[r>#2,#,#2] означає: "Якщо число рядків більше другого вводу, використовуйте перший вхід як фактор, в іншому випадку використовуйте другий вхід.
  • If[c>#,#2,#] означає: "Якщо номер стовпця більший за перший вхід, використовуйте другий вхід як фактор, інакше використовуйте перший вхід.

Приклад 1

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

ex1

Приклад 2

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

ex2

Спосіб 2 (також 56-3 = 53)

Це працює аналогічно методу 1. Але при виклику йому потрібно менше коду. І клітини адреси, на відміну від комірок у таблиці. Цей метод краще використовувати, якщо функція буде використовуватися не один раз.

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

Приклади, наведені вище, виробляються наступним чином:

Приклад 1:

f[4,3]

Вихід 2:

f[0,3]
— DavidC
джерело
1
Це геніальне. За допомогою цього методу я можу зменшити власне рішення на 4 символи.
— Адам
Спасибі. Я щойно зрозумів, що той самий підхід працює з названою функцією. Див. Метод 2 вище.
— DavidC
4

Октава, 34 - 3 = 31

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

Приклади:

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
— алефальфа
джерело
Нічого собі, ідеї не repelemsіснувало. Дивовижно!
— стакан
4

CJam, 27 байт - 3 = 24

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

Вводить дані як масив стилів CJam. Він використовує трохи більше інтервалу, ніж потрібно, але я думаю, що це "в межах розуму", і він завжди правильно вирівняний.

Перевірте це тут.

Пояснення

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.
— Мартін Ендер
джерело
Приємно, але що викликає стільки простору, і що потрібно для його зменшення?
— Адам
1
@NBZ Найкоротший шлях, який я до цих пір знайшов для обчислення надійної верхньої межі ширини комірки, - це використання вдвічі довшішої вхідної рядки (оскільки більша кількість квадрата не матиме більше ніж удвічі більше цифр, ніж число себе). Звичайно, я міг обчислити фактичну необхідну суму, виходячи з отриманих чисел, але це було б трохи довше.
— Мартін Ендер
4

Функція C (за допомогою glibc), 122 байти - 3 = 119

Переважно пряма реалізація з 2-ма петлями. Я думаю, що тут я пропустив кілька можливостей для гольфу:

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

Вхідні дані передаються в перших двох параметрах функції, інші два - манекени. Стовпчики вирівнюються вправо.

Зверніть увагу, що glibc puts()завжди здається, що кількість повернених байт повертається, включаючи неявну заднім рядком, для чого нам тут потрібно. Ніяких гарантій це не буде працювати з будь-яким іншим libc.

У повній програмі:

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

Складіть як gcc sqrbin.c -o sqrbin(або make sqrbin). Попередження можуть безпечно ігноруватися.

Приклад виводу:

$ ./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
$
— Цифрова травма
джерело
Виходячи з мого досвіду, повернене значення puts()залежить від машини. Наприклад, 10 на моїй. Також ось рада: зазвичай ви можете стиснути дві петлі в одну, якщо умовно збільшити лічильник у зовнішній петлі. Моє рішення демонструє, як це можна зробити.
— xsot
@xsot Так, puts()повернення коду гарантується лише для успіху. Однак моє тестування на glibc, схоже, показує, що значення повернення - кількість записаних байтів. Що стосується консолідації циклу - так, я знаю про цю техніку і спробував це тут, поки що в цьому випадку немає скорочення.
— Цифрова травма
2

Ruby, (133 - 3) = 130 байт

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}

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

за 1,3

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

для 0,3

9   9   9   
9   9   9   
9   9   9
— Голгаппа
джерело
2
Ласкаво просимо до PPCG! Я не думаю, що ваші набивання є достатніми для великої кількості. Подумайте, як 1і велика кількість подібних 9999. Чим sвийде так 4, значить, ви забиваєте на ширину, s+3 = 7але вам 9999^2потрібно 8 цифр. Ви можете використовувати 2*sзамість цього.
— Мартін Ендер
2
Незважаючи на це, ось кілька порад щодо гольфу: я не розумію, навіщо вам це потрібно, rjustперш ніж робити ljust. Можна скоротити printдо $><<(і позбутися місця після нього). ARGVмає псевдонім $*. Ви можете уникнути flatten, побудувавши свій масив приблизно так: codegolf.stackexchange.com/a/19493/8478 . Крім того, тут напевно дозволені відповіді лише для функцій (навіть без назви), щоб ця функція могла приймати цілі числа як вхідні дані, і вам не доведеться робити жодних .to_i.
— Мартін Ендер
@ MartinBüttner, дякую за поради.
— Сувора Гупта
2

Пітон 2, 176 байт - 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,

При цьому використовуються рядкові функції Python для створення символьної сітки, а потім замінюються символи цілими числами та друкується вихід у формат.

— Дон яскравий
джерело
Цікавий метод.
— Adám
1

Матлаб, 58 - 3 = 55

Використання анонімної функції:

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

Приклад:

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

(Старе рішення) 59 - 3 = 56

Використання анонімної функції:

@(a,b)[b*a*ones(b,a) b^2*ones(b);a^2*ones(a) a*b*ones(a,b)]
— Луїс Мендо
джерело
1

C, (125 - 3) байт

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

Вхід приймається як два цілих цілих числа в одному рядку. Кожна комірка прокладена пробілами в два рази довжиною вхідного рядка.

— xsot
джерело
у мене виникають проблеми з отриманням цього для компіляції з gcc (4.8.4) ...
— don яскравий
1
Я перевірив це на golf.shinh.org/check.rb, який використовує пакет debian gcc-4.6.1-2. Які помилки компіляції ви отримуєте?
— xsot
Вибачте, що я спробував ще раз, як всі одні рядки, і це спрацювало, ... але коли я запускаю, я отримую segfault. я ввійшов до рядка 2 3 і натиснув return, і він говорить про помилку сегментації (ядро скинуто)
— нехай яскравий
Вибачте, але я не знаю, чому це не працює для вас. Принаймні, ви все ж можете спробувати код на сайті, з яким я зв’язувався раніше :)
— xsot
1

Піта, 39 - 3 = 36

Pyth не має вбудованого матричного форматування, що значно збільшує розмір, оскільки доводиться вручну прокладати вихідні числа. Ось що я придумав.

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

Спробуйте в Інтернеті.

— PurkkaKoodari
джерело
1

Блоки , 51 байт 52 62 82 87 (неконкурентні)

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

Безголівки:

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

Спробуй це

— Пуховик
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.