Buat fungsi atau program yang membuat kotak sedekat mungkin dengan kotak

• Anda akan diberikan integer N sebagai input, bilangan bulat (1,2,3,25, dll)
• Outputnya harus berupa kotak persegi sempurna huruf N sedekat mungkin dengan kotak
• Kotak (wannabe) harus terdiri dari salah satu huruf O atau X seperti yang ditentukan oleh pengguna

Poin :

• Hardcode hanya untuk O atau X: +1
• Param (0/1, true / false, sesuatu yang mirip) untuk memutar output (seperti dengan 5 atau 8): -10
• Desain kotak (gunakan O dan X dalam beberapa pola): -5

Suatu pola dianggap sah jika mengandung kedua jenis karakter (di mana sumbu x / y> = 3) dan pola tersebut tetap sama ketika dibalik secara horizontal atau vertikal (pertukaran Xs dengan Os diperbolehkan)

Contohnya

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

Contoh yang tidak diizinkan (baris atau kolom panjang tidak sama)

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

Jika memungkinkan, berikan contoh online.

CJam, 16 (31 - 10 - 5)

Ini membutuhkan dua bilangan bulat input, yang pertama adalah untuk 0atau 1untuk arah dan yang kedua adalah jumlah Oatau Xdalam grid.

Ini mencetak alternatif Odan X.

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

Ini hanya fungsi tubuh, untuk mencobanya tambahkan l~di depan kode seperti:

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

dan beri input like

0 10

untuk mendapatkan output seperti

OXOXO
XOXOX

atau masukan suka

1 10

untuk

OX
OX
OX
OX
OX

Cobalah online di sini

Bagaimana itu bekerja:

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

Contoh dijalankan:

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

Argumen kiri adalah rotasi, argumen kanan adalah ukuran. Ini juga menggunakan pola sederhana (itu hanya bergantian 'X' dan '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       

Penjelasan:

• ∆←,⍳2/⍵: menghasilkan semua pasangan angka yang mungkin dari 1ke ⍵dan simpan di ∆.
• ∆←∆[⍋|-/¨∆... ]: urutkan ∆naik dalam perbedaan absolut dari dua angka di setiap pasangan, dan simpan hasilnya kembali ∆.
• ⊃∆/⍨⍵=×/¨∆: untuk setiap pasangan, kalikan jumlahnya. Pilih hanya pasangan yang berkembang biak ⍵, dan ambil pasangan pertama yang cocok (yang 'paling persegi' karena jenisnya).
• ⍺⌽: memutar daftar panjang (yang memiliki 2 elemen) oleh ⍺.
• 'OX'⍴⍨: buat matriks ukuran itu, dan mengisinya dengan bolak-balik Odan X.

Haskell, 59 karakter

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)

Ini adalah fungsi tubuh. Jika Anda ingin program lengkap, tambahkan ririke depan. Jika Anda ingin menggunakannya sebagai blok kode, masukkan di dalamnya {}. Uji di cjam.aditsu.net .

Dibutuhkan input sebagai dua argumen integer: saklar untuk apakah persegi panjang itu vertikal (nilai tidak nol) atau horizontal (nol), dan jumlah Os yang digunakan.

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

Penjelasan

: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) atau 101 (116-10-5)

Pola + rotasi (parameter f, 0 atau 1) - bonus 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)
}

Tidak ada pola, tidak ada rotasi - penalti 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));
}

Uji di konsol FireFox / FireBug

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (tidak ada bonus)

Bonusnya terlihat rumit, jadi di sini ada fungsi Python yang cukup sederhana:

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

Penjelasan

• Masukan diambil sebagai argumen untuk lambda. Diharapkan Integer.
• Periksa apakah n(input) dapat dibagi oleh setiap bilangan bulat dari 1 hingga n.
  • Jika ya, hitung perbedaan antara panjang dan lebar.
  • Jika tidak, kembalikan sejumlah besar ( n).
• Ambil perbedaan terkecil dari panjang lebar yang paling menyerupai persegi.
• Gunakan metode (yang terlalu ringkas) String#*untuk "menggambar" kotak.

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

Lambda infix Anonim. Membawa N sebagai argumen benar dan param sebagai argumen kiri. Rectangles akan memiliki garis-garis X dan O atau kotak-kotak.

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

Cobalah online!

{... } "dfn"; ⍺adalah argumen kiri (param), ⍵adalah argumen kanan ( N ):

 ⍳⍵ d ndices 1… N

 ∘.×⍨ tabel perkalian itu

 ⍵= topeng di mana N sama dengan itu

 ⍸ ɩ ndices nilai true dalam mask

 c← simpan dalam c(untuk c andidates)

 ≢ tally para kandidat

 .5× setengah dikalikan dengan itu

 ⌈ langit-langit (bulat)

 ⊃∘c pilih elemen itu dari c

 ⍴∘'XO' menggunakannya untuk membentuk kembali "XO" secara siklus

 ⍉⍣⍺ transpos jika param

05AB1E (warisan) , skor: 7 (22 byte - 15 bonus)

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

Cobalah secara online atau verifikasi beberapa kasus uji lagi .

Mengambil input Nterlebih dahulu, lalu boolean ( 0/ 1) apakah itu harus diputar atau tidak.

Menggunakan versi Python legacy dari 05AB1E sejak zip dengan daftar string secara implisit meratakan dan bergabung dengan karakter, tidak seperti Elixir menulis ulang versi 05AB1E yang lebih baru.

Penjelasan:

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

Mengharapkan dua parameter berada di tumpukan:

• 0untuk normal atau 1untuk dialihkan
• yang nnilai

Polanya adalah bahwa papan penuh Xdengan dan sudut kiri atas adalah O. Tak perlu dikatakan, pola ini dipertahankan saat transpos papan.

Demo: teratur , dialihkan

Mathematica, 71 karakter

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

Petit Computer 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.@]|]

Cobalah online!

Rotasi dikendalikan oleh bendera 0/1 yang diambil sebagai argumen kiri

Retina 0.8.2 , 66 byte + penalti 1 byte = 67

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

Cobalah online! Penjelasan:

.+
$*X

Konversikan input ke string Xs.

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

Lintasan pertama dari tangkapan luar cocok dengan awal string sedangkan pada lintasan berikutnya nilai tangkapan dalam sebelumnya cocok. Tangkapan batin kemudian ditingkatkan dan dicocokkan. Hasilnya adalah jumlah string yang dikonsumsi oleh tangkapan luar adalah kuadrat dari tangkapan dalam, yang karenanya tidak dapat melebihi akar kuadrat dari input. Sementara itu, pengulangan berikutnya memastikan bahwa tangkapan bagian dalam adalah faktor dari panjang tali.

$3 $3$#4$*X

Simpan faktor yang ditemukan dan hitung pembagi lainnya dengan menambahkan jumlah pengulangan berikutnya.

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

Susun ulang faktor menjadi persegi panjang.

Arang , 33 byte - 10 - 5 = 18

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｎθ

Masukan N.

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

Ambil rentang 0.. N, simpan hanya angka-angka yang kuadratnya tidak kurang dari Ndan bagi N, dan ambil minimum dari angka-angka itu.

Ｅ÷θη⭆η§XO⁺ιλ

Gunakan faktor yang ditemukan untuk menghasilkan persegi panjang dengan lebar dan tinggi yang sesuai menggunakan pola papan catur. (Ini seharusnya ＵＯη÷θηXO¶OXuntuk penghematan 1-byte tapi itu buggy sekarang.)

¿Ｎ⟲

Jika input kedua bukan nol maka putar output. (Jika membutuhkan input kedua agar 0atau 2dapat diterima, maka ini bisa ⟲Ｎuntuk penghematan 1-byte.)