जॉली गैरमांडरिंग

Question

पृष्ठभूमि

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

एक नगर पालिका (2d सरणी) के एक आयताकार नक्शे को देखते हुए, आप अपनी पार्टी को सबसे अधिक प्रतिनिधित्व पाने में मदद करने के लिए जिला रेखा खींचेंगे। यही है, आप शांत होंगे। हर नगरपालिका में दो पक्ष होते हैं, 0और 1। नक्शा 0या तो 1उन पर या उनके साथ वर्गों में शामिल होगा । यहाँ एक उदाहरण का नक्शा है:

चुनौती

आप नक्शे को जिलों में समूहित करेंगे ताकि 1पार्टी को इनपुट द्वारा निर्दिष्ट जिलों की संख्या कम से कम मिले।

इनपुट

इनपुट में एक नक्शा, आकर्षित करने के लिए जिलों की संख्या और 1पार्टी को जीतने के लिए आवश्यक न्यूनतम जिलों की संख्या (न्यूनतम स्कोर) शामिल होगी।

उत्पादन

आउटपुट जिलों का नक्शा होगा। प्रत्येक जिले में वर्णमाला के बड़े अक्षरों में विशिष्ट रूप से शामिल किया जाएगा। हां, इसका मतलब यह है कि 26 से अधिक जिले नहीं होंगे।

यदि कोई संभावित आउटपुट नहीं है जहां इनपुट पार्टी पर्याप्त जिलों को जीतती है, तो:

1. प्रिंट "हमने कोशिश की ..."
2. पूरी तरह से त्रुटि क्योंकि पार्टी चुनाव परिणामों से अपूरणीय रूप से घायल हो गई थी
3. अथवा दोनों

नियम (बहुत महत्वपूर्ण भी)

1. सभी जिलों को सन्निहित होना चाहिए
2. जिलों में अन्य जिले नहीं हो सकते हैं
3. प्रत्येक जिले में कम से कम चार नोड्स होने चाहिए। इनपुट नियमों के अनुरूप होगा, जिसका अर्थ है कि number_of_districts * 4नक्शे में कम से कम नोड होंगे
4. प्रत्येक पार्टी का स्कोर उन जिलों की संख्या है, जिनमें उसका बहुमत है
5. यदि किसी जिले में समान संख्या में 0s और 1s है, तो न तो पार्टी को इससे कोई लाभ होता है
6. सामान्य नो-चीटिंग के नियम
7. यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

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

1. Input       1. Output       2. Input       2. Output     3. Input      3. Output
districts: 5   Image and map   districts: 3   Image below   districts: 3  fatal error
min wins: 3                    min wins: 3                  min wins: 3
map:                           map:                         map:
00000110000    AAAAAAAAAAA     101101                       101101
10000010000    AAAAAAAAAAA     100000                       100000
10010000011    AAAAAAAAAAA     011011                       011011
11001110000    BBBBBBBAAAA     111111                       100111
00111111000    BBBBBBBAAAA     
01111111000    CCCCCDDDAAA     
01111111001    CCCCCDDDAAA     
01000111100    EEEEEDDDDDD     
00000001000    EEEEEDDDDDD     

बेशक, आपका कार्यक्रम किसी भी वैध परीक्षण मामले के लिए काम करना चाहिए , न कि केवल इन लोगों के लिए।

Comments

@ अरनुलद, हाँ, वे केवल उदाहरण हैं। वास्तविक आउटपुट वर्णमाला के अक्षरों के साथ पहले परीक्षण के मामले में होना चाहिए। मैंने इसे दर्शाने के लिए टैग को बदल दिया।

— डैनियल

पहले परीक्षण मामले का एक सरल विभाजन कुछ इस तरह होगा । क्या वो सही है?

— अरनुलद

@Arnauld, हाँ, यह मान्य है।

— डैनियल

तो 3 उदाहरण के लिए, यदि हम इसे क्षैतिज पंक्तियों में विभाजित करते हैं, तो प्रत्येक 1 जिला लंबा है, तो 1s 3 से 1 हां जीतेंगे?

— माइकल डोरगन

यह मुझे बहुत कुछ याद दिलाता है कि डीएमजी से डीएस तक निंटेंडो हैंडहेल्ड पर चार आधारित ग्राफिक्स के लिए क्या करना था। आपको ग्राफिक्स को काटने के लिए विशिष्ट आकार दिए गए थे और उपयोग किए गए आकृतियों की संख्या को कम करना था क्योंकि आपके पास उपयोग में केवल स्प्राइट (आकृतियों) की एक हार्डवेयर परिभाषित संख्या हो सकती है। यह एक आसान समस्या नहीं थी।

— माइकल डोरगन

Answer 1

आर , 938 896 858 952 बाइट्स

function(N,M,m){U="We tried...
"
L=length
A=matrix
W=which
K=sum
S=sample
G=unique
H=function(s,p=s-1){Y=S(c(s-j,s+j,p*(p%%j>0),(s+1)*(s%%j>0)))
Y[Y>0&Y<=k]}
C=function(v,z=W(r==v))K(z%%j<2,z-j<0,(z+j)>k)
m=A(strsplit(m,"")[[1]],1)
i=W(m<0)[1]-1
m=((t(A(m,i+1))[,1:i]>0)-.5)*2
if((K(m)<M&(N-M)<1)|K(m>0)<(3*M))cat(U) else{j=max(1,nrow(m))
k=i*j;w=g=T
while(w<9&g){Z=R=N;Q=M;b=0
r=A(0,j,i)
while(b<9&g){s=W(r<1)
s=s[S(L(s))][1:min(L(s),R)]
r[s]=1:L(s);a=0
while(K(r<1)>0&a<(k^2)){a=a+1
s=S(W(r>0&r<=R),1);p=r[s]
Y=H(s)
Y=Y[r[Y]<1]
if(L(Y)){Y=Y[order(m[Y])]
if(K(m[r==p]>1))r[Y[1]]=p else r[Y[L(Y)]]=p}}
if(a<(k^2)){for(v in 1:R){if(K(m[r==v])>0){r[r==v]=max(k,max(r))+1
Q=Q-1;Z=Z-1}}
if(Q<1){g=F
for(v in 1:R)r[r==v]=max(k,max(r))+1
for(v in G(c(r)))g=g|(K(r==v)<4)|(L(G(r[H(W(r==v))]))+C(v))<3}}
b=b+1;r[r<=R]=0;R=Z}
w=w+1}
if(g)cat(U) else{u=G(c(r))
for(v in 1:L(u))r[r==u[v]]=v
cat(paste(apply(A(LETTERS[r],j,i),1,paste,collapse=""),collapse="
"))}}}

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

एक विशाल > 900 > 800 (nope!)> 900 बाइट्स घोल। कोड निम्नानुसार काम करता है। बता दें कि N चुनावी जिलों की संख्या है और M जिले की न्यूनतम संख्या है जहां 1 बहुमत पाने की इच्छा रखता है।

सबसे पहले, कोड बेतरतीब ढंग से एन जिलों को विभिन्न समूहों को सौंपता है। इसके बाद, यह यादृच्छिक रूप से उन्हें विस्तारित करता है, अर्थात एक जिले को यादृच्छिक रूप से चयनित समूह में जोड़ता है, यह सुनिश्चित करता है कि जिला उस समूह से संबंधित जिले के बगल में है। विस्तार प्रक्रिया में, यह एक जिले को 1 बहुमत के साथ वरीयता देता है, अगर जिला समूह अभी तक पूर्ण 1 बहुमत नहीं है; यदि समूह पहले से ही एक निश्चित 1 बहुमत है, तो यह 0 जिले को वरीयता देता है। यह तब तक जारी रहता है जब तक सभी जिलों को सौंपा नहीं गया है।

प्रत्येक समूह जहां 1 पार्टी के लिए बहुमत है, संग्रहीत किया जाता है, और उसके जिलों को बंद कर दिया जाता है। यदि 1 के बहुमत के साथ कम से कम एम समूह हैं, तो सब कुछ अच्छा है और हम परिणाम को प्रिंट कर सकते हैं हम यह जांच सकते हैं कि प्रत्येक समूह में कम से कम 4 जिले हैं या नहीं। यदि 4 जिलों की कटऑफ मिलती है, तो हम खुशी से परिणाम प्रिंट कर सकते हैं। अन्यथा, कोड उन जिलों को फिर से सौंपने की कोशिश करता है जो उपलब्ध नहीं हैं, जितने कि उपलब्ध नहीं हैं।

कोड कुछ समय (9 बार) की कोशिश करता है। यदि यह विफल हो जाता है, तो यह सब कुछ रीसेट करता है और फिर से शुरू होता है। ऐसा करने से पहले 9 बार ऐसा करने से पहले और "हमने कोशिश की ..." छपता है।

यदि कोड पहली बार में सफल नहीं होता है, तो कुछ बार फिर से प्रयास करें। मैंने पुनरावृत्तियों की संख्या को ऐसे ट्यून किया कि यह एक मिनट के भीतर टीआईओ में चल सके। हालाँकि, अगर कोई समाधान है, तो यह कोड (अंततः) उसे खोज सकता है। एल्गोरिथ्म का बेतरतीब हिस्सा एक गैर-शून्य संभावना देता है, अगर कोई समाधान है, तो वह इसे पा सकता है। परीक्षण की सीमित संख्या ही सफलता का एकमात्र सीमित कारक है।

EDIT: नियंत्रण में जोड़ा गया है कि कोई भी जिला समूह पूरी तरह से सिर्फ एक दूसरे से घिरा नहीं हो सकता, जब तक कि जिला समूह के पास दिए गए वर्ग के किनारे पर जिले न हों। मुझे लगता है कि मैं इसे पहली बार में याद किया।

Comments

क्या आप किसी भी नई सूची को हटा सकते हैं?

— NoOneIsHere

मैंने किया। मैंने एकल अक्षरों में लंबे समय तक फ़ंक्शन नाम भी दिए, और कुछ ==0को बदल दिया <1जब चर सख्ती से पूर्णांक और सकारात्मक था।

— NofP

यहाँ बहुत सारी चीजें हैं जो तुच्छ रूप से गोल्फ हो सकती हैं, लेकिन यह एक उत्तर में एक अच्छा पहला प्रयास है, इसलिए +1, और मैं अपने फोन पर नहीं होने पर मैं कुछ घंटों के संपादन का सुझाव दूंगा!

— ग्यूसेप

858 बाइट्स - "नियमित" गोल्फ, if...elseबयानों के साथ ब्रेसिज़ के उपयोग को साफ करना , स्वैप cकरना as.vector, "\n"शाब्दिक न्यूलाइन्स के साथ बदलना , और इस तथ्य का उपयोग >करना कि स्वचालित रूप से वर्णों की संख्याओं को चुपचाप और उनके कोडपाइंट्स की तुलना करना। शायद कुछ अन्य गोल्फ हैं जो मैंने किया था कि मुझे याद नहीं है लेकिन यह एक शुरुआत है। मुझे लगता है कि कुछ और चीजें हैं जिन्हें हम नीचे कर सकते हैं लेकिन मुझे 100% यकीन नहीं है कि मैं कोड को समझ सकता हूं ...

— Giuseppe

अच्छा है! मैंने प्रेरणा ली। आपके कोड की तुलना करने से मुझे एक बग भी मिला, जो कभी-कभी बहुत छोटे जिला समूहों (4 जिलों से कम) का नेतृत्व करता था। यह अब तय हो गया है।

— एनओएफपी