मैजिक बॉक्स की समस्या

Question

आपके पास आकार m * n का इनपुट सरणी है। सरणी में प्रत्येक कक्ष P या T के साथ आबाद है। सरणी पर आप कर सकते हैं केवल ऑपरेशन फ्लिप कॉलम है। जब आप किसी कॉलम को फ्लिप करते हैं, तो उस कॉलम स्विच की सभी कोशिकाओं में अक्षर (P T और वाइसवर्स बन जाता है)। यदि आपके पास समान अक्षर (जैसे PPPP) के साथ पंक्तियों की संख्या 'x' है तो आपको एक बिंदु मिलता है। एक एल्गोरिथ्म डिज़ाइन करें जो सरणी में लेता है और एक समाधान लौटाता है (जो कॉलम फ्लिप करने के लिए) जैसे कि परिणामस्वरूप सरणी में अधिकतम अंक संभव हैं।

नोट: यदि उच्चतम स्कोर प्राप्त करने वाले कई समाधान हैं, तो सबसे कम संख्या में फ़्लिप चुनें। उदाहरण:

इनपुट एरियर:

PPTPP
PPTPP
PPTTP
PPPTT
PPPTT

आउटपुट:

3

स्पष्टीकरण:
एक ऐसा समाधान जो सबसे अधिक अंक देता है: फ्लिप कॉलम नं। 3
फिर मूल सरणी होगी:

PPPPP // 1 point
PPPPP // 1 point
PPPTP
PPTTT
PPTTT

//Total: 2 points

ध्यान दें कि दो में से एक अंक प्राप्त करने के लिए कॉलम 4 और 5 को भी फ्लिप कर सकता है, लेकिन इसके लिए अतिरिक्त फ्लिप की आवश्यकता है।

आप दो आयामी सरणी का प्रतिनिधित्व करने के लिए किसी भी सुविधाजनक इनपुट प्रारूप का उपयोग कर सकते हैं, और आप किसी भी दो अलग, लेकिन निश्चित, मानों का प्रतिनिधित्व करने के लिए Pऔर हो सकता है T।

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

Comments

PPCG में आपका स्वागत है। यह एक बड़ी चुनौती है, लेकिन इसे विषय पर जीतने की कसौटी चाहिए।

— य्प्निपन

क्या मैं इनपुट प्रारूप को नियंत्रित कर सकता हूं? क्या मैं कह सकता हूं कि P गलत है और T सत्य है? यदि नहीं, तो इनपुट प्रारूप क्या है?

— गर्वित हेकेलर

ज़रूर, इनपुट प्रारूप कोई फर्क नहीं पड़ता। मान लें कि आपके पास चार दिशाओं या पुलों या बुलियन या आप जो भी प्रकार चुनते हैं, उसके दो दिशात्मक सरणी हैं।

— bruhhhhh

आपको यह तय करने के लिए एक जीत की कसौटी की जरूरत है कि कौन सा मान्य उत्तर सबसे अच्छा है। मान्य उत्तर के अनुसार इनपुट ग्रिड के लिए अधिकतम अंक देना होगा (BTW आपको यह बताना चाहिए), उचित समय में 32 कॉलम ग्रिड को ब्रूटफोर्स करना संभव होना चाहिए। इसलिए मेरा सुझाव है कि आप ia codegolf (सबसे छोटी कोड जीत) बनाते हैं

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

मैंने पीटर के पहले सुझाव में काम किया है। यदि आप इसे पसंद नहीं करते हैं, तो शब्दों को बदलने के लिए स्वतंत्र महसूस करें।

— मार्टिन एंडर

Answer 1

एपीएल, ३,

{x/1+⍳⍴x←y[↑⍋(+/∘.≠⍨2⊥⍉y),¨+/y←⍵⍪~⍵]}

उदाहरण:

{x/1+⍳⍴x←y[↑⍋(+/∘.≠⍨2⊥⍉y),¨+/y←⍵⍪~⍵]} 5 5⍴0 0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 1

यहां परीक्षण किया गया।

Answer 2

अजगर , २,

f@eo+/QN/Qm!dN_osZ^U2lhQTUhQ

एक नेस्टेड सूची के रूप में इनपुट लेता है, जैसे

[[0,0,1,0,0],[0,0,1,0,0],[0,0,1,1,0],[0,0,0,1,1],[0,0,0,1,1]]

आउटपुट 0-अनुक्रमित, उदाहरण के लिए देता है

[2]

^U2lhQ: सही लंबाई के 0s और 1s के सभी संभावित सूची उत्पन्न करता है।

_osZ: इन सूचियों को अधिकतम 1s से कम से कम करने के लिए आदेश।

+/QN/Qm!dN: गिनता है कि इनपुट में प्रत्येक सूची ( N) और उसके व्युत्क्रम, 0s और 1s स्वैप ( m!dN) कितनी बार होती हैं। पूर्व सभी शून्य छोड़ने वाले फ्लिप की एक श्रृंखला से मेल खाती है, बाद वाले सभी को छोड़ने के लिए।

eo: उपरोक्त कुंजी द्वारा सूची का आदेश देता है, और इसका अंतिम तत्व लेता है, जो सबसे मिलान कॉलम के साथ परिणाम देगा, और उनमें से सबसे कम वाले के साथ।

f@ ... TUhQ: 1s और 0s की इस सूची को फ़्लिप किए जाने वाले सूचकांकों की सूची में परिवर्तित करता है।

1-अनुक्रमण के लिए, बदलने के dएक करने के लिए kहै, तो डाल mhdशुरुआत में।

Answer 3

CJam, 53 51 बाइट्स

l~z:X,,La\{1$f++}/{,}${X\{_X=:!t}/z{_&,(},,}$0=:)S*

यह STDIN से 0s और 1s के द्वि-आयामी सरणी को पढ़ता है। उदाहरण के लिए प्रश्न में उदाहरण होगा

[[0 0 1 0 0] [0 0 1 0 0] [0 0 1 1 0] [0 0 0 1 1] [0 0 0 1 1]]

इसका परीक्षण यहां करें।

यह पहली बार स्तंभों के सभी संभव सबसेट को प्राप्त करता है, बढ़ती लंबाई के क्रम में, फिर प्रत्येक सबसेट के लिए फ़्लिप करता है और उन्हें सॉर्ट करता है कि कितनी पंक्तियों में अभी भी 0s और 1s दोनों हैं। अंत में, हम पहले ऐसे सबसेट को वापस करते हैं। यह छंटाई के स्थिर होने पर निर्भर करता है, जैसे कि बढ़ती लंबाई का प्रारंभिक क्रम टाई-ब्रेकर की देखभाल करता है।

Answer 4

हास्केल, 98

g s=snd$maximum[((sum[1|o<-s,o==r||o==map(1-)r],-sum r),[i|(i,1)<-zip[1..]r])|r<-s++map(map(1-))s]

इनपुट प्रारूप, किलों की सूची की एक सूची है। आप परीक्षण के लिए एक स्ट्रिंग संस्करण का उपयोग कर सकते हैं:

gg = g . map (map (\c -> case c of 'T' -> 0 ; _ -> 1) ) . lines

_{अरे नहीं रिक्त स्थान! यह दुखदायक है!}

यह पंक्तियों पर पुनरावृति और अंकों की संख्या की गणना करके काम करता है, अगर हम स्तंभों को इस तरह से फ़्लिप करते हैं, तो यह पंक्ति हमें एक बिंदु देती है।

पहली बात यह है कि पंक्ति को सभी में फ़्लिप करना True या सभी केFalse कोई मायने नहीं रखता है, क्योंकि ग्रिड बिल्कुल एक-दूसरे के व्युत्क्रम होंगे और इस प्रकार सटीक एक ही स्कोर होगा।

जिस तरह से हम गणना की गणना करते हैं जब किसी दिए गए पंक्ति लाभ एक बिंदु ऐसा होता है: हम फिर से पंक्तियों पर पुनरावृति करते हैं, और प्रत्येक पंक्ति को उन बिंदुओं को जोड़ते हैं, जो इस तथ्य का उपयोग करते हुए करते हैं कि वे पंक्तियों के समान या सटीक व्युत्क्रम हैं।

उदाहरण के लिए, यदि हम जिस पंक्ति को फ़्लिप कर रहे हैं वह है TPPTPऔर वर्तमान पंक्ति जिसे हम अधिक पुनरावृत्त कर रहे हैं, PTTPTया TPPTPफिर पंक्ति हमें एक बिंदु प्राप्त करती है, लेकिन जब यह कोई अन्य पंक्ति होती है, तो यह हमें कोई भी बिंदु नहीं देती है।

Comments

@ मार्टिनबटनर हां, मैं इसे शीघ्र ही (उम्मीद से) ठीक कर

— दूंगा

Answer 5

सीजेएम, 37

q~_{:!}%+:T{T1$a-,\0-+}$0={U):U*}%0-`

इनपुट प्रारूप:

[[0 0 1 0 0] [0 0 1 0 0] [0 0 1 1 0] [0 0 0 1 1] [0 0 0 1 1]]

Answer 6

गणितज्ञ - 76६

{
{P, P, T, P, P},
{P, P, T, P, P},
{P, P, T, T, P},
{P, P, P, T, T},
{P, P, P, T, T}
}/.{P -> 1, T -> 0};
First@MaximalBy[
  Subsets@Range@Length[%],
  MapAt[1-#&,%,{All,#}]~Count~{1..}&
]

Comments

जब तक निर्दिष्ट न हो तो स्निपेट मान्य प्रस्तुतियाँ नहीं हैं। आपको इनपुट लेने के लिए फंक्शन या फुल प्रोग्राम लिखना होगा।

— मार्टिन एंडर

Answer 7

अजगर 2, 234

from itertools import *
A=input()
n=len(A[0])
R=range(n)
S=(0,)
for p in[q for i in R[:-1] for q in combinations(R,i)]:
    s=[sum([(l[q]+(q in p))%2 for q in R])for l in A]
    m=s.count(n)+s.count(0)
    if m>S[0]:S=(m,p)
print S[1]

इनपुट सूची की एक सूची है:

[[0,0,1,0,0],[0,0,1,0,0],[0,0,1,1,0],[0,0,0,1,1],[0,0,0,1,1]]

आउटपुट 0 से पायथन इंडेक्सिंग का उपयोग करके फ़्लिप का एक समूह है:

(2,)

यदि आउटपुट को 1 से अनुक्रमित किया जाना चाहिए, तो कोड 272 वर्ण है जिसमें 0 फ़्लिप नहीं है:

print 0 if len(S[1])==0 else [p+1 for p in S[1]]