Bir kareyi olabildiğince kareye yakın yapan bir işlev veya program oluşturun

• Bir tam sayı verilecek N girişi, bütün bir sayı olarak (1,2,3,25, vs.)
• Çıktı , mümkün olduğunca kareye yakın N harflerinin mükemmel bir dikdörtgen ızgarası olmalıdır
• (Özenti) kare, kullanıcı tarafından belirtildiği gibi O veya X harflerinden birini içermelidir

Puanlar :

• Yalnızca O veya X'e sabit kodlanmış: +1
• Çıktıyı döndürmek için bir parametre (0/1, doğru / yanlış, benzer bir şey) (5 veya 8 gibi): -10
• Kareyi tasarlayın (hem O hem de X'i bir çeşit desende kullanın): -5

Bir kalıp, her iki karakter türünü de içeriyorsa (x / y ekseni> = 3 olduğunda) ve yatay veya dikey olarak çevrildiğinde kalıp aynı kalır (X'leri Os ile değiştirmeye izin verilir)

Örnekler

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

İzin verilmeyen örnekler (aynı uzunlukta satır veya sütunlar değil)

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

Mümkünse lütfen çevrimiçi bir örnek verin.

CJam, 16 (31-10-5)

Bu, birincisi yön için 0veya 1ikincisi giriş olmak üzere iki tamsayı alır ve ikincisi ızgaranın içindeki Oveya sayısıdır X.

Bir alternatif yazdırır Ove X.

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

Bu sadece fonksiyon gövdesi, denemek l~için kodun önüne ekleyin :

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

ve şöyle bir girdi verin

0 10

çıktı almak gibi

OXOXO
XOXOX

veya giriş gibi

1 10

için

OX
OX
OX
OX
OX

Buradan çevrimiçi deneyin

Nasıl çalışır:

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

Örnek çalışma:

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

Sol argüman döndürme, sağ argüman boyuttur. Ayrıca basit bir desen kullanır (sadece 'X' ve 'O' yerine geçer).

      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       

Açıklama:

• ∆←,⍳2/⍵: Numaralardan mümkün çiftlerini oluşturmak 1için ⍵ve mağaza içinde ∆.
• ∆←∆[⍋|-/¨∆... ]: ∆her bir çiftteki iki sayının mutlak farkına göre artan şekilde sıralayın ve sonucu tekrar saklayın ∆.
• ⊃∆/⍨⍵=×/¨∆: her çift için sayıları birlikte çarpın. Yalnızca çarpılan çiftleri seçin ⍵ve eşleşen ilk çifti alın (sıralama nedeniyle 'en kare' olan).
• ⍺⌽: uzunluk listesini (2 elemanı olan) döndürün ⍺.
• 'OX'⍴⍨: bu boyutta bir matris oluşturun ve alternatif Ove ile doldurun 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)

Bu bir işlev gövdesidir. Tam bir program istiyorsanız riri, öne ekleyin . Kod bloğu olarak kullanmak istiyorsanız onu çevreleyin {}. Cjam.aditsu.net adresinden test edin .

Girdiyi iki tamsayı bağımsız değişkeni olarak alır: dikdörtgenin dikey (sıfır olmayan herhangi bir değer) veya yatay (sıfır) ve Okullanılacak s sayısı anahtarı .

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

açıklama

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

Kalıp + dönüş (parametre f, 0 veya 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)
}

Desen yok, rotasyon yok - ceza 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 konsolunda test et

F(30,0)

OXOXOX
XOXOXO
OXOXOX
XOXOXO
OXOXOX

F(30,1)

OXOXO
XOXOX
OXOXO
XOXOX
OXOXO
XOXOX

Python, 79 75 (bonus yok)

Bonuslar zor görünüyor, bu yüzden oldukça basit bir Python işlevi:

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

Yakut, 74

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

açıklama

• Girdi bir lambda'ya argüman olarak alınır. Bekleyen bir Integer.
• n(Girişin) 1'den her tamsayıya bölünebilir olup olmadığını kontrol edin n.
  • Öyleyse, uzunluk ve genişlik arasındaki farkı hesaplayın.
  • Değilse, büyük bir sayı ( n) döndürün .
• Bir kareye en iyi benzemek için en küçük uzunluk-genişlik farklarını alın.
• Kullanım (aşırı özlü) String#*için yöntem kare "çizmek".

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

Anonim infix lambda. Alır N sol argüman olarak sağ argüman ve param olarak. Dikdörtgenler X ve O şeritlerine sahip olacak veya damalı olacaktır.

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

Çevrimiçi deneyin!

{… } "Dfn"; ⍺sol argüman (param), ⍵sağ argüman ( N ):

 ⍳⍵ ɩ 1 ... N ndices

 ∘.×⍨ bunun çarpım tablosu

 ⍵=N'nin buna eşit  olduğu maske

 ⍸ Maskede gerçek değerlerin bulunması

 c← bunu sakla c( c andidates için)

 ≢ adayları sayın

 .5× bunun yarısı ile çarpılır

 ⌈ tavan (yukarı doğru)

 ⊃∘c o elemanı seç c

 ⍴∘'XO' bunu "XO" yu periyodik olarak yeniden şekillendirmek için kullanın

 ⍉⍣⍺ eğer param olursa

05AB1E (eski) , skor: 7 (22 bayt - 15 bonus)

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

Çevrimiçi deneyin veya daha fazla test vakası doğrulayın .

NÖnce girdileri alır , sonra döndürülüp döndürülmeyeceği boole ( 0/ 1).

05AB1E'nin eski Python sürümünü kullanır, çünkü bir dize listesiyle zip, 05AB1E'nin daha yeni Elixir yeniden yazma sürümünün aksine, karakterleri dolaylı olarak düzleştirir ve birleştirir.

Açıklama:

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

İki parametrenin yığın üzerinde olmasını bekler:

• 0normal veya 1transpozisyon için
• ndeğer

Desen, tahta Xs ile dolu ve sol üst köşede bir O. Söylemeye gerek yok, bu desen tahta aktarılırken korunur.

Demo: düzenli , aktarılmış

Mathematica, 71 karakter

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

Petit Computer BASIC, 72 bayt

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

J , 32 bayt - 15 = 17 bayt

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

Çevrimiçi deneyin!

Dönüş sol argüman olarak alınan 0/1 bayrağı ile kontrol edilir

Retina 0.8.2 , 66 bayt + 1 bayt ceza = 67

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

Çevrimiçi deneyin! Açıklama:

.+
$*X

Girdiyi Xs dizgisine dönüştürün .

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

Dış yakalamanın ilk geçişi, dizenin başlangıcıyla eşleşirken, sonraki geçişlerde iç yakalamanın önceki değeri eşleştirilir. İç yakalama daha sonra artırılır ve eşleştirilir. Bunun sonucu, dış yakalama tarafından tüketilen dize miktarının, iç yakalamanın karesi olmasıdır, bu nedenle girdinin kare kökünü aşamaz. Bu arada sonraki tekrarlama, iç yakalamanın ipin uzunluğunun bir faktörü olmasını sağlar.

$3 $3$#4$*X

Bulunan faktörü kaydedin ve sonraki tekrarların sayısını ekleyerek diğer böleni hesaplayın.

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

Faktörleri bir dikdörtgene yeniden düzenleyin.

Kömür , 33 bayt - 10-5 = 18

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

Ｎθ

Giriş N.

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

Aralığı alın 0.. N, yalnızca kareleri küçük olmayan sayıları tutun Nve bölün Nve bu sayıların minimumunu alın.

Ｅ÷θη⭆η§XO⁺ιλ

Bir chequerboard deseni kullanarak uygun genişlik ve yükseklikte bir dikdörtgen elde etmek için keşfedilen faktörü kullanın. (Bu ＵＯη÷θηXO¶OX1 baytlık bir tasarruf için olmalı, ancak şu anda bu adamcağız.)

¿Ｎ⟲

İkinci giriş sıfır değilse, çıkışı döndürün. (İkinci girişin kabul edilmesi 0veya 2kabul edilebilir olması gerekiyorsa ⟲Ｎ, bu 1 baytlık bir tasarruf için olabilir.)