10

एक फ़ंक्शन या प्रोग्राम बनाएं जो ग्रिड को यथासंभव एक वर्ग के करीब बनाता है

आपको एक पूर्णांक एन इनपुट के रूप में दिया जाएगा , पूरे नंबर (1,2,3,25, आदि)
आउटपुट एन अक्षर का एक सही आयताकार ग्रिड होना चाहिए, जितना संभव हो एक वर्ग के करीब
(Wannabe) वर्ग में उपयोगकर्ता द्वारा निर्दिष्ट O या X अक्षरों में से एक होना चाहिए

अंक :

केवल O या X: +1 के लिए हार्डकोड किया गया
आउटपुट को घुमाने के लिए एक परम (0/1, सच / गलत, कुछ इसी तरह) (जैसे 5 या 8 के साथ): -10
वर्ग को डिज़ाइन करें (कुछ प्रकार के पैटर्न में ओ और एक्स दोनों का उपयोग करें): -5

एक पैटर्न को वैध माना जाता है यदि इसमें दोनों प्रकार के वर्ण (जहाँ x / y- अक्ष> = 3) हो और पैटर्न एक ही रहता है जब क्षैतिज रूप से या लंबवत रूप से फ़्लिप किया जाता है (ओएस के साथ एक्स का आदान-प्रदान करने की अनुमति है)

उदाहरण

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

यदि संभव हो तो कृपया एक ऑनलाइन उदाहरण प्रदान करें।

— Martijn
स्रोत

क्या एक फ़ंक्शन पर्याप्त है, या क्या आप एक पूर्ण कार्यक्रम चाहते हैं?

— जॉन ड्वोरक

"9 वर्ग के मामले में केंद्र को डिज़ाइन करें ..." - किन परिस्थितियों में पैटर्न एक बिसात नहीं है? क्या आप एक उदाहरण प्रदान कर सकते हैं?

— जॉन ड्वोरक

संपादित करें: क्या मैं सही ढंग से पढ़ता हूं कि मुझे "xo"[i]इसके बजाय करने के लिए तीन अंक मिलते हैं i? यह इसके लायक नहीं लगता है। सामान्य तौर पर, आपके सभी पुरस्कार थोड़े कम लगते हैं।

— जॉन ड्वोरक

"कुछ प्रकार का पैटर्न" थोड़े अस्पष्ट है। यदि मैं पहले 'x' को 'o' से बदलूं तो क्या इसकी गिनती होती है?

— जॉन ड्वोरक

अच्छा प्रश्न। केवल दिलचस्प बोनस / जुर्माना रोटेशन एक है। व्यक्तिगत रूप से मैं एक, हार्डकोड वर्ण (यानी दंड को डिफ़ॉल्ट बनाता हूं) के साथ रहना होगा और शायद रोटेशन को छोड़कर सभी बोनस / दंड को समाप्त कर दूंगा। बहुत अधिक बोनस या दंड देना अच्छा नहीं है। मुख्य बात स्पष्ट रूप से मुख्य समस्या को निर्दिष्ट करना है।

— लेवल रिवर सेंट

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

— अनुकूलक
स्रोत

3

एपीएल (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।

— मारीनस
स्रोत

2

हास्केल, 59 वर्ण

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

— जॉन ड्वोरक
स्रोत

2

CJam, 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

बड़ी संख्या के लिए

— गिरावट

1

किसने उतारा? क्यों?

2

मैं केवल इसका अनुमान लगा सकता हूं क्योंकि कोई सीजेएम को वास्तविक भाषा नहीं मानता है

— जॉन ड्वोरक

आपकी व्याख्या थोथा टूटी हुई है। क्या आप वर्तमान में संपादन कर रहे हैं?

— जॉन डेवोरक

@JDDvorak हाँ, मैं इसे संपादित करने और गलती से टैब और एंटर दबाकर आधा हो गया था। यह अब तय हो गया है।

2

जावास्क्रिप्ट (E6) 84 (83 + 1) या 101 (116-10-5)

पैटर्न + रोटेशन (पैरामीटर एफ, 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
स्रोत

2

पायथन, 79 75 (कोई बोनस नहीं)

बोनस मुश्किल लग रहा है, तो यहाँ एक बहुत ही सरल अजगर समारोह है:

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

— एमिल
स्रोत

इच्छुक के लिए ऑनलाइन उदाहरण: repl.it/Zq9

— Martijn

1

क्या आपने परीक्षण के बाद इसे बदल दिया? मैंने यह कोशिश की और यह काम नहीं करता है, उदाहरण के लिए f(8)मुझे 8 Oएस का एक कॉलम दिया , जो गलत है।

— मारिनस

@marinus: मैंने इसका परीक्षण किया था लेकिन लगता है कि एक गलत संस्करण की नकल की है। >जहाँ होना चाहिए था वहाँ एक था <। यह अब तय हो गया है। नोट के लिए धन्यवाद!

— एमिल

1

रूबी, 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#*वर्ग को "आकर्षित" करने के लिए (अत्यधिक संक्षिप्त) विधि का उपयोग करें ।

— britishtea
स्रोत

मुझे क्यों अपमानित किया गया? क्या मेरे उत्तर में एक बग है?

— ब्रितीष्टा

आपके पास एक टाइपो है। अंतिम शब्द "वर्ग" होना चाहिए और आपके पास "sqaure" होना चाहिए। (मैं नीच नहीं हूं, मैं इस गलती की ओर इशारा कर रहा हूं)।

— इस्माईल मिगुएल

1

एपीएल (डायलॉग यूनिकोड) , 30 - 15 = 15 बाइट्स ^{एसबीसीएस}

अनाम शिशु लाम्बा। N को दाएं तर्क के रूप में और बाएं तर्क को परम के रूप में लेता है। रेक्टैंगल्स में या तो एक्स और ओ की धारियां होंगी या जांच की जाएगी।

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

इसे ऑनलाइन आज़माएं!

{... } "डीएफएन"; ⍺बाएं तर्क (परम) है, ⍵सही तर्क है ( एन ):

⍳⍵ d ndices 1… N

∘.×⍨ उस की गुणा तालिका

⍵= मास्क जहां एन के बराबर है

⍸ mask मास्क में सच्चे मूल्यों की ndices

c← दुकान में है कि c(के लिए ग andidates)

≢ उम्मीदवारों का मिलान करें

.5× एक आधा उससे गुणा होता है

⌈ छत (राउंड अप)

⊃∘c उस तत्व को उठाओ c

⍴∘'XO' "एक्सओ" को चक्रीय रूप से फिर से व्यवस्थित करने के लिए उपयोग करें

⍉⍣⍺ पारम अगर

— एडम
स्रोत

1

05AB1E (विरासत) , स्कोर: 7 (22 बाइट्स - 15 बोनस)

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

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

Nपहले इनपुट लेता है , फिर बूलियन ( 0/ 1) यह घूमना चाहिए या नहीं।

05AB1E के पायथन विरासत संस्करण का उपयोग करता है क्योंकि एक स्ट्रिंग-सूची के साथ ज़िप समतल रूप से समतल होता है और 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)

— केविन क्रूज़सेन
स्रोत

0

गोल्फस्क्रिप्ट 26 (41 - 10 - 5)

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

स्टैक पर दो पैरामीटर होने की उम्मीद है:

0सामान्य या 1प्रत्यारोपित के लिए
nमूल्य

पैटर्न यह है कि बोर्ड एस से भरा है Xऔर शीर्ष बाएं कोने में ए है O। कहने की जरूरत नहीं है, बोर्ड को ट्रांसपोज़ करते समय यह पैटर्न बना रहता है।

डेमो: नियमित , प्रत्यारोपित

— क्रिस्टियन लुपस्कू
स्रोत

0

गणितज्ञ, 71 वर्ण

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

— alephalpha
स्रोत

0

पेटिट कंप्यूटर बेसिक, 72 बाइट्स

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

— 12Me21
स्रोत

0

जे , 32 बाइट्स - 15 = 17 बाइट्स

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

इसे ऑनलाइन आज़माएं!

रोटेशन को एक 0/1 ध्वज द्वारा नियंत्रित किया जाता है जिसे बाएं तर्क के रूप में लिया जाता है

— जोनाह
स्रोत

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¶

एक आयत में कारकों को पुनर्व्यवस्थित करें।

— नील
स्रोत

0

चारकोल , 33 बाइट्स - 10 - 5 = 18

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｎθ

इनपुट N।

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

सीमा लें 0.. N, केवल उन संख्याओं को रखें, जिनके वर्ग किसी से कम नहीं हैं Nऔर विभाजित हैं N, और उन संख्याओं में से कम से कम लें।

Ｅ÷θη⭆η§XO⁺ιλ

खोज विधि का उपयोग करें और एक चेम्बरबोर्ड पैटर्न का उपयोग करके उपयुक्त चौड़ाई और ऊंचाई की आयत का उत्पादन करें। (यह ＵＯη÷θηXO¶OX1 बाइट की बचत के लिए होना चाहिए लेकिन अभी यह छोटी गाड़ी है।)

¿Ｎ⟲

यदि दूसरा इनपुट नॉनजरो है तो आउटपुट को घुमाएं। (यदि दूसरे इनपुट की आवश्यकता हो 0या 2स्वीकार्य हो, तो यह ⟲Ｎ1-बाइट की बचत के लिए हो सकता है ।)

— नील
स्रोत

जितना संभव हो एक वर्ग के करीब एक ग्रिड बनाएं

सीजाम, 16 (31 - 10 - 5)

एपीएल (36 - 5 - 10 = 21)

हास्केल, 59 वर्ण

CJam, 25 22 21 (31 - 10)

व्याख्या

जावास्क्रिप्ट (E6) 84 (83 + 1) या 101 (116-10-5)

पायथन, 79 75 (कोई बोनस नहीं)

रूबी, 74

व्याख्या

एपीएल (डायलॉग यूनिकोड) , 30 - 15 = 15 बाइट्स एसबीसीएस

05AB1E (विरासत) , स्कोर: 7 (22 बाइट्स - 15 बोनस)

गोल्फस्क्रिप्ट 26 (41 - 10 - 5)

गणितज्ञ, 71 वर्ण

पेटिट कंप्यूटर बेसिक, 72 बाइट्स

जे , 32 बाइट्स - 15 = 17 बाइट्स

रेटिना 0.8.2 , 66 बाइट्स + 1 बाइट जुर्माना = 67

चारकोल , 33 बाइट्स - 10 - 5 = 18

एपीएल (डायलॉग यूनिकोड) , 30 - 15 = 15 बाइट्स ^{एसबीसीएस}