Создайте функцию или программу, которая делает сетку как можно ближе к квадрату

• Вам будет дано целое число N в качестве входных данных, целые числа (1,2,3,25 и т. Д.)
• На выходе должна быть идеальная прямоугольная сетка из N букв, максимально приближенная к квадрату
• Квадрат (подражатель) должен состоять из одной из букв O или X, как указано пользователем

Очки :

• Закодировано только O или X: +1
• Параметр (0/1, true / false, что-то похожее) для поворота вывода (например, с 5 или 8): -10
• Создайте квадрат (используйте O и X в каком-то шаблоне): -5

Шаблон считается действительным, если он содержит оба типа символов (где ось x / y> = 3), и шаблон остается тем же самым, когда переворачивается по горизонтали или вертикали (допускается замена X на Os)

Примеры

INPUT: 4         INPUT: 5       INPUT: 8              INPUT: 9
OO               OOOOO          XXXX                  XOX
OO                              XXXX                  OXO  
                                or rotated 90deg      XOX

Примеры, которые не разрешены (не одинаковые по длине строки или столбцы)

BAD RESULT: 5a        BAD RESULT: 5b      BAD RESULT: 8
OOO                   OO                  OOO
OO                    OO                  OOO
                      O                   OO

Если возможно, приведите пример онлайн.

CJam, 16 (31 - 10 - 5)

Для этого нужно ввести два целых числа, первое из которых является 0или 1для направления, а второе - числом Oили Xв сетке.

Он печатает альтернативу Oи X.

:X"OX"*X<\Xmqi){(_X\%}g_X\/?/N*

Это просто тело функции, чтобы попробовать его добавить l~перед кодом, как:

l~:X"OX"*X<\Xmqi){(_X\%}g_X\/?/N*

и дать вклад как

0 10

чтобы получить вывод, как

OXOXO
XOXOX

или введите как

1 10

за

OX
OX
OX
OX
OX

Попробуйте онлайн здесь

Как это работает:

l~                                 "Put the two input integers to stack";
  :X                               "Assign the number of cells to X";
    "OX"*                          "Take string "OX" and repeat it X times";
         X<                        "Slice it to take only first X characters";
           \                       "Swap top two stack elements, now string is at bottom";
            Xmqi)                  "Take square root of X, ceil it and put on stack";
                 {(_X\%}g          "Keep decrementing until it is perfectly divisible by X";
                         _X\/      "Copy it, divide X by that and put it on stack";
                             ?     "Based on first input integer, take either of numbers";
                              /    "Divide the XOXO string that many times";
                               N*  "Join the string parts with a new line";

Пример выполнения:

l~ed:X"OX"*edX<ed\edXmqi)ed{(_X\%}ged_edXed\ed/ed?ed/edN*ed

#INPUT:
1 10

#OUTPUT:
Stack: [1 10]

Stack: [1 "OXOXOXOXOXOXOXOXOXOX"]

Stack: [1 "OXOXOXOXOX"]

Stack: ["OXOXOXOXOX" 1]

Stack: ["OXOXOXOXOX" 1 4]

Stack: ["OXOXOXOXOX" 1 2]

Stack: ["OXOXOXOXOX" 1 2 2]

Stack: ["OXOXOXOXOX" 1 2 2 10]

Stack: ["OXOXOXOXOX" 1 2 10 2]

Stack: ["OXOXOXOXOX" 1 2 5]

Stack: ["OXOXOXOXOX" 2]

Stack: [["OX" "OX" "OX" "OX" "OX"]]

Stack: ["OX
OX
OX
OX
OX"]

OX
OX
OX
OX
OX

APL (36 - 5 - 10 = 21)

{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}

Левый аргумент - вращение, правый аргумент - размер. Он также использует простой шаблон (он просто чередует 'X' и 'O').

      0{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}¨4 5 8 9
 OX  OXOXO  OXOX  OXO 
 OX         OXOX  XOX 
                  OXO 
      1{'OX'⍴⍨⍺⌽⊃∆/⍨⍵=×/¨∆←∆[⍋|-/¨∆←,⍳2/⍵]}¨4 5 8 9
 OX  O  OX  OXO 
 OX  X  OX  XOX 
     O  OX  OXO 
     X  OX      
     O       

Объяснение:

• ∆←,⍳2/⍵: сгенерировать все возможные пары чисел из 1в ⍵и сохранить в ∆.
• ∆←∆[⍋|-/¨∆... ]: сортировка по ∆возрастанию по абсолютной разности двух чисел в каждой паре и сохранение результата в ∆.
• ⊃∆/⍨⍵=×/¨∆: для каждой пары умножьте числа вместе. Выберите только те пары, которые умножаются на ⍵, и возьмите первую, которая соответствует (которая является «самой квадратной» из-за сортировки).
• ⍺⌽: повернуть список длин (который имеет 2 элемента) на ⍺.
• 'OX'⍴⍨: создайте матрицу такого размера и заполните ее чередующимися Oи X.

Хаскель, 59 персонажей

r=replicate
f n=[r x$r y '0'|x<-[1..n],y<-[1..x],x*y==n]!!0

CJam, 25 22 21 (31 - 10)

Это функциональное тело. Если вы хотите законченную программу, добавьте ririв начало. Если вы хотите использовать его как блок кода, поместите его в {}. Проверьте это на cjam.aditsu.net .

Он принимает входные данные в виде двух целочисленных аргументов: переключатель для определения того, является ли прямоугольник вертикальным (любое ненулевое значение) или горизонтальным (ноль), и числом Os для использования.

:Xmqi){(_X\%}g_X\/@{\}{}?'O*N+*

объяснение

:X "Assign the top item on the stack (the second input) to variable X";
mq "Take its square root";
i  "Convert to integer (round)";
)  "Increment it";

{  "Start code block";
  (  "Decrement";
  _X "Duplicate top item on stack; push X to the stack";
  \% "Swap top 2 items and take division remainder";
}g "Loop until top item on stack is 0; pop condition after checking it";

_X "Duplicate top item on stack; push X to the stack";
\/ "Swap top 2 items and divide";

"OMIT THIS BIT TO GET A 25-CHAR FUNCTION WITHOUT THE 10PT BONUS";
 @  "Rotate top 3 items on stack";
 {\}"Code block 1: swap top two items";
 {} "Code block 2: do nothing";
 ?  "If top item of stack is 0, run code block 1, otherwise run code block 2";

'O "Push the character O to the stack";
*  "Repeat it N times, where N is the second item from the top of the stack (O is first)";
N+ "Push a new line and concatenate it with the string on the top of the stack";
*  "Repeat the string N times";

JavaScript (E6) 84 (83 + 1) или 101 (116-10-5)

Паттерн + вращение (параметр f, 0 или 1) - бонус 15

F=(n,f)=>{
  for(r=x=0;y=n/++x|0,x<=y;)x*y-n?0:z=f?x:y;
  for(o='';n;)o+=(n--%z?'':(r^=1,c='\n'))+'OX'[r^(c^=1)];
  alert(o)
}

Без рисунка, без вращения - штраф 1

F=n=>{
  for(x=0;y=n/++x|0,x<=y;)x*y-n?0:z=y;
  alert(('O'.repeat(z)+'\n').repeat(n/z));
}

Тест в консоли FireFox / FireBug

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (без бонусов)

Бонусы кажутся хитрыми, поэтому вот довольно простая функция Python:

def f(N):c=max(x*((x*x<=N)>N%x)for x in range(1,N+1));print(N/c*'O'+'\n')*c

Руби, 74

f=->n{w=(1..n).min_by{|z|n%z>0?n:(n/z-n/(n/z))**2};$><<("X"*w+"\n")*(n/w)}

объяснение

• Входные данные принимаются в качестве аргументов лямбда-выражения. Ожидается Integer.
• Проверьте, nделится ли (вход) на каждое целое число от 1 до n.
  • Если это так, рассчитайте разницу между длиной и шириной.
  • Если это не так, верните большое число ( n).
• Возьмите наименьшее из различий длины и ширины, чтобы лучше всего походить на квадрат.
• Используйте (слишком сжатый) String#*метод, чтобы «нарисовать» квадрат.

APL (Dyalog Unicode) , 30 - 15 = 15 байт ^SBCS

Анонимный инфикс лямбда. Принимает N в качестве правого аргумента и параметр в качестве левого аргумента. Прямоугольники либо будут иметь полосы X и O, либо будут клетчатыми.

{⍉⍣⍺⍴∘'XO'⊃∘c⌈.5×≢c←⍸⍵=∘.×⍨⍳⍵}

Попробуйте онлайн!

{… } "Дфн"; ⍺левый аргумент (param), ⍵правый аргумент ( N ):

 ⍳⍵ 1ndice 1… N

 ∘.×⍨ таблица умножения этого

 ⍵= маска, где N равно этому

 ⍸ of указатели истинных значений в маске

 c← сохранить это в c(для c andidates)

 ≢ подсчитать кандидатов

 .5× половина, умноженная на это

 ⌈ потолок (вверх)

 ⊃∘c выбрать этот элемент из c

 ⍴∘'XO' использовать это, чтобы циклически изменить форму "XO"

 ⍉⍣⍺ перенести если парам

05AB1E (наследие) , оценка: 7 (22 байта - 15 бонусов)

„OXI∍¹tï[D¹sÖ#<}äIiø}»

Попробуйте онлайн или проверьте еще несколько тестов .

NСначала принимает входные данные , затем логическое значение ( 0/ 1), должно ли оно вращаться или нет.

Использует унаследованную от Python версию 05AB1E, поскольку zip со списком строк неявно выравнивает и объединяет символы, в отличие от более новой версии 05AB1E для перезаписи Elixir.

Объяснение:

„OX         # Push string "OX"
   I∍       # Extend it to a size equal to the first input
            #  i.e. 9 → "OXOXOXOXO"
            #  i.e. 10 → "OXOXOXOXOX"
¹t          # Take the first input again, and square-root it
            #  i.e. 9 → 3.0
            #  i.e. 10 → 3.1622776601683795
  ï         # Then cast it to an integer, removing any decimal digits
            #  i.e. 3.0 → 3
            #  i.e. 3.1622776601683795 → 3
   [        # Start an infinite loop:
    D       #  Duplicate the integer
     ¹sÖ    #  Check if the first input is evenly divisible by that integer
            #   i.e. 9 and 3 → 1 (truthy)
            #   i.e. 10 and 3 → 0 (falsey)
        #   #  And if it is: stop the infinite loop
    <       #  If not: decrease the integer by 1
            #   i.e. 3 → 2
   }        # After the infinite loop:
ä           # Divide the string into that amount of equal sized parts
            #  i.e. "OXOXOXOXO" and 3 → ["OXO","XOX","OXO"]
            #  i.e. "OXOXOXOXOX" and 2 → ["OXOXO","XOXOX"]
 Ii }       # If the second input is truthy:
   ø        #  Zip/transpose; swapping rows/columns of the strings
            #   i.e. ["OXOXO","XOXOX"] → ["OX","XO","OX","XO","OX"]
»           # And finally join the strings in the array by newlines
            #  i.e. ["OXO","XOX","OXO"] → "OXO\nXOX\nOXO"
            #  i.e. ["OX","XO","OX","XO","OX"] → "OX\nXO\nOX\nXO\nOX"
            # (and output the result implicitly)

GolfScript 26 (41 - 10 - 5)

:x),1>{x\%!},.,2/=.x\/@{\}*'X'*n+*1>'O'\+

Ожидается, что в стеке будут два параметра:

• 0для нормального или 1для транспонированного
• nзначение

Шаблон состоит в том, что на доске полно Xs, а верхний левый угол - O. Излишне говорить, что этот шаблон сохраняется при транспонировании доски.

Демо: обычная , транспонированная

Mathematica, 71 символ

f@n_:=#<>"\n"&/@Array["O"&,{#,n/#}&[#[[⌊Length@#/2⌋]]&@Divisors@n]]<>""

Petit Computer BASIC, 72 байта

INPUT N,S$FOR I=1TO SQR(N)IF N%I<1THEN M=I
NEXT
?(S$*M+" "*(32-M))*(N/M)

J , 32 байта - 15 = 17 байтов

'XO'$~[|.](%,])i.@]{~0 i:~i.@]|]

Попробуйте онлайн!

Вращение контролируется флагом 0/1, принятым в качестве левого аргумента.

Сетчатка 0.8.2 , 66 байт + штраф 1 байт = 67

.+
$*X
((^|\3)(X(?(3)\3)))+(\3)*$
$3 $3$#4$*X
X(?=X* (X+))| X+
$1¶

Попробуйте онлайн! Объяснение:

.+
$*X

Преобразуйте входные данные в строку Xs.

((^|\3)(X(?(3)\3)))+(\3)*$

Первый проход внешнего захвата соответствует началу строки, в то время как на последующих проходах сопоставляется предыдущее значение внутреннего захвата. Внутренний захват затем увеличивается и сопоставляется. Результатом этого является то, что количество строк, потребляемых внешним захватом, представляет собой квадрат внутреннего захвата, который, следовательно, не может превышать квадратный корень из ввода. Между тем последующее повторение гарантирует, что внутренний захват является фактором длины строки.

$3 $3$#4$*X

Сохраните обнаруженный коэффициент и вычислите другой делитель, добавив количество последующих повторений.

X(?=X* (X+))| X+
$1¶

Переставьте факторы в прямоугольник.

Древесный уголь , 33 байта - 10 - 5 = 18

Ｎθ≔⌊Φ⊕θ¬∨‹×ιιθ﹪θιηＥ÷θη⭆η§XO⁺ιλ¿Ｎ⟲

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

Ｎθ

Вход N.

≔⌊Φ⊕θ¬∨‹×ιιθ﹪θιη

Возьмите диапазон 0.. N, оставьте только числа, чьи квадраты не меньше, Nи разделите N, и возьмите минимум этих чисел.

Ｅ÷θη⭆η§XO⁺ιλ

Используйте обнаруженный фактор, чтобы вывести прямоугольник соответствующей ширины и высоты, используя рисунок на шахматной доске. (Это должно быть ＵＯη÷θηXO¶OXдля 1-байтового сохранения, но это сейчас глючит.)

¿Ｎ⟲

Если второй вход не равен нулю, поверните выход. (Если требуется, чтобы второй вход был 0или 2является приемлемым, то это может быть ⟲Ｎдля 1-байтового сохранения.)