चार रंग प्रमेय

13

चार रंग की प्रमेय स्टेट्स कि कोई और अधिक से अधिक चार रंगों मानचित्र के क्षेत्रों रंग करने के लिए आवश्यक हैं।

चुनौती

राज्य की सीमाओं की एक सूची को देखते हुए प्रत्येक राज्य की आईडी को एक रंग प्रदान करें ताकि किसी भी दो आसन्न राज्यों में एक ही रंग न हो। आउटपुट को सीएसएस स्टाइलशीट होना चाहिए जो राज्य के 2 अक्षर आईडी कोड को रंग प्रदान करता है। यहां एक एसवीजी मानचित्र है जिसे स्टाइलशीट पर लागू किया जा सकता है। http://upload.wikimedia.org/wikipedia/commons/3/32/Blank_US_Map.svg

नियम

  • सबसे छोटा कोड जीतता है
  • किसी भी राज्य की सीमा सूची का उपयोग किया जा सकता है
  • केवल 4 रंगों का उपयोग किया जा सकता है।
  • राज्य सूची को हार्डकोड किया जा सकता है

सलाह: fill:रंग बदलने के लिए CSS संपत्ति का उपयोग करें , उदाहरण के लिए#AL{fill:green}

यहाँ राज्य सीमाओं की एक सूची दी गई है

AL-FL
AL-GA
AL-MS
AL-TN
AR-LA
AR-MO
AR-MS
AR-OK
AR-TN
AR-TX
AZ-CA
AZ-CO
AZ-NM
AZ-NV
AZ-UT
CA-NV
CA-OR
CO-KS
CO-NE
CO-NM
CO-OK
CO-UT
CO-WY
CT-MA
CT-NY
CT-RI
DC-MD
DC-VA
DE-MD
DE-NJ
DE-PA
FL-GA
GA-NC
GA-SC
GA-TN
IA-MN
IA-MO
IA-NE
IA-SD
IA-WI
ID-MT
ID-NV
ID-OR
ID-UT
ID-WA
ID-WY
IL-IA
IL-IN
IL-KY
IL-MO
IL-WI
IN-KY
IN-MI
IN-OH
KS-MO
KS-NE
KS-OK
KY-MO
KY-OH
KY-TN
KY-VA
KY-WV
LA-MS
LA-TX
MA-NH
MA-NY
MA-RI
MA-VT
MD-PA
MD-VA
MD-WV
ME-NH
MI-OH
MI-WI
MN-ND
MN-SD
MN-WI
MO-NE
MO-OK
MO-TN
MS-TN
MT-ND
MT-SD
MT-WY
NC-SC
NC-TN
NC-VA
ND-SD
NE-SD
NE-WY
NH-VT
NJ-NY
NJ-PA
NM-OK
NM-TX
NM-UT
NV-OR
NV-UT
NY-PA
NY-VT
OH-PA
OH-WV
OK-TX
OR-WA
PA-WV
SD-WY
TN-VA
UT-WY
VA-WV
code-golf  graph-theory 
— काइल के
स्रोत
क्या हम राज्य की सीमाओं की सूची को हार्डकोड कर सकते हैं?
— निंजाबियरमॉन्की
@ एचएसएल हाँ, राज्य सीमाओं को हार्डकोड करना ठीक है।
— काइल की
@steveverrill यदि आप रंग बदलने की बेहतर विधि के बारे में सोच सकते हैं जो बहुत अच्छा होगा। मैंने एक उदाहरण जोड़ा जिसमें सीएसएस का उपयोग करना दिखाया गया है।
— काइल k
क्या यह सबूत फोर कलर थ्योरम को खुद ही तैयार करने की आवश्यकता नहीं होगी? चूंकि आपको हर संभव मामले को संभालना है?
— बैरीकेटर
1
क्या यह प्रमेय गलत साबित नहीं होगा यदि किसी राज्य की सीमा 3 अन्य राज्यों से अधिक छू रही हो?
— ऑप्टिमाइज़र

जवाबों:

4

पायथन, 320 वर्ण

import sys,random
S=[]
E={}
for x in sys.stdin:a=x[:2];b=x[3:5];S+=[a,b];E[a,b]=E[b,a]=1
C={0:0}
while any(1>C[s]for s in C):
 C={s:0for s in S};random.shuffle(S)
 for s in S:
    A=set([1,2,3,4])-set(C[y]for x,y in E if x==s)
    if A:C[s]=random.choice(list(A))
for s in C:print'#%s{fill:%s}'%(s,' bglrloieulmdede'[C[s]::4])

एक यादृच्छिक एल्गोरिथ्म का उपयोग करता है। रंगों को यादृच्छिक क्रम में राज्यों को असाइन करें एक रंग का चयन करके जो आसन्न राज्यों के साथ संघर्ष नहीं करता है जो पहले से ही रंगीन हैं। दिए गए इनपुट पर सेकंड के दसवें हिस्से में काम करने लगता है।

उदाहरण आउटपुट:

$ 4color.py < stategraph
#WA{fill:red}
#DE{fill:gold}
#DC{fill:blue}
#WI{fill:blue}
#WV{fill:red}
#FL{fill:lime}
#WY{fill:gold}
#NH{fill:red}
#NJ{fill:lime}
#NM{fill:gold}
#TX{fill:red}
#LA{fill:blue}
#NC{fill:blue}
#ND{fill:gold}
#NE{fill:blue}
#TN{fill:red}
#NY{fill:gold}
#PA{fill:blue}
#RI{fill:gold}
#NV{fill:red}
#VA{fill:gold}
#CO{fill:red}
#CA{fill:gold}
#AL{fill:blue}
#AR{fill:gold}
#VT{fill:lime}
#IL{fill:red}
#GA{fill:gold}
#IN{fill:lime}
#IA{fill:gold}
#OK{fill:blue}
#AZ{fill:lime}
#ID{fill:lime}
#CT{fill:red}
#ME{fill:blue}
#MD{fill:lime}
#MA{fill:blue}
#OH{fill:gold}
#UT{fill:blue}
#MO{fill:lime}
#MN{fill:red}
#MI{fill:red}
#KS{fill:gold}
#MT{fill:blue}
#MS{fill:lime}
#SC{fill:red}
#KY{fill:blue}
#OR{fill:blue}
#SD{fill:lime}

उदाहरण svg में चिपकाया गया ।

— कीथ रान्डेल
स्रोत
tanजाहिरा तौर पर एक समर्थित एसवीजी रंग है। शर्म की बात है कि आप केवल ::4चाल के साथ एक तीन-रंग प्राप्त कर सकते हैं ।
— पीटर टेलर
1
@PeterTaylor: तन भयानक लगता है। इसके बजाय सोने का उपयोग करने के लिए पूरी तरह से 1 पात्र।
— कीथ रान्डेल
क्या आप गारंटी दे सकते हैं कि यह एल्गोरिथ्म हमेशा सीमित समय में समाप्त होगा, बशर्ते 4-रंग समाधान मौजूद हो? :)
— बैरीकेटर
@barrycarter: यह प्रायिकता के साथ समाप्त होने की गारंटी है। हालांकि, मानचित्र के आकार में समय की कमी हो सकती है, हालांकि।
— कीथ रान्डेल
@KeithRandall मैं चिढ़ने की तरह था, लेकिन ... यदि आप दोहराते हैं, तो सही रंग खोजने के लिए 4 ^ (n-1) कदम उठा सकते हैं (n-1 क्योंकि रंगों की समरूपता के कारण)। यदि आप दोहराव की जांच नहीं करते हैं, तो इसमें अभी भी समय लग सकता है। मैं सिर्फ समाधान को असंतोषजनक पाया, क्योंकि यह "वास्तव में" "उचित" एल्गोरिथ्म नहीं है।
— बैरीकेटर
3

प्रोलॉग, 309 307 283 वर्ण

:-initialization m.
a-X:-assert(X);retract(X),1=0.
r:-maplist(get_char,[A,B,E,C,D,F]),(E=F;X=[A,B],Y=[C,D],a-X/Y,a-Y/X,(s/X;a-s/X),(s/Y;a-s/Y),r).
s+[]:- \+ (X*C,writef('#%s{fill:#%w}',[X,C]),1=0).
s+[X|T]:-member(C,[911,191,119,991]),a-X*C,\+ (X/Y,Y*C),s+T.
m:-r,bagof(X,s/X,L),s+L.

एल्गोरिथ्म मानचित्र को भरने के लिए बैकट्रैकिंग / गहराई-पहली खोज का उपयोग करता है।

थोड़ा अधिक पठनीय:

:- initialization(main).

% Found on http://awarth.blogspot.de/2008/08/asserts-and-retracts-with-automatic.html
assert2(X) :- assert(X).
assert2(X) :- retract(X), fail.

% Reads all states into clauses "state-State",
% and all connections into "State-Neighbor" and "Neighbor-State".
read_states :-
    % Read a line "AB-CD\n"
    maplist(get_char, [A,B,E,C,D,F]),
    (   A = F;
        State = [A, B],
        Neighbor = [C, D],
        % Memorize the connection between State and Neighbor in both directions.
        assert(State/Neighbor),
        assert(Neighbor/State),
        % Memorize State and Neighbor for the list of states.
        (state/State; assert(state/State)),
        (state/Neighbor; assert(state/Neighbor)),
        % Continue for all lines.
        read_states
    ).

% Print out all colors.
solve([]) :-
    once((
        State*Color,
        writef('#%s{fill:%w}', [State, Color]),
        fail
    )); !.

% Use depth-first search to color the map.
solve([State|FurtherStates]) :-
    member(Color, ['#911', '#191', '#119', '#991']),
    assert2(State*Color),
    \+ (State/Neighbor, Neighbor*Color),
    solve(FurtherStates).

main :-
    read_states,
    bagof(State, state/State, States),
    solve(States).

मंगलाचरण:

cat borders.txt | swipl -q ./fourcolors.pl

परिणाम (newlines की जरूरत नहीं है):

#AL{fill:#911}#FL{fill:#191}#GA{fill:#119}#MS{fill:#191}#TN{fill:#991}#AR{fill:#911}#LA{fill:#119}#MO{fill:#191}#OK{fill:#119}#TX{fill:#191}#AZ{fill:#911}#CA{fill:#191}#CO{fill:#191}#NM{fill:#991}#NV{fill:#991}#UT{fill:#119}#OR{fill:#911}#KS{fill:#911}#NE{fill:#119}#WY{fill:#911}#CT{fill:#911}#MA{fill:#191}#NY{fill:#119}#RI{fill:#119}#DC{fill:#911}#MD{fill:#191}#VA{fill:#119}#DE{fill:#119}#NJ{fill:#191}#PA{fill:#911}#NC{fill:#911}#SC{fill:#191}#IA{fill:#911}#MN{fill:#191}#SD{fill:#991}#WI{fill:#119}#ID{fill:#191}#MT{fill:#119}#WA{fill:#119}#IL{fill:#991}#IN{fill:#191}#KY{fill:#911}#MI{fill:#911}#OH{fill:#119}#WV{fill:#991}#NH{fill:#911}#VT{fill:#991}#ME{fill:#191}#ND{fill:#911}

एक SVG में पास: http://jsbin.com/toniseqaqi/

— का - एसई बुराई है
स्रोत
1

जावास्क्रिप्ट (ईएस 6) 269 279

Backtracking के साथ पुनरावर्ती खोज। ~ 80 बाइट राज्य सूची पार्सिंग के लिए खर्च की गई।

 F=l=>{
   S=(a,b)=>S[a]=(S[a]||[]).concat(b),
   l.replace(/(..)-(..)/g,(_,a,b)=>S(a,b)+S(b,a)),
   k=Object.keys(S),
   R=(p,c=k[p])=>!c||['blue','gold','red','tan'].some(i=>!c.some(t=>S[t].c==i)&&(c.c=i,R(p+1)||(c.c='')),c=S[c]),
   R(0),
   k.map(k=>console.log('#'+k+'{fill:'+S[k].c+'}'))
 }

Ungolfed

F=l=>{
  var states = {}; // hash table with adiacent list for each state
  S=(a,b)=>states[a]=(states[a]||[]).concat(b);
  l.replace(/(..)-(..)/g,(_,a,b)=>S(a,b)+S(b,a)); // build the hash table from the param list 

  keys = Object.keys(states); // get the list of hashtable keys as an array (the 49 states id)
  Scan=(p)=> // Recursive scan function
  {
    var sId = keys[p]; // in sid the current state id, or undefined if passed last key
    if (!sId) return true; // end of keys, recursive search is finished 
    var sInfo = states[sId]; // in sInfo the aarray of adiacent states id + the color property

    return ['blue','gold','red','tan'].some( (color) => // check the four avaialabe colors
      {
        var colorInUse = sInfo.some( (t) => states[t].color == color); // true if an adiacent state already has the currnet color
        if (!colorInUse) // if the color is usable
        {
          sInfo.color = color; // assign the current color to the current state
          var ok = Scan(p+1); // proceed with the recursive scan on the next state
          if (!ok) // if recursive scan failed, backtrack
          {
            sInfo.color = ''; // remove the assigned color for the current state
          }
          return ok;
        }
      }
    )
  },
  Scan(0), // start scan 
  keys.forEach( (sId) => console.log('#'+sId+'{fill:'+states[sId].color+'}')) // output color list
}

FireFox / FireBug कंसोल में टेस्ट करें

list = "AL-FL AL-GA AL-MS AL-TN AR-LA AR-MO AR-MS AR-OK AR-TN AR-TX AZ-CA AZ-CO AZ-NM "+
"AZ-NV AZ-UT CA-NV CA-OR CO-KS CO-NE CO-NM CO-OK CO-UT CO-WY CT-MA CT-NY CT-RI "+
"DC-MD DC-VA DE-MD DE-NJ DE-PA FL-GA GA-NC GA-SC GA-TN IA-MN IA-MO IA-NE IA-SD "+
"IA-WI ID-MT ID-NV ID-OR ID-UT ID-WA ID-WY IL-IA IL-IN IL-KY IL-MO IL-WI IN-KY "+
"IN-MI IN-OH KS-MO KS-NE KS-OK KY-MO KY-OH KY-TN KY-VA KY-WV LA-MS LA-TX MA-NH "+
"MA-NY MA-RI MA-VT MD-PA MD-VA MD-WV ME-NH MI-OH MI-WI MN-ND MN-SD MN-WI MO-NE "+
"MO-OK MO-TN MS-TN MT-ND MT-SD MT-WY NC-SC NC-TN NC-VA ND-SD NE-SD NE-WY NH-VT "+
"NJ-NY NJ-PA NM-OK NM-TX NM-UT NV-OR NV-UT NY-PA NY-VT OH-PA OH-WV OK-TX OR-WA "+
"PA-WV SD-WY TN-VA UT-WY VA-WV";
F(list);

उत्पादन

#AL{fill:blue}
#FL{fill:gold}
#GA{fill:red}
#MS{fill:gold}
#TN{fill:tan}
#AR{fill:blue}
#LA{fill:red}
#MO{fill:gold}
#OK{fill:red}
#TX{fill:gold}
#AZ{fill:blue}
#CA{fill:gold}
#CO{fill:gold}
#NM{fill:tan}
#NV{fill:tan}
#UT{fill:red}
#OR{fill:blue}
#KS{fill:blue}
#NE{fill:red}
#WY{fill:blue}
#CT{fill:blue}
#MA{fill:gold}
#NY{fill:red}
#RI{fill:red}
#DC{fill:blue}
#MD{fill:gold}
#VA{fill:red}
#DE{fill:red}
#NJ{fill:gold}
#PA{fill:blue}
#NC{fill:blue}
#SC{fill:gold}
#IA{fill:blue}
#MN{fill:gold}
#SD{fill:tan}
#WI{fill:red}
#ID{fill:gold}
#MT{fill:red}
#WA{fill:red}
#IL{fill:tan}
#IN{fill:gold}
#KY{fill:blue}
#MI{fill:blue}
#OH{fill:red}
#WV{fill:tan}
#NH{fill:blue}
#VT{fill:tan}
#ME{fill:gold}
#ND{fill:blue}
— edc65
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.