10

创建使网格尽可能靠近正方形的函数或程序

您将得到一个整数N作为输入，整数（1、2、3、25等）
输出必须是N个字母的完美矩形网格，并尽可能接近正方形
（wannabe）方块必须由用户指定的字母O或X之一组成

要点：

硬编码为仅O或X：+1
一个param（0/1，true / false，类似的东西）以旋转输出（例如5或8）：-10
设计正方形（以某种方式同时使用O和X）：-5

如果图案包含两种类型的字符（其中x / y轴> = 3）并且在水平或垂直翻转时保持不变（允许将Xs与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

如果可能，请提供在线示例。

— 马丁
source

功能是否足够，还是您需要完整的程序？

— 约翰·德沃夏克

“设计正方形...在9的情况下更改中心” –在哪种情况下图案不是棋盘格？你能举个例子吗？

— 约翰·德沃夏克

重新编辑：我是否正确地读到我得到了三分"xo"[i]而不是i？这似乎不值得。通常，您的所有奖励似乎都很少。

— John Dvorak 2014年

“某种模式”有点含糊。如果我用“ o”替换第一个“ x”，这算不算？

— John Dvorak

好问题。唯一有趣的奖金/罚分是轮换。就我个人而言，我会坚持使用一个硬编码字符（即将惩罚设为默认值），并消除所有可能的奖金/罚分，除了轮换之一。有太多的奖金或罚款不是一个好主意。重要的是要明确指出主要问题。

— 级，2013年

6

果酱（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

— 优化器
source

3

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。

— 马里纳斯
source

2

Haskell，59个字符

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

— 约翰·德沃拉克
source

2

果酱 25 22 21（31-10）

这是一个功能主体。如果您需要完整的程序，请添加riri到最前面。如果要将其用作代码块，请将其括在中{}。在cjam.aditsu.net上对其进行测试。

它使用输入作为两个整数参数：矩形是垂直（任何非零值）还是水平（零）的开关，以及O要使用的s 数。

: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";

1

对于大数，减量应该相当快，而不会损失字节数

— edc65

1

谁投票？为什么？

2

我只能猜测这是因为有人不考虑CJam一个真正的语言

— 约翰·德沃夏克

您的解释有点破。您目前正在编辑吗？

— John Dvorak 2014年

@JanDvorak是的，我正在编辑它的一半，不小心按了Tab键和Enter键。现在已修复。

2

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

— edc65
source

2

蟒蛇，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

— 埃米尔
source

感兴趣的在线示例：repl.it/Zq9

— Martijn

1

测试后您更改了吗？我尝试了一下，但它不起作用，例如，f(8)给了我一列8 Os的信息，这是不正确的。

— marinus 2014年

@marinus：我确实进行了测试，但似乎复制了错误的版本。有一个>地方，应该有一个<。现在已修复。感谢您的来信！

— 埃米尔（Emil）2014年

1

Ruby，74岁

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

说明

输入作为lambda的参数。它期望一个Integer。
检查n（输入）是否可被1到的每个整数整除n。
- 如果是这样，计算长度和宽度之间的差。
- 如果不是，请返回一个大数字（n）。
采取最小的长度-宽度差异以最好地类似于正方形。
使用（过于简洁）String#*方法“绘制”正方形。

— 英国茶
source

我为什么被否决？我的答案是否包含错误？

— britishtea

你有错字最后一个单词应该是“ square”，并且您有“ sqaure”。（我不是拒绝投票的人，我指出了这个错误）。

— Ismael Miguel

1

APL（Dyalog Unicode），30-15 = 15 字节^SBCS

匿名中缀lambda。将N作为右参数，并将param作为左参数。矩形将具有X和O条纹或被支票。

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

在线尝试！

{…… } “ dfn”；⍺是左参数（param），⍵是右参数（N）：

⍳⍵ ɩ1 …N

∘.×⍨ 该乘法表

⍵= 掩模其中Ñ等于

⍸ ɩ在面具真值的ndices

c← 将其存储在c（用于c和 ididates）

≢ 汇总候选人

.5× 一半乘以那个

⌈ 天花板（向上）

⊃∘c 从中选择那个元素 c

⍴∘'XO' 用它来周期性地重塑“ XO”

⍉⍣⍺ 如果参数则转置

— 亚当
source

1

05AB1E（旧版），得分：7（22 字节 -15奖金）

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

在线尝试或验证更多测试用例。

首先获取输入N，然后获取布尔值（0/ 1）是否应该旋转。

使用05AB1E的Python旧版本，因为带有字符串列表的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)

— 凯文·克鲁伊森
source

0

GolfScript 26（41-10-5）

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

期望两个参数在堆栈上：

0正常或1换位
该n值

模式是板上满是Xs，左上角是O。毋庸置疑，在对电路板进行转位时，会保持这种模式。

演示：常规，移调

— 克里斯蒂安·卢帕斯库（Cristian Lupascu）
source

0

Mathematica，71个字符

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

— Alephalpha
source

0

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)

— 12Me21
source

0

J，32个字节-15 = 17个字节

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

在线尝试！

旋转由作为左参数的0/1标志控制

— 约拿
source

0

视网膜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¶

将因子重新排列为矩形。

— 尼尔
source

0

木炭，33字节-10-5 = 18

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

在线尝试！链接是详细版本的代码。说明：

Ｎθ

输入N。

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

取范围0.. N，仅保留平方不小于N和除的数N，并取最小的那些数。

Ｅ÷θη⭆η§XO⁺ιλ

使用发现的因子使用棋盘图案输出适当宽度和高度的矩形。（这应该是ＵＯη÷θηXO¶OX为了节省1字节，但是现在有很多错误。）

¿Ｎ⟲

如果第二个输入非零，则旋转输出。（如果要求第二个输入是0或2可接受的，则可能是⟲Ｎ为了节省1个字节。）

— 尼尔
source

创建一个尽可能靠近正方形的网格

果酱（16）（31-10-5）

APL（36-5-10 = 21）

Haskell，59个字符

果酱 25 22 21（31-10）

说明

JavaScript（E6）84（83 + 1）或101（116-10-5）

蟒蛇，79 75（无奖金）

Ruby，74岁

说明

APL（Dyalog Unicode），30-15 = 15 字节SBCS

05AB1E（旧版），得分：7（22 字节 -15奖金）

GolfScript 26（41-10-5）

Mathematica，71个字符

Petit Computer BASIC，72字节

J，32个字节-15 = 17个字节

视网膜0.8.2，66字节+ 1字节罚款= 67

木炭，33字节-10-5 = 18

APL（Dyalog Unicode），30-15 = 15 字节^SBCS