สร้างฟังก์ชั่นหรือโปรแกรมที่ทำให้กริดใกล้เคียงกับสแควร์มากที่สุด

• คุณจะได้รับจำนวนเต็มNเป็นอินพุตจำนวนเต็ม (1,2,3,25 และอื่น ๆ )
• ผลลัพธ์จะต้องเป็นตารางสี่เหลี่ยมที่สมบูรณ์แบบของตัวอักษรNที่ใกล้เคียงกับสี่เหลี่ยมมากที่สุด
• สแควร์ (ตะกาย) ต้องประกอบด้วยหนึ่งในตัวอักษร O หรือ X ตามที่ระบุโดยผู้ใช้

คะแนน :

• ฮาร์ดโค้ดเป็น O เท่านั้นหรือ X: +1
• พารามิเตอร์ (0/1, จริง / เท็จ, บางอย่างที่คล้ายกัน) เพื่อหมุนเอาต์พุต (เช่น 5 หรือ 8): -10
• ออกแบบสี่เหลี่ยม (ใช้ทั้ง O และ X ในรูปแบบบางแบบ): -5

รูปแบบถือว่าใช้ได้ถ้ามีอักขระทั้งสองประเภท (โดยที่ x / y-axis> = 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

หากเป็นไปได้โปรดระบุตัวอย่างออนไลน์

CJam, 16 (31 - 10 - 5)

สิ่งนี้จะใช้จำนวนเต็มสองจำนวนคืออินพุท, อันแรกที่เป็น0หรือ1สำหรับทิศทางและอันที่สองคือจำนวนของOหรือXในกริด

มันพิมพ์สลับกันและOX

: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'⍴⍨: สร้างเมทริกซ์ขนาดนั้นและเติมเต็มด้วยการสลับและOX

Haskell, 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←⍸⍵=∘.×⍨⍳⍵}

ลองออนไลน์!

{… } "dfn"; ⍺เป็นอาร์กิวเมนต์ที่เหลือ (param) ⍵คืออาร์กิวเมนต์ที่ถูกต้อง ( N ):

 ⍳⍵ ɩ ndices 1 ... N

 ∘.×⍨ ตารางสูตรคูณของ

 ⍵= หน้ากากที่Nเท่ากับ

 ⍸ ɩ ndices ของค่าจริงในหน้ากาก

 c← เก็บที่ในc(สำหรับc andidates)

 ≢ นับผู้สมัคร

 .5× ครึ่งหนึ่งคูณด้วยสิ่งนั้น

 ⌈ เพดาน (ปัดขึ้น)

 ⊃∘c เลือกองค์ประกอบนั้นจาก c

 ⍴∘'XO' ใช้มันเพื่อเปลี่ยนรูป "XO" เป็นวงกลม

 ⍉⍣⍺ ขนย้ายถ้าพารามิเตอร์

05AB1E (ดั้งเดิม)คะแนน: 7 (22 ไบต์ - 15 โบนัส)

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

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบบางมากขึ้น

รับอินพุตNก่อนจากนั้นบูลีน ( 0/ 1) ว่าควรหมุนหรือไม่

ใช้เวอร์ชัน Python ดั้งเดิมของ 05AB1E ตั้งแต่ zip ที่มีรายชื่อสตริงแบนราบและเชื่อมอักขระเข้าด้วยกันโดยไม่เหมือนกับ Elixir รุ่นใหม่ที่เขียนใหม่ของ 05AB1E

คำอธิบาย:

„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ค่า

รูปแบบคือการที่คณะกรรมการจะเต็มไปด้วยและที่มุมบนซ้ายเป็นX 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¶

จัดเรียงปัจจัยต่าง ๆ ให้เป็นรูปสี่เหลี่ยมผืนผ้า

Charcoal , 33 ไบต์ - 10 - 5 = 18

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｎθ

Nอินพุต

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

ใช้ช่วง0.. N, เก็บเฉพาะตัวเลขที่มีกำลังสองไม่น้อยกว่าNและหารNและใช้จำนวนน้อยที่สุด

Ｅ÷θη⭆η§XO⁺ιλ

ใช้ปัจจัยที่ค้นพบเพื่อแสดงผลสี่เหลี่ยมความกว้างและความสูงที่เหมาะสมโดยใช้รูปแบบ chequerboard (สิ่งนี้ควรเป็นการＵＯη÷θηXO¶OXประหยัดขนาด 1 ไบต์ แต่ตอนนี้เป็นบั๊กกี้)

¿Ｎ⟲

หากอินพุตที่สองไม่ใช่ศูนย์ให้หมุนเอาต์พุต (หากต้องการให้อินพุตที่สองเป็น0หรือ2ยอมรับก็อาจเป็นการ⟲Ｎประหยัดขนาด 1 ไบต์)