वह कीटाणु कहाँ जाएगा?

Question

परिचय

आप एक जीवविज्ञानी हैं जो जीवाणुओं के आंदोलन के पैटर्न का अध्ययन कर रहे हैं। आपकी शोध टीम ने उन्हें पेट्री डिश में एक गुच्छा दिया है, और आप उनकी गतिविधि रिकॉर्ड कर रहे हैं। दुर्भाग्य से, आप गंभीरता से कम कर रहे हैं, और एक वीडियो कैमरा बर्दाश्त नहीं कर सकता, इसलिए आप नियमित अंतराल पर पकवान की एक तस्वीर लेते हैं। आपका कार्य एक ऐसा कार्यक्रम बनाना है जो इन चित्रों से कीटाणुओं की चाल का पता लगाता है।

इनपुट

आपके इनपुट किसी भी उचित प्रारूप में वर्णों के दो 2 डी सरणियों हैं, पेट्री डिश के लगातार चित्रों का प्रतिनिधित्व करते हैं। दोनों सरणियों में, चरित्र .खाली स्थान का प्रतिनिधित्व करता है, और Oएक रोगाणु का प्रतिनिधित्व करता है (यदि आप चाहें तो किसी भी दो अलग-अलग वर्ण चुन सकते हैं)। इसके अलावा, "के बाद" सरणी चार कार्डिनल दिशाओं में से एक में कुछ कीटाणुओं को एक कदम बढ़ाकर "पहले" सरणी से प्राप्त की जाती है; विशेष रूप से, सरणियों का आकार समान होता है। रोगाणु एक साथ चलते हैं, इसलिए उनमें से एक ऐसे स्थान पर जा सकता है जिसमें पहले से ही एक और कीटाणु मौजूद हो, अगर वह रास्ते से हट जाए। यह गारंटी है कि "पहले" सरणी की सीमाओं में केवल खाली स्थान होते हैं, और कम से कम एक रोगाणु होता है। इस प्रकार, निम्नलिखित इनपुट की एक वैध जोड़ी है:

Before  After
......  ......
.O..O.  ....O.
.OO.O.  .OO.O.
......  ..O...

उत्पादन

आपका आउटपुट इनपुट के समान प्रारूप में वर्णों का एकल 2D सरणी है। यह >^<vआंदोलन की दिशा के आधार पर उन कीटाणुओं को प्रतिस्थापित करने से पहले "से" सरणी से प्राप्त होता है, जो एक के साथ चले गए हैं (आप यहां किसी भी 4 अलग-अलग वर्णों का उपयोग भी कर सकते हैं)। कई संभावित आउटपुट हो सकते हैं, लेकिन आप उनमें से केवल एक ही देंगे। उपरोक्त उदाहरण में, एक संभव सही आउटपुट है

......
.v..O.
.>v.O.
......

आउटपुट में अनावश्यक आंदोलन की अनुमति है और रोगाणु स्थानों को स्वैप कर सकते हैं, इसलिए निम्नलिखित भी मान्य हैं:

......
.v..v.
.>v.^.
......

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

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

मैं अपेक्षाकृत कुशल एल्गोरिदम में दिलचस्पी रखता हूं, लेकिन मैं पूरी तरह से मजबूर करने पर प्रतिबंध नहीं लगाना चाहता। इस कारण से, एक आधुनिक सीपीयू पर 10 मिनट के भीतर अंतिम परीक्षण मामले को हल करने के लिए -75% का बोनस है (मैं अधिकांश समाधानों का परीक्षण करने में असमर्थ हूं, इसलिए मैं सिर्फ यहां आप पर भरोसा करूंगा)। डिस्क्लेमर: मुझे पता है कि एक तेज़ एल्गोरिथ्म मौजूद है ("असंतुष्ट पथ समस्या के लिए खोज"), लेकिन मैंने इसे स्वयं लागू नहीं किया है।

अतिरिक्त परीक्षण के मामले

Before
......
.O..O.
..OO..
......
After
......
..O...
...OO.
..O...
Possible output
......
.>..v.
..vO..
......

Before
.......
.OOOOO.
.O..OO.
.OO..O.
.OOOOO.
.......
After
.......
..OOOOO
.O...O.
.O...O.
.OOOOOO
....O..
Possible output
.......
.>>>>>.
.O..>v.
.Ov..v.
.O>>v>.
.......

Before
..........
.OOO..OOO.
.OOOOOOOO.
.OOO..OOO.
..........
After
..O.......
.OOO..O.O.
..OOOOOOOO
.O.O..OOO.
.......O..
Possible output
..........
.>^O..O>v.
.^O>>>vO>.
.O>^..>vO.
..........

Before
............
.OO..OOOOOO.
.OO......OO.
...OOOOOO...
.O.OOOOOO.O.
...OOOOOO...
.OOOOOOOOOO.
............
After
..........O.
.OO..OOOOO..
.O...O...O..
.O.OOOOOOO..
.O.OOOOOO..O
...OO..OO...
....OOOOOOOO
.OOO........
Possible output
............
.OO..v<<<<^.
.v<......^<.
...OOO>>>...
.O.OOO^OO.>.
...OOv^OO...
.vvvO>>>>>>.
............

Before
................
.OOOOOO.OOOOOOO.
..OO..OOOOOOOOO.
.OOO..OOOO..OOO.
..OOOOOOOO..OOO.
.OOOOOOOOOOOOOO.
................
After
................
..OOOOO.OOOOOOOO
..OO..OOOOOOOOO.
..OO..OOOO..OOOO
..OOOOOOOO..OOO.
..OOOOOOOOOOOOOO
................
Possible output
................
.>>>>>v.>>>>>>>.
..OO..>>^>>>>>v.
.>>v..OOO^..OO>.
..O>>>>>>^..OOO.
.>>>>>>>>>>>>>>.
................

Before
..............................
.OOO.O.O.....O.....O.O.O..O...
..OOO.O...O..OO..O..O.O.......
.....O......O..O.....O....O...
.O.OOOOO......O...O..O....O...
.OO..O..OO.O..OO..O..O....O...
..O.O.O......OO.OO..O..OO.....
..O....O..O.OO...OOO.OOO...O..
.....O..OO......O..O...OO.OO..
........O..O........OO.O.O....
..O.....OO.....OO.OO.......O..
.O.....O.O..OO.OO....O......O.
..O..OOOO..O....OO..........O.
.O..O...O.O....O..O....O...OO.
....O...OO..O.......O.O..OO...
........O.O....O.O....O.......
.OO.......O.OO..O.......O..O..
....O....O.O.O...OOO..O.O.OO..
.OO..OO...O.O.O.O.O...OO...O..
..............................
After
..............................
.OOOOO.......OO.....O..O......
...OO..O...O...O....OO....O...
....O.O......O..OO...OO...O...
.OO.OOOO......OO..O..O........
O.O.OO..O..O..O..OO...O...OO..
.OO.....O....OO.O..O.OO.O.....
......O.....O.....OOO.OO...O..
....O..OOOO..O..O..O.O.O.OO...
..O......O.O........O...O.O...
.O.....OOO.....OO.OO...O...O..
.......OOO..O.O.O...........O.
.O...O.....O...OOOO..O.O....O.
.O..O.O..O.....O......O....OO.
....O..O..O.O......O.....O....
........OOO....O......O..O....
.OO......O..OO..OOO.....O..O..
..O.O....OO..O...OO...O...OO..
.O..OO....O..O...O.O.O.OO.....
..............O............O..
Possible output
..............................
.OOO.O.v.....>.....>.v.O..v...
..>>^.v...>..^>..v..O.v.......
.....<......>..>.....O....O...
.O.<O><O......O...O..O....v...
.<O..O..v<.O..O^..O..>....>...
..<.^.v......OO.O^..>..<O.....
..^....v..v.Ov...>>^.<OO...O..
.....<..OO......O..O...Ov.v<..
........>..O........O^.v.^....
..^.....Ov.....OO.OO.......O..
.^.....^.^..O>.vO....v......O.
..<..Ov^^..O....><..........O.
.O..O...>.v....O..^....^...OO.
....O...<v..O.......<.^..v<...
........O.O....O.v....O.......
.OO.......<.Ov..O.......O..O..
....O....O.<.^...O^v..O.v.OO..
.O^..<<...O.>.v.>.^...<O...v..
..............................

Comments

बस सुनिश्चित करने के लिए, रोगाणु केवल एक या शून्य कोशिकाओं द्वारा ही आगे बढ़ सकते हैं, है ना?

— डोमिनोज

@JacqueGoupil हाँ, यह सही है। प्रत्येक >^<vसंबंधित दिशा में ठीक एक कदम के आंदोलन से मेल खाती है।

— जर्बद

मैंने इसे अभी तक हल करने की कोशिश नहीं की, लेकिन यहां अधिक परीक्षण मामलों का निर्माण करने का एक उपकरण है :) jsfiddle.net/xd2xns64/embedded/result

— डोमिनोज़

ओह, सावधान, एक मौका है कि स्क्रिप्ट हमेशा के लिए लूप करेगी अगर यह एक किनारे के खिलाफ सभी कोशिकाओं को स्थानांतरित करने की कोशिश करता है लेकिन फिर किनारे की कोशिकाओं को कहीं नहीं जाना है।

— डोमिनोज

Answer 1

ऑक्टेव, 494 496 बाइट्स - 372 बाइट बोनस = 124 बाइट्स

function o=G(b,a)
y='.O<^v>';s=(b>46)+0;t=a>46;v=t;f=s;t(:,2:end,2)=t(:,1:end-1);t(2:end,:,3)=t(1:end-1,:,1);t(1:end-1,:,4)=t(2:end,:,1);t(:,1:end-1,5)=t(:,2:end,1);t=reshape(t,[],5);m=size(s,1);p=[0 -m -1 1 m];
function z(n)
f(n+p(s(n)))--;q=find(t(n,:));w=n+p(q);d=min(f(w));q=q(f(w)==d);j=randi(numel(q));s(n)=q(j);f(n+p(q(j)))++;end
for g=find(s)' z(g);end
while any((f~=v)(:)) L=find(s);k=zeros(size(s));for h=L' k(h)=f(h+p(s(h)));end;c=find(k>1);g=c(randi(numel(c)));z(g);end
o = y(s+1);end

अभी भी इस जवाब पर बहुत कुछ किया जा रहा है, लेकिन मैं इस बात का खुलासा नहीं करना चाहता था।

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

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

यहाँ कोड है:

function output = germs(before, after)

%before = ['......';'.O..O.';'.OO.O.';'......'];
%after = ['......';'....O.';'.OO.O.';'..O...'];

symbs = '.O<^v>';
start = (before > 46) + 0;                   %should be called current_board
target = after > 46;                         %destinations on current cell == O
goal = target;
conflicts = start;
target(:, 2:end,2) = target(:, 1:end-1);     %destinations on cell to left
target(2:end, :,3) = target(1:end-1, :,1);   %destinations on cell above
target(1:end-1, :,4) = target(2:end, :,1);   %destinations on cell below
target(:, 1:end-1,5) = target(:, 2:end,1);   %destinations on cell to right
target=reshape(target,[],5);
m = size(start,1);                           %number of rows = offset to previous/next column
offsets = [0 -m -1 1 m];                     %offsets of neighbors from current index


function moveGerm(n)
   conflicts(n+offsets(start(n)))--;         %take germ off board
   move = find(target(n, :));                %get valid moves for this germ
   neighbors = n + offsets(move);            %valid neighbors = current position + offsets
   minVal = min(conflicts(neighbors));       %minimum number of conflicts for valid moves
   move = move(conflicts(neighbors)==minVal);
   mi = randi(numel(move));                  %choose a random move with minimum conflicts
   start(n) = move(mi);                      %add move type to board
   conflicts(n + offsets(move(mi)))++;       %add a conflict on the cell we move to
end

% Generate an initial placement
for g = find(start)'
   moveGerm(g);                              %make sure all germs are moved to valid cells
end

% Repeat until board matches goal
while any((conflicts ~= goal)(:))
   germList = find(start);                   %list of all our germs
   cost = zeros(size(start));                %calculate conflicts for each germ
   for h = germList'
      cost(h) = conflicts(h + offsets(start(h)));
   end
   conflicted = find(cost > 1);              %find those germs that occupy the same cell as another
   g = conflicted(randi(numel(conflicted))); %choose a random germ to move
   moveGerm(g);
end

output = symbs(start+1);                     %use moves as indices into symbol array for output

end

अंतिम परीक्षण मामले के लिए आउटपुट:

>> gtest
ans =

..............................
.OO>.O.v.....>.....>.v.O..v...
..>^O.v...>..^>..v..O.v.......
.....v......>..>.....O....O...
.O.<^<OO......>...O..O....v...
.<O..O..v<.O..^<..O..>....>...
..<.^.v......OO.O^..<..<O.....
..^....v..v.Ov...>>>.^OO...O..
.....<..OO......O..O...Ov.<<..
........>..O........O^.v.>....
..^.....OO.....OO.OO.......O..
.^.....^.O..O>.vO....v......O.
..<..Ov^^..O....OO..........O.
.O..O...>.v....O..^....^...OO.
....O...<v..O.......<.^..v<...
........O.O....O.v....O.......
.OO.......<.OO..O.......O..O..
....O....O.<.O...O^<..O.v.OO..
.O^..<<...O.>.v.>.>...<O...v..
..............................

Elapsed time is 0.681691 seconds.

औसत बीता समय 5 साल के कोर i5 पर 9 सेकंड 1 सेकंड * से कम था , जो बोनस के लिए अर्हता प्राप्त करता था।

मैं इसे विचारधारा पर काम करने की कोशिश कर रहा हूं, लेकिन मुझे लगता है कि जिस तरह से यह नेस्टेड कार्यों को संभालता है, उसके साथ मुद्दों पर डांट लगाता हूं। (यहां संदर्भ के लिए गैर-काम करने वाला आइडोन लिंक दिया गया है: http://ideone.com/mQSwgZ ) अब ideone
पर कोड काम कर रहा है। मुझे सभी चरों को वैश्विक रूप से बाध्य करना पड़ा, जो अनावश्यक रूप से स्थानीय स्तर पर चल रहा था।

* मेरे पास मेरे ungolfed संस्करण में एक नोट था कि चरणों में से एक अक्षम था, इसलिए मैंने यह देखने की कोशिश की कि क्या मैं निष्पादन को गति दे सकता हूं और 2 अतिरिक्त बाइट्स के लिए निष्पादन समय अब ​​एक सेकंड के नीचे है। कोड और नमूना आउटपुट को अपडेट किया गया है और विचारधारा पर इनपुट को अंतिम परीक्षण मामले में बदल दिया गया है।

Answer 2

पायथन, 1171 बाइट्स - 878.25 बाइट बोनस = 292.75 बाइट्स

from itertools import *;from random import *;R=range;L=len;O=choice;G='O'
def A(a,b):a.append(b)
def D(y,z):
 a=[];b=[];c=[]
 for i in R(L(y)):
  A(c,[])
  for j in R(L(y[0])):
   k=[(i,j),y[i][j]==G,z[i][j]==G,[],0];A(c[i],k)
   for l,m in [(0,1),(1,0)]:
    try:
     n=c[i-l][j-m]
     if k[2]&n[1]:A(n[3],k)
     if k[1]&n[2]:A(k[3],n)
    except:pass
   if k[1]&~k[2]:A(a,k)
   elif k[2]&~k[1]:A(b,k)
 d={}
 for i in a:
  j=[[i]]
  while j:
   k=j.pop();l=[e[0] for e in k]
   while True:
    m=k[-1];n=[o for o in m[3] if o[0] not in l]
    if not n:
     if m in b:A(d.setdefault(i[0],[]),k)
     break
    for o in n[1:]:p=k[:];A(p,o);A(j,p)
    A(k,n[0]);A(l,n[0][0])
 e={}
 for i in a:e[i[0]]=O(d[i[0]])
 def E():return sum(any(k in j for k in i) for i,j in combinations(e.values(),2))
 f=E()
 for i in count():
  t=3**-i/L(a);j=O(a);k=e[j[0]];e[j[0]]=O(d[j[0]]);l=E()
  if not l:break
  else:
   if l>f and random()>t:e[j[0]]=k
   else:f=l
 for i in e.values():
  for j in R(L(i)-1):i[j][4]=i[j+1]
 for i in c:
  for j in R(L(i)):
   k=i[j]
   if 1&~k[1]:i[j]='.'
   elif not k[4]:i[j]=G
   else:l,m=k[0];n,o=k[4][0];i[j]='v>^<'[abs((l-n+1)+2*(m-o))]
 return c

Ideone लिंक: http://ideone.com/0Ylmwq

औसत पर अंतिम परीक्षा के मामले में 1 - 8 सेकंड से कहीं भी ले जाता है, बोनस के लिए अर्हता प्राप्त करता है।

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

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

व्याख्या

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

• इसके पहले या बाद में कोई कीटाणु नहीं था, जिसका अर्थ है कि हम इसे अनदेखा कर सकते हैं
• इसके पहले एक रोगाणु था, लेकिन बाद में नहीं, जिसका अर्थ है कि हमें इसके लिए एक कदम खोजना होगा।
• इसके पहले कोई रोगाणु नहीं था, लेकिन एक के बाद एक, जिसका अर्थ है कि हमें इसके लिए एक कदम खोजना होगा।
• यह पहले और बाद में एक रोगाणु था, जिसका अर्थ है कि हमें इसके लिए एक कदम खोजना होगा, लेकिन फिर शायद नहीं।

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

मैंने उस समस्या को हल किया जो पहले ग्राफ़ के निर्माण से ऊपर बताया गया था। मैं तो प्रगणित हर में, के बाद तो बेतरतीब ढंग से इसके संभावित रास्तों में से एक से पहले में प्रत्येक कोशिका सौंपा से पहले में प्रत्येक कोशिका और प्रत्येक कोशिका से संभव पथ। अंत में, मैंने संभावित समाधान को अर्ध-बेतरतीब ढंग से बदलने के लिए सिम्युलेटेड एनालिंग का उपयोग किया जब तक कि मुझे अंततः एक ऐसा समाधान नहीं मिला जिसमें किसी भी पथ के लिए कोई संघर्ष न हो।

एनोटेट संस्करण

from itertools import *;from random import *;

# redefine some built-in functions to be shorter
R=range;L=len;O=choice;G='O'
def A(a,b):a.append(b)

# The function itself.  Input is in the form of two 2d arrays of characters, one each for before and after.
def D(y,z):
 # Declare the Before-but-not-after set, the After-but-not-before set, and a temp cell array
 # (the cells are temporarily stored in a 2d array because I need to be able to locate neighbors)
 a=[];b=[];c=[]

 # Build the graph
 for i in R(L(y)):
  # Append a row to the 2d temp array
  A(c,[])

  for j in R(L(y[0])):
   # Define the interesting information about the cell, then add it to the temp array
   # The cell looks like this: [position, does it have a germ before?, does it have a germ after?, list of neighbors with germs, final move]
   k=[(i,j),y[i][j]==G,z[i][j]==G,[],0];A(c[i],k)
   for l,m in [(0,1),(1,0)]:
    # Fill up the neighbors by checking the above and left cell, then mutually assigning edges
    try:
     n=c[i-l][j-m]
     if k[2]&n[1]:A(n[3],k)
     if k[1]&n[2]:A(k[3],n)
    except:pass

   # Decide if it belongs in the Before or After set
   if k[1]&~k[2]:A(a,k)
   elif k[2]&~k[1]:A(b,k)

 # For each cell in the before set, define ALL possible paths from it (this is a big number of paths if the grid is dense with germs)
 # This uses a bastard form of depth-first search where different paths can cross each other, but no path will cross itself
 d={}
 for i in a:
  j=[[i]]  # Define the initial stack of incomplete paths as the starting node.
  while j:
   # While the stack is not empty, pop an incomplete path of the stack and finish it
   k=j.pop();l=[e[0] for e in k]
   while True:
    # Set the list of next possible moves to the neighbors of the current cell,
    # ignoring any that are already in the current path.
    m=k[-1];n=[o for o in m[3] if o[0] not in l]

    # If there are no more moves, save the path if it ends in an After cell and break the loop
    if not n:
     if m in b:A(d.setdefault(i[0],[]),k)
     break

    # Otherwise, set the next move in this path to be the first move,
    # then split off new paths and add them to the stack for every other move
    for o in n[1:]:p=k[:];A(p,o);A(j,p)
    A(k,n[0]);A(l,n[0][0])

 # Perform simulated annealing to calculate the solution
 e={}
 for i in a:e[i[0]]=O(d[i[0]])  # Randomly assign paths for the first potential solution

 # Define a function for calculating the number of conflicts between all paths, then do the initial calculation for the initial potential solution
 def E():return sum(any(k in j for k in i) for i,j in combinations(e.values(),2))
 f=E()

 # Do the annealing
 for i in count():
  # The "temperature" for simulated annealing is calculated as 3^-i/len(Before set).
  # 3 was chosen as an integer approximation of e, and the function e^(-i/len) itself was chosen because
  # it exponentially decays, and does so slower for larger problem sets
  t=3**-i/L(a)

  j=O(a)              # Pick a random Before cell to change
  k=e[j[0]]           # Save it's current path
  e[j[0]]=O(d[j[0]])  # Replace the current path with a new one, randomly chosen
  l=E()               # Recalculate the number of conflicts

  if not l:break  # If there are no conflicts, we have a valid solution and can terminate
  else:           # Otherwise check the temperature to see if we keep the new move
   if l>f and random()>t:e[j[0]]=k  # Always keep the move if it's better, and undo it with probability 1 - T if it's worse
   else:f=l                         # If we don't undo, remember the new conflict count

 # Set each of the cells' final moves based on the paths
 for i in e.values():
  for j in R(L(i)-1):i[j][4]=i[j+1]

 # Build the output in the form of a 2d array of characters
 # Reuse the temp 2d array from step since its the right size
 for i in c:
  for j in R(L(i)):
   k=i[j]
   # Cells that are empty in the before array are always empty in the output
   if 1&~k[1]:i[j]='.'
   # Cells that aren't empty and don't have a move are always germs in the output
   elif not k[4]:i[j]=G
   # Otherwise draw the move
   else:l,m=k[0];n,o=k[4][0];i[j]='v>^<'[abs((l-n+1)+2*(m-o))]
 return c