अनुमानित वर्ग गठन

Question

पृष्ठभूमि

मेरे पास समान आकार के वर्ग-आकार के बक्से का एक गुच्छा है, और चूंकि मैं एक साफ-सुथरा व्यक्ति हूं, इसलिए मैं उन सभी को एक वर्ग गठन में व्यवस्थित करना चाहता हूं। हालांकि, उनकी संख्या जरूरी नहीं कि एक पूर्ण वर्ग है, इसलिए मुझे वर्ग आकार का अनुमान लगाना पड़ सकता है। मैं चाहता हूं कि आप मुझे सबसे सौंदर्यवादी मनभावन व्यवस्था - प्रोग्रामिक रूप से, निश्चित रूप से मिल जाए।

इनपुट

आपका इनपुट एक एकल धनात्मक पूर्णांक है k, जो बॉक्स की संख्या का प्रतिनिधित्व करता है।

उत्पादन

आपका कार्यक्रम दो सकारात्मक पूर्णांक का चयन करेगा m, nजो m*(n-1) < k ≤ m*nधारण करता है। वे बड़े वर्ग जैसी आकृति की चौड़ाई और ऊँचाई का प्रतिनिधित्व करते हैं जो हम व्यवस्थित कर रहे हैं। चूंकि हम सौंदर्य की दृष्टि से मनभावन आकृतियों की तलाश कर रहे हैं, मात्रा कम से कम होगी, ताकि आकार एक वर्ग के करीब हो, और इसका क्षेत्रफल करीब हो । यदि जोड़ी के लिए अभी भी कई उम्मीदवार हैं, तो उस जगह को चुनें जहां चौड़ाई अधिकतम है।(m - n)2 + (m*n - k)2k(m, n)m

अब, आपका वास्तविक आउटपुट संख्या और नहीं होगा । इसके बजाय, आप एक बॉक्स का प्रतिनिधित्व करने के लिए चरित्र का उपयोग करके, बक्से की व्यवस्था को प्रिंट करेंगे । विशेष रूप से, आप पंक्तियों को मुद्रित करेंगे , जिनमें से प्रत्येक में वर्ण होते हैं , और फिर वर्णों में से एक पंक्ति । ध्यान दें कि आउटपुट में ठीक अक्षर हैं ।mn#n-1m#k - m*(n-1)#k#

नियम और स्कोरिंग

आउटपुट में कोई भी अग्रणी या अनुगामी व्हाट्सएप नहीं होगा, सिवाय इसके कि अंतिम पंक्ति को अनुगामी स्थानों के साथ गद्देदार बनाया जा सकता है m, यदि वांछित हो। एक अनुगामी न्यूलाइन हो सकती है, लेकिन कोई पूर्ववर्ती न्यूलाइन्स नहीं। यदि आप चाहें तो किसी भी मुद्रण योग्य ASCII चरित्र का उपयोग कर सकते हैं #।

आप एक पूरा कार्यक्रम लिख सकते हैं, या एक फ़ंक्शन से एक स्ट्रिंग वापस कर सकते हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

यहां कुछ इनपुट मानों के लिए सही आउटपुट दिए गए हैं।

1
#
2
##
3
##
#
4
##
##
8
###
###
##
13
#####
#####
###
17
######
######
#####
18
#####
#####
#####
###
20
#####
#####
#####
#####
21
######
######
######
###
22
######
######
######
####
23
#####
#####
#####
#####
###

Answer 1

पायथ, 28 बाइट्स

jbc*\#Qho.a,,N*NJ_/_QN,JQ_SQ

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

क्रुक्स यह है कि मैं निम्नलिखित संपत्ति पर संभावित मीटर सॉर्ट करता हूं:

(m - ceil(k/m))^2 + (m*ceil(k/m) - k)^2

की कुल अनुपस्थिति पर ध्यान दें n। कुल आकार केवल द्वारा परिभाषित किया गया है m। फिर मैं उपरोक्त संपत्ति को एक बार फिर से बदल देता हूं, और मेरे अंतिम छंटाई के वजन को निम्नलिखित दो बिंदुओं के बीच यूक्लिडियन दूरी के रूप में परिभाषित किया जाता है:

(m, m*ceil(k/m)) and (ceil(k/m), k)

यह वजन मूल्यों को बदलता है, लेकिन उनका क्रम नहीं।

Answer 2

पायथन 3, 202 बाइट्स

मुझे पता है कि CJam या Pyth समाधानों की तुलना में इसका समय अधिक है, लेकिन फिर भी, यहाँ Python में इस समस्या को हल करने का एक तरीका है:

k=int(input())
r,d,s=range(k+1),{},'#'*k
for n in r:
 for m in r:
  if m*n>=k:
   d[m,n]=(m-n)**2+(m*n-k)**2
x,y=max(i for i in d.keys()if d[i]==min(d.values()))
[print(s[i*x:(i*x+x])for i in range(y+1)]

मूल सिद्धांत यह है कि हम जानते हैं कि m और n दोनों k से कम हैं। इसके अलावा, एम * एन> = के। इसका मतलब है कि हम केवल उन सभी m, n <k के लिए चुनौती में दी गई अभिव्यक्ति का न्यूनतम मान पा सकते हैं, जिनमें उन मानों को छोड़कर, जिनका उत्पाद k से अधिक है।

Comments

मैं वास्तव में आपके स्रोत में 231 बाइट्स की गिनती करता हूं, 234 नहीं। लेकिन परवाह किए बिना, आप इसे अपने इंडेंट आकार को चार स्थानों से एक स्थान तक घटाकर कम कर सकते हैं। यह वही काम करेगा।

— एलेक्स ए।

यह आपके बाइट की गिनती प्राप्त करने के लिए एक उपयोगी उपकरण है। वैसे, साइट पर अच्छा सबमिशन और स्वागत है!

— एलेक्स ए।

:लाइन 5 पर गायब होना। कॉम्मा वह है जो एक टपल को परिभाषित करता है, कोष्ठक ()को लाइन 6 पर हटाया जा सकता है। बीच में रिक्त स्थान )और ( ifया for) भी। maxजनरेटर को पैरामीटर के रूप में प्राप्त कर सकते हैं, इस प्रकार कोष्ठक []निरर्थक हैं। आप dकुंजियों पर पुनरावृति करते हैं , ताकि आप सुरक्षित रूप से उपयोग कर सकें d[i]।

— ट्रांग ओउल

आप को बदलने के दो बाइट्स बचा सकते हैं (i+1)*xकरने के लिए -~i*xया i*x+x।

— केड

आपके पास एक अतिरिक्त, अमान्य (i*x+x

— पार्न है

Answer 3

CJam ( 44 42 बाइट्स)

qi_,{)_2$d\/m]_2$-_*@@*2$-_*+~}$W=)'#@*/N*

ऑनलाइन डेमो

मैं बल्कि चौकोर जड़ों को शामिल करने के लिए एक सरल समाधान होने की उम्मीद कर रहा था, लेकिन यह बिल्कुल सरल नहीं है। इनपुट के 31लिए पंक्ति की चौड़ाई वर्गमूल की छत से दो गुना अधिक है; के लिए 273(वर्गमूल सिर्फ 16.5 से अधिक) सबसे अच्छा अनुमानित वर्ग एक सही 21x13 आयत है।

Answer 4

सीजेएम, 42 बाइट्स

li:K_,f-{:XdK\/m]:YX-_*XY*K-_*+}$0='#K*/N*

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

स्पष्टीकरण:

li    Get and interpret input.
:K    Store in variable K for later use.
_     Copy.
,     Build sequence [0 .. K-1].
f-    Subtract from K, to get sequence [K .. 1]. Larger values have to come
      first so that they are ahead in ties when we sort later.
{     Begin block for calculation of target function for sort.
  :X    Store width in variable X.
  d     Convert to double.
  K\/   Calculate K/X.
  m]    Ceiling.
  :Y    Store height in variable Y.
  X-    Calculate Y-X.
  _*    Square it.
  XY*   Calculate X*Y...
  K-    ... and X*Y-K
  _*    Square it.
  +     Add the two squares.
}$    Sort by target function value.
0=    Get first element, this is the best width.
'#K*  Build string of K '# characters.
/     Split using width.
N*    Join with newlines.