Tạo một hàm hoặc chương trình làm cho lưới càng gần hình vuông càng tốt

• Bạn sẽ được cấp một số nguyên N làm đầu vào, toàn bộ số (1,2,3,25, v.v.)
• Đầu ra phải là một lưới hình chữ nhật hoàn hảo gồm N chữ cái càng gần hình vuông càng tốt
• Hình vuông (wannabe) phải bao gồm một trong các chữ cái O hoặc X theo chỉ định của người dùng

Điểm :

• Mã hóa cứng chỉ O hoặc X: +1
• Một thông số (0/1, đúng / sai, tương tự) để xoay đầu ra (như với 5 hoặc 8): -10
• Thiết kế hình vuông (sử dụng cả O và X theo một số kiểu mẫu): -5

Một mẫu được coi là hợp lệ nếu nó chứa cả hai loại ký tự (trong đó trục x / y> = 3) và mẫu vẫn giữ nguyên khi được lật theo chiều ngang hoặc chiều dọc (cho phép trao đổi X với Os)

Ví dụ

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

Các ví dụ không được phép (không phải hàng hoặc cột có cùng chiều dài)

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

Nếu có thể xin vui lòng cung cấp một ví dụ trực tuyến.

CJam, 16 (31 - 10 - 5)

Điều này có hai số nguyên là đầu vào, đầu tiên là một 0hoặc 1cho hướng và thứ hai là số lượng Ohoặc Xtrong lưới.

Nó in một thay thế Ovà X.

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

Đây chỉ là phần thân hàm, để dùng thử, thêm l~vào trước mã như:

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

và đưa ra đầu vào như

0 10

để có được đầu ra như

OXOXO
XOXOX

hoặc nhập như

1 10

cho

OX
OX
OX
OX
OX

Dùng thử trực tuyến tại đây

Làm thế nào nó hoạt động:

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

Chạy ví dụ:

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/⍵]}

Đối số bên trái là xoay vòng, đối số bên phải là kích thước. Nó cũng sử dụng một mẫu đơn giản (nó chỉ xen kẽ 'X' và '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       

Giải trình:

• ∆←,⍳2/⍵: tạo tất cả các cặp số có thể từ 1đến ⍵và lưu trữ trong ∆.
• ∆←∆[⍋|-/¨∆... ]: Sắp xếp ∆tăng dần theo độ chênh lệch tuyệt đối của hai số trong mỗi cặp và lưu lại kết quả ∆.
• ⊃∆/⍨⍵=×/¨∆: cho mỗi cặp, nhân các số với nhau. Chỉ chọn các cặp nhân với ⍵và lấy cặp đầu tiên khớp với (đó là 'vuông nhất' vì sắp xếp).
• ⍺⌽: xoay danh sách độ dài (có 2 phần tử) theo ⍺.
• 'OX'⍴⍨: tạo một ma trận có kích thước đó và điền vào nó xen kẽ Ovà X.

Haskell, 59 ký tự

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

Camam 25 22 21 (31 - 10)

Đây là một cơ quan chức năng. Nếu bạn muốn một chương trình hoàn chỉnh, thêm ririvào phía trước. Nếu bạn muốn sử dụng nó như một khối mã, hãy bao quanh nó {}. Kiểm tra nó trên cjam.aditsu.net .

Nó nhận đầu vào là hai đối số nguyên: công tắc cho dù hình chữ nhật là dọc (bất kỳ giá trị khác không) hay ngang (không) và số Os sẽ sử dụng.

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

Giải trình

: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) hoặc 101 (116-10-5)

Mẫu + xoay (tham số f, 0 hoặc 1) - tiền thưởng 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)
}

Không mẫu, không xoay - phạt 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));
}

Kiểm tra trong bảng điều khiển FireFox / FireBug

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (không có tiền thưởng)

Phần thưởng có vẻ khó, vì vậy đây là một hàm Python khá đơn giản:

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

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

Giải trình

• Đầu vào được lấy làm đối số cho lambda. Nó mong đợi một Integer.
• Kiểm tra xem n(đầu vào) có chia hết cho mọi số nguyên từ 1 đến không n.
  • Nếu có, hãy tính chênh lệch giữa chiều dài và chiều rộng.
  • Nếu không, trả về một số lượng lớn ( n).
• Lấy sự khác biệt nhỏ nhất của chiều dài chiều rộng để giống nhất với hình vuông.
• Sử dụng String#*phương pháp (súc tích quá mức) để "vẽ" hình vuông.

APL (Dyalog Unicode) , 30 - 15 = 15 byte ^SBCS

Vô danh lambda. Đưa N làm đối số phải và param là đối số bên trái. Hình chữ nhật sẽ có các sọc X và O hoặc được kiểm tra.

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

Hãy thử trực tuyến!

{... } "DFN"; ⍺là đối số bên trái (param), ⍵là đối số bên phải ( N ):

 ⍳⍵ số 1 1 N

 ∘.×⍨ bảng nhân của đó

 ⍵= mặt nạ trong đó N bằng

 ⍸ thông tin về các giá trị thực trong mặt nạ

 c← lưu trữ trong c(cho c andidates)

 ≢ kiểm đếm các ứng cử viên

 .5× một nửa nhân với điều đó

 ⌈ trần nhà (làm tròn lên)

 ⊃∘c chọn yếu tố đó từ c

 ⍴∘'XO' sử dụng nó để định hình lại theo chu kỳ "XO"

 ⍉⍣⍺ chuyển vị nếu param

05AB1E (di sản) , điểm: 7 (22 byte - 15 tiền thưởng)

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

Hãy thử trực tuyến hoặc xác minh một số trường hợp thử nghiệm .

Lấy đầu vào Ntrước, sau đó là boolean ( 0/ 1) xem nó có nên xoay hay không.

Sử dụng phiên bản kế thừa Python của 05AB1E kể từ zip với danh sách chuỗi hoàn toàn làm phẳng và nối các ký tự, không giống như phiên bản viết lại Elixir mới hơn của 05AB1E.

Giải trình:

„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'\+

Yêu cầu hai tham số sẽ nằm trên ngăn xếp:

• 0cho bình thường hoặc 1cho chuyển
• các ngiá trị

Mô hình là bảng đầy Xs và góc trên cùng bên trái là một O. Không cần phải nói, mô hình này được duy trì khi hoán chuyển bảng.

Demo: thường xuyên , chuyển đổi

Toán học, 71 ký tự

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

Máy tính Petit BASIC, 72 byte

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

J , 32 byte - 15 = 17 byte

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

Hãy thử trực tuyến!

Xoay được điều khiển bởi cờ 0/1 được lấy làm đối số bên trái

Retina 0.8.2 , 66 byte + 1 byte phạt = 67

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

Hãy thử trực tuyến! Giải trình:

.+
$*X

Chuyển đổi đầu vào thành một chuỗi Xs.

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

Đường chuyền đầu tiên của lần chụp bên ngoài khớp với điểm bắt đầu của chuỗi trong khi ở lần tiếp theo, giá trị trước đó của lần chụp bên trong được khớp. Việc chụp bên trong sau đó được tăng lên và khớp. Kết quả cuối cùng là số lượng chuỗi được sử dụng bởi chụp bên ngoài là bình phương của chụp bên trong, do đó không thể vượt quá căn bậc hai của đầu vào. Trong khi đó, sự lặp lại tiếp theo đảm bảo rằng sự bắt giữ bên trong là một yếu tố của độ dài của chuỗi.

$3 $3$#4$*X

Lưu yếu tố được phát hiện và tính toán ước số khác bằng cách thêm vào số lần lặp lại tiếp theo.

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

Sắp xếp lại các yếu tố thành một hình chữ nhật.

Than , 33 byte - 10 - 5 = 18

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｎθ

Đầu vào N.

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

Lấy phạm vi 0.. N, chỉ giữ các số có bình phương không nhỏ hơn Nvà chia Nvà lấy tối thiểu các số đó.

Ｅ÷θη⭆η§XO⁺ιλ

Sử dụng yếu tố được phát hiện để xuất ra một hình chữ nhật có chiều rộng và chiều cao phù hợp bằng cách sử dụng mẫu bảng điều khiển. (Điều này nên ＵＯη÷θηXO¶OXđể tiết kiệm 1 byte nhưng đó là lỗi ngay bây giờ.)

¿Ｎ⟲

Nếu đầu vào thứ hai là khác không thì xoay đầu ra. (Nếu yêu cầu đầu vào thứ hai phải 0hoặc 2có thể chấp nhận được, thì đây có thể là ⟲Ｎđể tiết kiệm 1 byte.)