एक प्रोग्राम या फ़ंक्शन लिखें जो सकारात्मक पूर्णांक की सूची में लेता है। इनमें से प्रत्येक पूर्णांक 2 डी विमान पर एक वर्ग की ओर की लंबाई का प्रतिनिधित्व करता है। प्रत्येक वर्ग को विमान में किसी भी पूर्णांक निर्देशांक में ले जाया जा सकता है, लेकिन यह घूम नहीं सकता है और यह अन्य वर्गों को ओवरलैप नहीं कर सकता है।

प्रत्येक वर्ग के लिए एक अलग प्रिंट करने योग्य ASCII वर्ण का उपयोग करना (खाली स्थान जो खालीपन के लिए उपयोग किया जाता है) आपके प्रोग्राम / फ़ंक्शन को उन चौकों की किसी एक व्यवस्था को प्रिंट करने की आवश्यकता होती है जिसमें परावर्तक समरूपता की एक क्षैतिज या ऊर्ध्वाधर रेखा होती है। अगर ऐसी कोई व्यवस्था मौजूद नहीं है तो कुछ भी नहीं छापना चाहिए।

वर्ग अलग-अलग वर्ण हैं, इसलिए उन्हें अलग बताया जा सकता है। केवल सभी वर्गों के संघ द्वारा बनाई गई आकृति को सममित होने की आवश्यकता है। आप मान सकते हैं कि सूची में 94 से अधिक तत्व नहीं होंगे (क्योंकि 94 अक्षर हैं)।

उदाहरण के लिए, यदि इनपुट था [2, 1, 2, 2, 2], तो एक संभावित आउटपुट है:

DD--
DD--
Z
FFPP
FFPP

इस आकृति में परावर्तक समरूपता की एक क्षैतिज रेखा है; इसके ऊपरी और निचले हिस्से में दर्पण चित्र हैं। यहां कुछ अन्य संभावनाएं हैं: (ध्यान दें कि वर्गों को छूने की आवश्यकता नहीं है और किसी भी वर्ण का उपयोग तब तक किया जा सकता है जब तक कि कोई दो वर्ग एक ही वर्ण के न हों।)

  55
  55
  %%
  %%
@
  HH
  HH
  ((
  ((

समरूपता की रेखा वर्णों के बीच की सीमा भी हो सकती है, उदाहरणार्थ [2, 4]:

!!!!
!!!!  ++
!!!!  ++
!!!!

वर्गों के कुछ सेटों को सममित रूप से व्यवस्थित करना असंभव है, जैसे [1, 2, 3]:

AAA BB C
AAA BB         (these can't be vertically or horizontally symmetric => no output)
AAA

और याद रखें कि समग्र आकार सममित हो सकता है भले ही वर्ग की सीमाएं न हों। उदाहरण के लिए एक मान्य आउटपुट [2, 1, 1, 1, 1, 4]है:

AA----
AA----
BC----
DE----

इसी तरह, के लिए एक वैध उत्पादन [1, 1, 2, 3, 5]है:

इनपुट सूची में हमेशा 1 से 94 तत्व होंगे।
किसी भी उचित तरीके से इनपुट लें: स्टडिन, कमांड लाइन, टेक्स्ट फाइल, फंक्शन आरजी। यह आपकी आवश्यकताओं, जैसे {1, 2, 3, 4}या के अनुरूप करने के लिए थोड़ा स्वरूपित किया जा सकता है [1 2 3 4]।
स्टडआउट या इसी तरह का आउटपुट। प्रमुख / अनुगामी स्थानों या न्यूलाइन्स की कोई भी मात्रा तब तक ठीक है जब तक कि परिणामी आकृति में समरूपता की रेखा न हो।
समरूपता की एक विकर्ण रेखा की गिनती नहीं होती है (अन्यथा यह सुपर आसान होगा)। इसके अलावा, यह परावर्तक समरूपता होनी चाहिए, न कि घूर्णी या संक्रमणकालीन।
मुझे ईमानदारी से यकीन नहीं है कि यह काम कितना कम्प्यूटेशनल है। आप आंशिक उत्तर पोस्ट कर सकते हैं जो समस्या के कुछ सबसेट को हल करते हैं (विशेषकर यदि आप एक विशेष रूप से चतुर एल्गोरिदम को दिखाना चाहते हैं)। ये जीतने के योग्य नहीं हैं।
- उदाहरण के लिए, आप मान सकते हैं कि इनपुट में हमेशा कम से कम एक सममित व्यवस्था होती है (इसलिए सूचियाँ [1, 2, 3]कभी इनपुट नहीं होती हैं)।
- या, उदाहरण के लिए, आप केवल उन व्यवस्थाओं पर विचार कर सकते हैं जहां वर्ग की सीमाएं, साथ ही समग्र आकार, सममित हैं। इस मामले में, [1, 1, 2, 3, 5]कोई आउटपुट नहीं होगा।
- यदि आप पागल होना चाहते हैं, तो आप इस विचार को आयतों या पॉलीओमीनो तक बढ़ा सकते हैं ।

स्कोरिंग

आपका स्कोर बाइट्स में आपके कार्यक्रम का आकार है । सबसे कम स्कोर जीतता है। टाईब्रेकर पहले जवाब पोस्ट किया जाता है।

— केल्विन के शौक
स्रोत

हल करने के लिए बोनस अंक [2, 4, 6, 7, 8, 9, 11, 15, 16, 17, 18, 19, 24, 25, 27, 29, 33, 35, 37, 42, 50, 112], हालांकि सवाल बहुत अधिक स्वतंत्रता देता है क्योंकि शायद अन्य समाधान हैं।

— Sp3000

पायथन 2, 460 452 437 बाइट्स

exec"""def f(L):
 if[]==L:
  X{2}[map(" ".__lt__,q)for q in G]);Z{2}zip(*X));C=Z==Z[::-1]or X==X[::-1]
  if C:print"\\n".join(map("".join,G))
  return C
 x=L[-1];T=S-x+1;R=range(x)
 for n in range(T*T):
  i=n%T;j=n/T
  if all({1}=" "{0}):
{0}:{1}chr(32+len(L))
   r=f(L[:-1])
{0}:{1}" "
   if r:return r""".format("   for a,b in[(a,b)for a in R for b in R]","G[i+a][j+b]=","=filter(sum,")
L=input()
S=sum(L)
G=[S*[" "]for _ in[0]*S]
f(L)

केवल हल्के से अब के लिए गोल्फ, लेकिन यहाँ कुछ चीजें शुरू करने के लिए है। मैं exec10 और 12 लाइनों के लिए उपयोग करने की कोशिश की , लेकिन किसी कारण के लिए यह मुझे नहीं दिया।

सूची Lको STDIN के माध्यम से इनपुट करें , जैसे [2, 1, 2, 2, 2]। कार्यक्रम बस वर्गों को sum(L) x sum(L)ग्रिड में रखने की हर संभावना का प्रयास करता है ।

नमूना उत्पादन (कॉम्पैक्टनेस के लिए खाली लाइनें):

[2, 1, 2, 2, 2]

%%       
%%       
$$       
$$       
"        
##       
##       
!!       
!!      

[2, 4]

""""  
""""  
""""  
""""  
 !!   
 !!   

[2, 1, 1, 1]

$!!  
#!!  
 "   

[1, 1, 2, 3, 5]

%%%%%       
%%%%%       
%%%%%       
%%%%%       
%%%%%       
$$$##       
$$$##       
$$$"!       

[1, 4, 1, 8]

$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
$$$$$$$$      
# """" !      
  """"        
  """"        
  """"        

[8, 1, 4, 1]

$   !!!!!!!!  
    !!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
####!!!!!!!!  
    !!!!!!!!  
"   !!!!!!!!  

(The algorithm starts placing from the last square first, prioritising left then up)

थोड़ा कम भ्रमित संस्करण (452 बाइट्स):

def f(L):
 if[]==L:
  X=filter(sum,[map(" ".__lt__,q)for q in G]);Z=filter(sum,zip(*X));C=Z==Z[::-1]or X==X[::-1]
  if C:print"\n".join(map("".join,G))
  return C
 x=L[-1];T=S-x+1;R=range(x);V=[(a,b)for a in R for b in R]
 for n in range(T*T):
  i=n%T;j=n/T
  if all(G[i+a][j+b]<"!"for a,b in V):
   for a,b in V:G[i+a][j+b]=chr(32+len(L))
   r=f(L[:-1])
   for a,b in V:G[i+a][j+b]=" "
   if r:return r
L=input()
S=sum(L)
G=[S*[" "]for _ in[0]*S]
f(L)

— Sp3000
स्रोत

@ केल्विन के शौकीनों ने महसूस किया कि मैं खाली पंक्तियों और स्तंभों को छोड़ना भूल गया (जिसका अर्थ यह होगा कि विन्यास को बोर्ड के साथ भी सममित होना था )। [1, 1, 2, 3, 5]अब ठीक चलता है।

— Sp3000

आह। मुझे लगा कि पाशविक बल हमेशा के लिए ले रहा है।

— केल्विन के शौक

@ केल्विन के शौकीन यह बड़े बोर्डों के लिए करते हैं, लेकिन अतिरिक्त अड़चनें डालने से यह और खराब हो जाता है: P

— Sp3000

मुझे लगता है कि इंडेंटेशन ट्रिक का उपयोग करके आप कुछ चार्ट बचा सकते हैं ।

— केल्विन के शौक

वर्गों में समरूपता ढूँढना

टिप्पणियाँ

स्कोरिंग

पायथन 2, 460 452 437 बाइट्स