देखें पुलिस धागा अधिक जानकारी के लिए। इस प्रश्न के प्रत्येक उत्तर को वहां एक उत्तर देना चाहिए। यह कहना है, यह उस जवाब में दिए गए दुभाषिया में चलाने पर इनपुट में तीसरे सबसे बड़े पूर्णांक को खोजने के लिए कोड होना चाहिए।
यदि आप एक दरार पोस्ट करते हैं जो अमान्य हो जाती है, तो आपको इसे हटा देना चाहिए और उसी उत्तर के खिलाफ एक और प्रयास पोस्ट करने के लिए अयोग्य हैं।
इस सवाल का विजेता वह डाकू है जो सबसे अधिक सफल दरारें बनाता है।
जवाबों:
cinpush
main:
gte Hans 1s Leopold
jnz Leopold done
mov 1s Hans
gte Gertrude Hans Leopold
jnz Leopold done
mov Gertrude ShabbySam
mov Hans Gertrude
mov ShabbySam Hans
gte Alberto Gertrude Leopold
jnz Leopold done
mov Alberto ShabbySam
mov Gertrude Alberto
mov ShabbySam Gertrude
done:
mov 10 ShabbySam
gte 1s ShabbySam Leopold
jz Leopold undo_u
mov 30 ShabbySam
gte 1s ShabbySam Leopold
jz Leopold undo_d
undo_r:
POP!! 1
"shuffle" f
"shuffle" f
"shuffle" b
"shuffle" b
"shuffle" l
"shuffle" f
"shuffle" f
"shuffle" b
"shuffle" b
jmp end
undo_u:
POP!! 1
"shuffle" f
"shuffle" f
"shuffle" f
"shuffle" b
"shuffle" b
"shuffle" b
"shuffle" l
"shuffle" l
"shuffle" l
"shuffle" f
"shuffle" b
jmp end
undo_d:
POP!! 1
"shuffle" f
"shuffle" b
"shuffle" l
"shuffle" f
"shuffle" f
"shuffle" f
"shuffle" b
"shuffle" b
"shuffle" b
end:
jnz 1s main
print Hans
done!
यह वास्तव में बहुत मजेदार था, धन्यवाद लियाम! :)
सही दिशा में एक मामूली लेकिन आवश्यक नग्नता के लिए Sp3000 के लिए धन्यवाद।
दो शब्द: पॉकेट क्यूब ।
यह पता चला है कि ढेर 2x2x2 रूबिक के घन के चेहरों के अनुरूप हैं:
____ ____
| | |
| 19 | 17 |
|____U____|
| | |
| 20 | 18 |
_________|____|____|____ ____ ____ ____
| | | | | | | | |
| 13 | 14 | 1 | 2 | 9 | 10 | 6 | 5 |
|____L____|____F____|____R____|____B____|
| | | | | | | | |
| 15 | 16 | 3 | 4 | 11 | 12 | 8 | 7 |
|____|____|____|____|____|____|____|____|
| | |
| 22 | 24 |
|____D____|
| | |
| 21 | 23 |
|____|____|
जहां ULFRBDसंकेत मिलता है कि कौन सा चेहरा ऊपर, बाएं, सामने, दाएं, पीछे, नीचे है जब घन ठीक से मुड़ा हुआ है।
क्रमपरिवर्तन किसी भी एक पक्ष को 90 डिग्री तक घुमाने के लिए मेल खाते हैं (जहां नाम शुक्र से मेल खाते हैं)। यह पता चला है कि f, rऔर dदक्षिणावर्त घुमाव (जब चेहरा देख रहे हैं ) और r, lऔर uकाउंटर-दक्षिणावर्त घुमाव (जब चेहरा देख रहे हैं)।
अब cinpushकमांड इस तरह से संचालित होती है कि यह घुमावों में से एक को लागू करती है u, dया r(दिए गए मूल्य के आधार पर) और फिर स्थिति में स्टैक पर इनपुट मूल्य को धक्का देती है 1। (और फिर यह इनपुट में हर तत्व के लिए इसे दोहराता है।) इसका मतलब है कि हम इस प्रक्रिया को उल्टा कर सकते हैं (यह सुनिश्चित करने के लिए कि हम बिना रुबिक के क्यूब को हल करने के लिए स्टैक के सही क्रम के साथ समाप्त होते हैं) बार-बार स्टैक को देखकर। स्थिति 1, इसी क्रमांकन को पूर्ववत् करना और उस स्टैक का मान पॉप करना (ताकि अगली बार जब हम स्टैक देखें, तो हमें मूल्य कम मिले)।
हम रोटेशन को पूर्ववत कैसे करते हैं? शुक्र है, हमारे पास fऔर bहमारे निपटान में दोनों हैं । यदि हम दोनों को लागू करते हैं, तो हम पूरे क्यूब को 90 डिग्री तक घुमाते हैं। इसका मतलब है कि हम प्रभावित पक्ष ( या U, ) को एक या तीन एस का उपयोग करके रोटेशन को पूर्ववत कर सकते हैं ( इनपुट के दौरान और उसके रोटेशन के सापेक्ष दिशा के आधार पर ), और फिर क्यूब को अपने पिछले अभिविन्यास का उपयोग करके और फिर से घुमाएं फिर।RDLllfb
विशेष रूप से, इनपुट के दौरान किए गए प्रत्येक घुमाव को निम्नानुसार पूर्ववत किया जा सकता है:
u --> fffbbblllfb
r --> ffbblffbb
d --> fblfffbbb
मैं देखूंगा कि क्या मैं यह दिखाने के लिए कुछ एनिमेशन के साथ आ सकता हूं।
अब यह हमें एक बार पूरे इनपुट के माध्यम से पुनरावृति का रास्ता देता है। लेकिन 5 रजिस्टरों के साथ, हम सभी की जरूरत है:
Alberto अब तक प्राप्त अधिकतम मूल्य है।Gertrude अब तक का दूसरा सबसे बड़ा मूल्य है।Hans अब तक का सामना करना पड़ा 3 सबसे बड़ा मूल्य है।जब हम एक नए मूल्य का सामना करते हैं, तो हम इसे उन तीनों तक बुलबुला बनाते हैं जहां तक आवश्यक हो, जहां हम ShabbySamस्वैप के लिए एक अस्थायी रजिस्टर के रूप में उपयोग कर सकते हैं । यह अभी भी छोड़ देता है Leopoldजिसे हम आवश्यक तुलना करते समय एक सशर्त धारण करने के लिए उपयोग कर सकते हैं।
प्रक्रिया के अंत में, हम केवल उन सामग्रियों को प्रिंट करते हैं Hans, जो पहले से ही 3 वें सबसे बड़े मूल्य को पकड़ लेंगे।
यह शायद इष्टतम नहीं है, लेकिन मुझे लगता है कि यह चाल है ...
cvcvc>v>^>>^^>>v>vvvvvvvv<<<^<<^<<^^>^<^cvc>v<cvcvcvc^>>vv<<c
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>cv<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>vc^v<>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<c^<^>^
>>^^<<^^>^c^^<^>^
>>^^<<^^>c<^>^^<^>^
>>^^<^c^<^>^^<^>^
>>^^<c<^^^>^^<^>^
>^cv>^>^<<<^^^>^^<^>^
>c>^>^<<<^^^>^^<^>^
>>^>>v>>>^^^^^^^^<^<<vv<<v<^<^^>>cv^
>>^>>v>>>^^^^^^^^<^<<<v<c^
>>^>>v>>>^^^^^^^^<^<<vv<<c^^
>>^>>v>>>^^^^^^^^<^<<vv<<vcv>>>^<^<<^^
>>^^<<^^>>^c>>>^<^<<^^
>>^^<<^^>>c<^>>>>^<^<<^^
>>^>>v>>^<^^<<<c^<^>>>>^<^<<^^
>>^^c>vv>^^^<<^<^>>>>^<^<<^^
>>^c^>vv>^^^<<^<^>>>>^<^<<^^
>>c^^>vv>^^^<<^<^>>>>^<^<<^^
>>^>>v>>>^^^^^^^^<^<<<c<>
>>^>>v>>>^^^^^^^^<^<<<vc^<>
>>^>>v>>>^^^^^^^^<^<<vv<c^^
>>^>>v>>>^^^^^^^^<^<<vv<vc^^^
>>^^<<^^>>>^c^^^^
>>^^<<^^>>>c^^^^^
>>^>>v>>^<^^<<c^^^^^^
>>^>^c<^^<^>^^^>^
>>^>c^<^^<^>^^^>^
>>>c^^<^^<^>^^^>^
>>^>>v>>>^^^^^^^^<^<<c<<>>
>>^>>v>>>^^^^^^^^<^<<vc<^>
>>^>>v>>>^^^^^^^^<^<<vvc>^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>c>^^<<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v<c^>^^<<^>
>>^^<<^^>>>>cv<^<^^>^>>^<<^>
>>^>>v>>^<^^<c<^<^^>^>>^<<^>
>>^>>v>>^<^^<vc>^^<v<^<^^>^>>^<<^>
>>^>>c>^^^<v<^<^^>^>>^<<^>
>>^>>vc<<^^>^^<^^>^>>^<<^>
>>^>>v>>>^^^^^^^^<^<cv^
>>^>>v>>>^^^^^^^^<<c^
>>^>>v>>>^^^^^^^^<^<<vv>c<^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>c<^^>^
>>^>>v>>>^^^^^^^^<^<<vv<v>>vc^<^^>^
>>^>>v>>^<^^^c^^<^^>^
>>^>>v>>^<^^c>v>>^>^<^^^<^<<^
>>^>>v>>^<^c^>v>>^>^<^^^<^<<^
>>^>>v>>^<c^^>v>>^>^<^^^<^<<^
>>^>>v>c^^^>v>>^>^<^^^<^<<^
>>^>>v>>>^^^^^^^^<^c<v^>
>>^>>v>>>^^^^^^^^<c<^>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>^c<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>>c>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^<<vv<v>>v>c^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^<c^^>^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^<^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>^cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>>^>>v>>>^^^^^^^^<^>c><
>>^>>v>>>^^^^^^^^c>^<
>>^>>v>>>^^^^^^^c^>^<
>>^>>v>>>^^^^^^c>^<^>^<
>>^>>v>>>^^^^^c^>^<^>^<
>>^>>v>>>^^^^c^^>^<^>^<
>>^>>v>>>^^^c>^^<^>^<^>^<
>>^>>v>>>^^c^>^^<^>^<^>^<
>>^>>v>>>^cv>^^<^>^^<^>^<^>^<
>>^>>v>>>c>^^<^>^^<^>^<^>^<
>>^>>v>>>^^^^^^^^>^c<>
>>^>>v>>>^^^^^^^^>c^<>
>>^>>v>>>^^^^^^^>cv<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^^^^^>vc<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^^c^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>^c^^<vvv>v<<^^^^^^>>^
>>^>>v>>>^^^>cv<<^^^^^^>>^
>>^>>v>>>^^^>vc<<^^^^^^>>^
>>^>>v>>>^>cv<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^>vc<<<^<<<^>>>>^^^^^^>>^
>>^>>v>>>^^^^^^^^>^>cv^
>>^>>v>>>^^^^^^^>>^c^
>>^>>v>>>^^^^^^^>>c^^
>>^>>v>>>^^^>^^>^c^^^
>>^>>v>>>^^^>^^>cvv<^^^^^^>
>>^>>v>>>^^^>^^>vcv<^^^^^^>
>>^>>v>>>^^^>>c<^^^^^^>
>>^>>v>>>^>v>^^cvv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>^cv<<^<^^>^>^^^^^>
>>^>>v>>>^>v>c<<^<^^>^>^^^^^>
cvc<v>cvcvc<v>cvc^<vv>c>>v<v<^cvc
>^>^<<<^^^>^>^>^^<cv^
>^>^<<<^^^>^>^^c^
>^>^<<<^^^>^>^c^^
>^>^<<<^^^>^>cv>>>^<^<<^^
>^>^<^^^c>>>^<^<<^^
>^>^<^^c<^>>>>^<^<<^^
>^>^<^c^<^>>>>^<^<<^^
>^>^<c>vv>^^^<<^<^>>>>^<^<<^^
>^c^>vv>^^^<<^<^>>>>^<^<<^^
>c^^>vv>^^^<<^<^>>>>^<^<<^^
>^>^<<<^^^>^>^>^^c<<>>
>^>^<<<^^^>^>^>^c^<<>>
>^>^<<<^^^>^>^>c^^<<>>
>^>^<<<^^^>^>>c^^^
>^>^<^^^>c^^^^
>^>^<^^>c^^^^^
>^>^<^>c^^^^^^
>^>^c<^^<^>^^^>^
>^>c^<^^<^>^^^>^
>^>>v<c^^<^^<^>^^^>^
>^>^<<<^^^>^>^>^^>c<v<>^>
>^>^<<<^^^>^>^>^^>vc<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<^c>^<<^>
>^>^<<<^^^>^>^>^^>>>>v<vv<<c>^^<<^>
>^>^<^^^>>c^>^^<<^>
>^>^<^>>^cv<^<^^>^>>^<<^>
>^>^<^>>c<^<^^>^>>^<<^>
>^>^<^>>vc>^^<v<^<^^>^>>^<<^>
>^>>c>^^^<v<^<^^>^>>^<<^>
>^>>vc<<^^>^^<^^>^>>^<<^>
>^>^<<<^^^>^>^>^^>>cv^
>^>^<<<^^^>^>^>^^>>>>v<<c^
>^>^<<<^^^>^>^>^^>>>>v<v<c<^>^
>^>^<<<^^^>^>^>^^>>>>v<vv<c<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<c^<^^>^
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<<vc^^<^^>^
>^>^<^>>v>^c>v>>^>^<^^^<^<<^
>^>^<^>>v>c^>v>>^>^<^^^<^<<^
>^>^<^>>v>vc^^>v>>^>^<^^^<^<<^
>^>^<^>>v>vvc^^^>v>>^>^<^^^<^<<^
>^>^<<<^^^>^>^>^^>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>v<c<^>
>^>^<<<^^^>^>^>^^>>>>v<vc<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<vvc>^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>v<v>>v<v<c^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<^c^^>^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>>>^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<^>>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>^>^<<<^^^>^>^>^^>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>vc>^<
>^>^<<<^^^>^>^>^^>>>>v<v>c^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<c>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>v<vc^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv<c^^>^<^>^<
>^>^<^>>v>>>>^<c>^^<^>^<^>^<
>^>^<^>>v>>>c^>^^<^>^<^>^<
>^>^<^>>v>>>vcv>^^<^>^^<^>^<^>^<
>^>^<^>>v>vv>>c>^^<^>^^<^>^<^>^<
>^>^<<<^^^>^>^>^^>>>>>cv^
>^>^<<<^^^>^>^>^^>>>>v>c^
>^>^<<<^^^>^>^>^^>>>>v<v>>cv<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vc<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvc^<vvv>v<<^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvvc^^<vvv>v<<^^^^^^>>^
>^>^<^>>v>>>>^cv<<^^^^^^>>^
>^>^<^>>v>>>>c<<^^^^^^>>^
>^>^<^>>v>>>v>cv<<<^<<<^>>>>^^^^^^>>^
>^>^<^>>v>>>v>>v<c<<<^<<<^>>>>^^^^^^>>^
>^>^<<<^^^>^>^>^^>>>>>>c<v^>
>^>^<<<^^^>^>^>^^>>>>>>vc^<v^>
>^>^<<<^^^>^>^>^^>>>>v<v>>v>^c^^
>^>^<<<^^^>^>^>^^>>>>v<v>>v>c^^^
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>^cvv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>cv<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vc<^^^^^^>
>^>^<<<^^^>^>^>^^>>>>v<v>>vvv>vvcvv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>cv<<^<^^>^>^^^^^>
>^>^<^>>v>>>v>>vc<<^<^^>^>^^^^^>
cvcvc>>v>v<<<^cvc<v>cvc>>vvv<^^<cvcvc
^^>vv>>^^^^>^>^>^<^<<^<<c<>
^^>vv>>^^^^>^>^>^<^<<^<<vc^<>
^^>vv>^^^<<^<^>>>>^<^<c^^
^^>vv>^^^<<^<^>>>>^<^<vc^^^
^^>vv>^^^<<^<^>>c^^^^
^^>vv>^^^<^c^^^^^
^^>vv>^^^<c^^^^^^
^^>c<^^<^>^^^>^
^^>vc^<^^<^>^^^>^
^^>vvc^^<^^<^>^^^>^
^^>vv>>^^^^>^>^>^<^<<^<c<<>>
^^>vv>^^^<<^<^>>>>^<^^c<^>
^^>vv>^^^<<^<^>>>>^<^c>^<<^>
^^>vv>^^^<<^<^>>>>^<c>^^<<^>
^^>vv>^^^<<^<^>>>c^>^^<<^>
^^>vv>^^^<<^<^>>>vcv<^<^^>^>>^<<^>
^^>vv>^^^c<^<^^>^>>^<<^>
^^>vv>^^c>^^<v<^<^^>^>>^<<^>
^^>vv>^c>^^^<v<^<^^>^>>^<<^>
^^>vv>c<<^^>^^<^^>^>>^<<^>
^^>vv>>^^^^>^>^>^<^<<^cv<>^
^^>vv>>^^^^>^>^>^<^<<c^v<>^
^^>vv>^^^<<^<^>>>>^>^<c<^>^
^^>vv>^^^<<^<^>>>>^c<^^>^
^^>vv>^^^<<^<^>>>>c^<^^>^
^^>vv>>^^^^c^^<^^>^
^^>vv>>^^^c>v>>^>^<^^^<^<<^
^^>vv>>^^c^>v>>^>^<^^^<^<<^
^^>vv>>^c^^>v>>^>^<^^^<^<<^
^^>vv>>c^^^>v>>^>^<^^^<^<<^
^^>vv>>^^^^>^>^>^<^<<^>c<<<<>>>>
^^>vv>>^^^^>^>^>^<^<c<^><<<<>>>>
^^>vv>^^^<<^<^>>>>^>^c<vv<<v<^^<^<^^>>>>>>
^^>vv>^^^<<^<^>>>>^>c>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^c^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>>>v<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<^c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>>^<cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^>vv>>^^^^>^>^>^<^<<^>>c><
^^>vv>>^^^^>^>^>^<^c>^<
^^>vv>>^^^^>^>^>^<c^>^<
^^>vv>>^^^^>^>^c>^<^>^<
^^>vv>>^^^^>^>c^>^<^>^<
^^>vv>>^^^^>>c^^>^<^>^<
^^>vv>>^^^^>>>v<c>^^<^>^<^>^<
^^>vv>>>>^<^>c^>^^<^>^<^>^<
^^>vv>>>>^cv>^^<^>^^<^>^<^>^<
^^>vv>>>>c>^^<^>^^<^>^<^>^<
^^>vv>>^^^^>^>^>^^^c<>
^^>vv>>^^^^>^>^>^^c^<>
^^>vv>>^^^^>^>^>^cv<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>^>^>c<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>>^<c^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>c^^<vvv>v<<^^^^^^>>^
^^>vv>>^^^^>>>vcv<<^^^^^^>>^
^^>vv>>>>^<^>>c<<^^^^^^>>^
^^>vv>>>>>>^<cv<<<^<<<^>>>>^^^^^^>>^
^^>vv>>>>>c<<<^<<<^>>>>^^^^^^>>^
^^>vv>>^^^^>^>^>^^>^c<>
^^>vv>>^^^^>^>^>^^>c^<>
^^>vv>>^^^^>^>^>^^>vc^^<>
^^>vv>>^^^^>^>^>>c^^^
^^>vv>>^^^^>>>>^cvv<^^^^^^>
^^>vv>>^^^^>>>>cv<^^^^^^>
^^>vv>>^^^^>>>>vc<^^^^^^>
^^>vv>>>>>>^^cvv<<^<^^>^>^^^^^>
^^>vv>>>>>>^cv<<^<^^>^>^^^^^>
^^>vv>>>>>>c<<^<^^>^>^^^^^>
cvcvcvcvcvcvc^^^^^<vvv<v>vv>cvcvc
^^<^^<^>^^^>>^c<>
^^<^^<^>^^^>>c<^>
^^<^^<^>^^^>v>c>^<<^>
^^<^^<^>^^^>vv>c>^^<<^>
^^<^^<^>^^^>vv>vc^>^^<<^>
^^<^^<^>^^^>vvvvv>^cv<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>c<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>vc>^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>v<c>^^^<v<^<^^>^>>^<<^>
^^<^^<^>^^^>vvvvv>v>vv<c<<^^>^^<^^>^>>^<<^>
^^<^^<^>^^^>>^>cv^
^^<^^<^>^^^>>>c^
^^<^^<^>^^^>v>>c<^>^
^^<^^<^>^^^>vv>>c<^^>^
^^<^^<^>^^^>vv>v>c^<^^>^
^^<^^<^>^^^>vvvvv>^>c^^<^^>^
^^<^^<^>^^^>vvvvv>>c>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>c^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vc^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>vvvvv>v>vvc^^^>v>>^>^<^^^<^<<^
^^<^^<^>^^^>>>>>>^<<c>><<
^^<^^<^>^^^>>>>c<^>
^^<^^<^>^^^>vv>>>^c<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>c>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vv>>>vc^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<^<c^^>^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>>>^^<<c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>v>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>vvvvv>v>vv>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^<^^<^>^^^>>>>>>^<c<<>>
^^<^^<^>^^^>>>>>c>^<<<>>
^^<^^<^>^^^>vv>>>^>c^>^<
^^<^^<^>^^^>vv>>>>c>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^^c^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<^c^^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>>^^<c>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>^c^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>cv>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>vvvvv>v>v>>vc>^^<^>^^<^>^<^>^<
^^<^^<^>^^^>>>>>>^cv><^
^^<^^<^>^^^>>>>>>c^v><^
^^<^^<^>^^^>>>>>>^>vv<cv<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vv>>>>>c<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^c^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^^c^^<vvv>v<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^^cv<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>^c<<^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>cv<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>vvvvv>v>v>>>vc<<<^<<<^>>>>^^^^^^>>^
^^<^^<^>^^^>>>>>>^>cvvv^^^
^^<^^<^>^^^>>>>>>^>vc^vvv^^^
^^<^^<^>^^^>>>>>>^>vvc^^vvv^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>^c^^^
^^<^^<^>^^^>vvvvv>v>v>>>^^^^>cvv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^^cv<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>^c<^^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>^>cvv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>^cv<<^<^^>^>^^^^^>
^^<^^<^>^^^>vvvvv>v>v>>>v>c<<^<^^>^>^^^^^>
c<v>c>v<c>v<cvc^>^<<v<vv>v>^cvc^>vv<c>v<c>^^^<v<v<vv>>c
<<^^>^^<^^>^>>^^c<>
<<^^>^^<^^>^>>^c^<>
<<^^>^^<^^>^>>c<^>^
<<^^>^^<^^>^>>vc<^^>^
<<^^>^^<^^>^>>vvc^<^^>^
<<^^>^>^>c^^<^^>^
<<^^>^>^>vc>v>>^>^<^^^<^<<^
<<^^>^>^>vvc^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvc^^>v>>^>^<^^^<^<<^
<<^^>^>^>vvvvc^^^>v>>^>^<^^^<^<<^
<<^^>^^<^^>^>>^^>c<<>>
<<^^>^^<^^>^>>^>c<^><<>>
<<^^>^^<^^>^>>>c<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>^c>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>c^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>vv>vc^^>^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>^c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>c^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>vcv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^>^>vv>v>v<c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
<<^^>^^<^^>^>>^^>>c>v^<
<<^^>^^<^^>^>>>>^c>^<
<<^^>^^<^^>^>>>>c^>^<
<<^^>^>^>vv>^>^>^^<c>^<^>^<
<<^^>^>^>vv>^>^>^^<vc^>^<^>^<
<<^^>^>^>vv>^>^c^^>^<^>^<
<<^^>^>^>vv>^>c>^^<^>^<^>^<
<<^^>^>^>vv>>c^>^^<^>^<^>^<
<<^^>^>^>vv>v>cv>^^<^>^^<^>^<^>^<
<<^^>^>^>vv>v>vc>^^<^>^^<^>^<^>^<
<<^^>^^<^^>^>>^^>>>cv^
<<^^>^>^>vv>^>^>^^^^c^
<<^^>^>^>vv>^>^>^^^cv<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^^c<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>^c^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>c^^<vvv>v<<^^^^^^>>^
<<^^>^>^>vv>^>^>vcv<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvc<<^^^^^^>>^
<<^^>^>^>vv>^>^>vvvcv<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>v>v>c<<<^<<<^>>>>^^^^^^>>^
<<^^>^>^>vv>^>^>^^^>^^c<>
<<^^>^>^>vv>^>^>^^^>^c^<>
<<^^>^>^>vv>^>^>^^^>c^^<>
<<^^>^>^>vv>^>^>^^>c^^^
<<^^>^>^>vv>^>^>>^cvv<^^^^^^>
<<^^>^>^>vv>^>^>>cv<^^^^^^>
<<^^>^>^>vv>^>^>>vc<^^^^^^>
<<^^>^>^>vv>^>^>>vvcvv<<^<^^>^>^^^^^>
<<^^>^>^>vv>^>^>vvv>cv<<^<^^>^>^^^^^>
<<^^>^>^>vv>v>v>>c<<^<^^>^>^^^^^>
cvc<v>c<v>cvcvc^^<^^>>>v>vvv>v<v<<^<cvcvcvc
^^^>v>>^>^<^^^<^<^c<>
^^^>v>>^>^<^^^<^<c<^>
^^^>v>>^>^<^^^<<c<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<v<c>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<vv<c^>^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<<<vv>vv>c^^>^<<vv<<v<^^<^<^^>>>>>>
^^^>c<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>vc^<v<v>>v>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^>cv>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
>c>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>
^^^>v>>^>^<^^^<^<^>c><
^^^>v>>^>^<^^^<^c>^<
^^^>v>>^>^<^^^<c^>^<
^^^>v>>^>^<^^^<vc>^<^>^<
^^^>v>>^>^<^^^<vvc^>^<^>^<
^^^>v>>^>^<^^^<^<<<vv>vv>>c^^>^<^>^<
^^^>v>>^<c>^^<^>^<^>^<
^^^>v>c^>^^<^>^<^>^<
^>>cv>^^<^>^^<^>^<^>^<
^^^>v>>>vv<<c>^^<^>^^<^>^<^>^<
^^^>v>>^>^<^^^<^>>^<c<>
^^^>v>>^>^<^^^<^>c^
^^^>v>>^>^<^^^cv<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^^c<vvv>v<<^^^^^^>>^
^^^>v>>^>^<^c^<vvv>v<<^^^^^^>>^
^^^>v>>^>^<c^^<vvv>v<<^^^^^^>>^
^^^>v>>^cv<<^^^^^^>>^
^^^>v>>c<<^^^^^^>>^
^^^>v>>vcv<<<^<<<^>>>>^^^^^^>>^
^^^>v>>>vv<c<<<^<<<^>>>>^^^^^^>>^
^^^>v>>^>^<^^^<^>>^c<<>>
^^^>v>>^>^<^^^<^>>c^<<>>
^^^>v>>^>^<^^^>c^^
^^^>v>>^>^<^^>c^^^
^^^>v>>^>^<^>cvv<^^^^^^>
^^^>v>>^>^cv<^^^^^^>
^^^>v>>^>c<^^^^^^>
^^^>v>>>cvv<<^<^^>^>^^^^^>
^^^>v>>>vcv<<^<^^>^>^^^^^>
^^^>v>>>vvc<<^<^^>^>^^^^^>
c<v>c<^<<<<<vv>v>vv>^>>^^>c>v<cvcvc^^>>vvvv>vv<^<v<^<<^>^>cvc^<v<v>>cvc
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>>>c><
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>c>^<
>^>v>^^<^^^^<^c^>^<
>^>v>^^<^^^^<c>^<^>^<
>^>v>^^<^^^<c^>^<^>^<
>^>v>^^<^^<c^^>^<^>^<
^<<^>^>>c>^^<^>^<^>^<
^<<^>^>>vc^>^^<^>^<^>^<
>^cv>^^<^>^^<^>^<^>^<
>c>^^<^>^^<^>^<^>^<
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^c<>
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>c^<>
>^>v>^^<^^^^^cv<vvv>v<<^^^^^^>>^
>^>v>^^<^^^^c<vvv>v<<^^^^^^>>^
>^>v>^^<^^^c^<vvv>v<<^^^^^^>>^
>^>v>^^<^^c^^<vvv>v<<^^^^^^>>^
>^>v>^^<^cv<<^^^^^^>>^
>^>v>^^<c<<^^^^^^>>^
>^>cv<<<^<<<^>>>>^^^^^^>>^
>^>vc<<<^<<<^>>>>^^^^^^>>^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>^>cv^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>c^
>^>v>^^<^^^^<^<<vv<<v<^^<^<^^>>>>>v>>>>vc^^
>^>v>^^<^^^^>c^^^
>^>v>^^<^^>^cvv<^^^^^^>
>^>v>^^<^^>cv<^^^^^^>
>^>v>^^<^^>vc<^^^^^^>
>^>v>^^cvv<<^<^^>^>^^^^^>
>^>v>^cv<<^<^^>^>^^^^^>
>^>v>c<<^<^^>^>^^^^^>
c>v<cvc>v<cvcvc^>vv<cvc>vv<^cvc
>^^<^>^^<^>^<^>^cv><^
>^^<^>^^<^>^<^>c^v><^
>^^<^>^^<^>^cv<vvv>v<<^^^^^^>>^
>^^<^>^^<^>c<vvv>v<<^^^^^^>>^
>^^<^>^^c^<vvv>v<<^^^^^^>>^
>^^<^>^c^^<vvv>v<<^^^^^^>>^
>^^<^>cv<<^^^^^^>>^
>^^c<<^^^^^^>>^
>^cv<<<^<<<^>>>>^^^^^^>>^
>c<<<^<<<^>>>>^^^^^^>>^
>^^<^>^^<^>^>^^c<>
>^^<^>^^<^>^>^c^<>
>^^<^>^^<^>^>c^^<>
>^^<^>^^<^>>c^^^
>^^<^>^^>cvv<^^^^^^>
>^>^^^cv<^^^^^^>
>^>^^c<^^^^^^>
>^>^cvv<<^<^^>^>^^^^^>
>^>cv<<^<^^>^>^^^^^>
>^>vc<<^<^^>^>^^^^^>
cvc<<vvvvvv>>^<^^^>^cvcvcvc^^<vvv>cvc<<<<<<v>>>v>>>^cvc
<<<^<<<^>>>>^^^^^^>>>^c<>
<<<^<<<^>>>>^^^^^^>>>c^<>
<<<^<<<^>>>>^^^^^^>>>vc^^<>
<<<^<<<^>>>>>>^<^^^>v>^c^^^
<<<^<<<^>>>>>>^<^^^>v>cvv<^^^^^^>
<<<^<<<^>>>>>>^>^cv<^^^^^^>
<<<^<<<^>>>>>>^>c<^^^^^^>
<<<^<<<^>>>>>>^>vcvv<<^<^^>^>^^^^^>
^>cv<<^<^^>^>^^^^^>
>c<<^<^^>^>^^^^^>
cvcvcvc^^^<vvvvvv>^^cvcvc<^<v<vv>v>>^^cvcvc
यह एक आश्चर्य के रूप में आ सकता है, लेकिन मैंने इसे हाथ से नहीं लिखा था ... कोड निम्नलिखित गणित कार्यक्रम द्वारा उत्पन्न किया गया था:
layouts = Graph /@ {Labeled[DirectedEdge[#, #2], #3] & @@@ {{0, 1, ">"}, ... };
path[layout_, a_, b_] :=
StringJoin[
PropertyValue[{layouts[[layout + 1]], #}, EdgeLabels] & /@
DirectedEdge @@@
Partition[FindShortestPath[layouts[[layout + 1]], a, b], 2, 1]]
safetyCheck[layout_, target_] = "";
safetyCheck[0, 1] = safetyCheck[0, 11] = "v<>^";
safetyCheck[0, 2] = "v^";
safetyCheck[0, 3] = safetyCheck[0, 13] = "<>";
safetyCheck[0, 4] = "<<>>";
safetyCheck[0, 5] = "v^";
safetyCheck[0, 6] = "<v^>";
safetyCheck[0, 7] = "><";
safetyCheck[0, 8] = safetyCheck[0, 18] = "<>";
safetyCheck[0, 9] = "v^";
safetyCheck[1, 2] = "v^";
safetyCheck[1, 3] = safetyCheck[1, 13] = safetyCheck[1, 23] = "<<>>";
safetyCheck[1, 4] = "<v<>^>";
safetyCheck[1, 5] = "v^";
safetyCheck[1, 6] = "<v^>";
safetyCheck[1, 7] = "<v^>";
safetyCheck[1, 8] = "v^";
safetyCheck[1, 9] = safetyCheck[1, 19] = "<v^>";
safetyCheck[2, 3] = safetyCheck[2, 13] = "<>";
safetyCheck[2, 4] = "<<>>";
safetyCheck[2, 5] = safetyCheck[2, 15] = "v<>^";
safetyCheck[2, 6] = safetyCheck[2, 16] = "<<<<>>>>";
safetyCheck[2, 7] = "><";
safetyCheck[2, 8] = safetyCheck[2, 18] = "<>";
safetyCheck[2, 9] = safetyCheck[2, 19] = safetyCheck[2, 29] = "<>";
safetyCheck[3, 4] = "<>";
safetyCheck[3, 5] = "v^";
safetyCheck[3, 6] = ">><<";
safetyCheck[3, 7] = safetyCheck[3, 17] = "<<>>";
safetyCheck[3, 8] = safetyCheck[3, 18] = "v><^";
safetyCheck[3, 9] = safetyCheck[3, 19] = safetyCheck[3, 29] = "vvv^^^";
safetyCheck[4, 5] = safetyCheck[4, 15] = "<>";
safetyCheck[4, 6] = safetyCheck[4, 16] = "<<>>";
safetyCheck[4, 7] = ">v^<";
safetyCheck[4, 8] = "v^";
safetyCheck[4, 9] = safetyCheck[4, 19] = safetyCheck[4, 29] = "<>";
safetyCheck[5, 6] = "<>";
safetyCheck[5, 7] = "><";
safetyCheck[5, 8] = "<>";
safetyCheck[5, 9] = safetyCheck[5, 19] = "<<>>";
safetyCheck[6, 7] = "><";
safetyCheck[6, 8] = safetyCheck[6, 18] = "<>";
safetyCheck[6, 9] = "v^";
safetyCheck[7, 8] = safetyCheck[7, 18] = "v><^";
safetyCheck[7, 9] = safetyCheck[7, 19] = safetyCheck[7, 29] = "<>";
safetyCheck[8, 9] = safetyCheck[8, 19] = safetyCheck[8, 29] = "<>";
minions = {};
For[i = 0, i < 10, ++i,
collector = "c";
For[j = i, j < 90, j += 10,
collector = collector <> path[i, j, j + 10] <> "c"
];
AppendTo[minions, collector];
For[newI = i + 1, newI < 10, ++newI,
For[k = 0, k < 10, ++k,
AppendTo[minions,
path[i, j, 10 k + newI] <> "c" <> path[newI, 10 k + newI, newI] <>
safetyCheck[i, 10 k + newI]]
]
]
];
StringRiffle[minions, "\n"]
मैंने वास्तव में उन सभी safetyCheckपंक्तियों को हाथ से लिखा था । लेकिन उस गणितज्ञ कोड की पहली पंक्ति वास्तव में लगभग 28,000 वर्णों की लंबी है और स्वयं निम्नलिखित CJam कोड द्वारा उत्पन्न की गई थी:
'{o
q~]{-1:W;
2b200Te[W%2/{W):W;~\{
"{"W+","W)++",\">\"}"+
"{"W)+","W++",\"<\"}"+
@
}*{
"{"W+","WA+++",\"v\"}"+
"{"WA++","W++",\"^\"}"+
}*}%", "*"Labeled[DirectedEdge[#,#2],#3]&@@@{ }"S/\*
]o',oNoNo}/'}
(इंटरप्रेटर में 10 लेआउट हार्डकोड के इनपुट के रूप में लिया जाता है। आप कोड को ऑनलाइन चला सकते हैं। )
कोड पीढ़ी-धारणा!
एक शुरुआत के लिए, इस सीजेएम स्क्रिप्ट पर एक नज़र डालें कि माज़े कैसा दिखता है।
मेरा समाधान एक महत्वपूर्ण अवलोकन पर आधारित है: जब तक हम एक एकल कॉलम के साथ आइटम उठाते हैं, हम लेआउट के बीच नहीं बदलेंगे, भले ही कोशिकाएं भरी हों या नहीं। विशेष रूप से, जब तक हम लेफ्ट-मोस्ट कॉलम के साथ आगे बढ़ते हैं, हम लेआउट में बने रहेंगे 0। जब तक हम अगले कॉलम के साथ आगे बढ़ते हैं, हम लेआउट में बने रहेंगे 1।
मुश्किल बिट यह है कि यह सुनिश्चित करने के लिए कि हमने लेआउट के बीच बदल दिया है , क्योंकि हम नहीं जानते हैं कि कॉलम में कौन से सेल में 1आइटम हैं (यदि कोई हो!)।
तो यहाँ एल्गोरिथ्म ( 0लेआउट में सेल पर शुरू 0) है:
अब प्रत्येक स्तंभ के लिए वर्तमान स्तंभ के दाईं ओर (स्तंभ-प्रमुख क्रम में उन्हें आज़माकर), वर्तमान लेआउट में वहां जाने का प्रयास करें, वहां एक आइटम उठाएं, फिर नए लेआउट का उपयोग करके उस नए कॉलम में शीर्ष पंक्ति पर जाएं।
यदि प्रयास किए गए सेल में एक आइटम होता है, तो लेआउट बदल जाएगा और हम सफलतापूर्वक नए कॉलम और लेआउट तक पहुंच जाएंगे। क्योंकि नई (सुरक्षित) स्थिति शीर्ष पंक्ति में है, लेकिन अगले कॉलम को खोजने के सभी प्रयासों में 10 शुद्ध उर्ध्व चाल शामिल हैं, अन्य सभी प्रयास विफल होंगे, इसलिए हम उन्हें अनदेखा कर सकते हैं।
यदि प्रयास किए गए सेल में कोई आइटम नहीं था, तो ज्यादातर मामलों में, मिनियन गलत लेआउट का उपयोग करके शीर्ष पंक्ति तक पहुंचने के प्रयास के दौरान मर जाएगा, इसलिए इस प्रयास को छोड़ देना चाहिए। हालांकि, यह मामला हमेशा नहीं होता है। उदाहरण के लिए, कोशिश की गई सेल पहले से ही शीर्ष पंक्ति पर हो सकती है, इसलिए नए लेआउट पर कोई चाल नहीं चली। इसी तरह, कुछ मामलों में, कोशिश की गई सेल से शीर्ष पंक्ति तक का रास्ता दोनों लेआउट पर मान्य होने के लिए पर्याप्त है। मैंने उन सभी मामलों को एकत्र किया है जहाँ यह हाथ से एक मुद्दा है, और चाल का एक सेट निर्धारित किया है जो केवल नए लेआउट पर मान्य है (लेकिन जो लक्ष्य को सेल में वापस ले जाता है, इसलिए यह प्रभावी रूप से एक नो-ऑप है नए विन्यास)। प्रत्येक प्रयास के बाद जहां यह एक मुद्दा हो सकता है, मैं इस कदम का प्रदर्शन किसी भी minions को मारने के लिए करता हूं, जो नहीं किया था '
अब हम सफलतापूर्वक अगले कॉलम के शीर्ष पर चले गए हैं जिसमें कम से कम एक आइटम है। चरण 1 पर वापस जाएं।
आप देख सकते हैं कि समाधान की संरचना इस प्रकार है:
Line with 10 "c"s
90 lines with 1 "c"
Line with 10 "c"s
80 lines with 1 "c"
Line with 10 "c"s
70 lines with 1 "c"
Line with 10 "c"s
60 lines with 1 "c"
...
Line with 10 "c"s
10 lines with 1 "c"
Line with 10 "c"s
मैथेमेटिका कोड के लिए, safetyCheckस्ट्रिंग्स उन हाथों से उठाए गए कदम हैं जो यह सुनिश्चित करते हैं कि हम नए लेआउट में पहुंच गए हैं। लुकअप का पहला पैरामीटर वह लेआउट है जिसे हम शुरू कर रहे हैं और दूसरा वह सेल है जिसे हमने प्रयास किया है। जिन संयोजनों का उल्लेख नहीं किया गया है, वे केवल एक खाली सुरक्षा जांच देते हैं (क्योंकि कोई भी आवश्यक नहीं है)।
उसके अलावा, मैं बस 10 mazes को Graphऑब्जेक्ट्स के रूप में स्थापित कर रहा हूं , जहां किसी भी आसन्न (और जुड़े) कोशिकाओं के बीच दो निर्देशित किनारे हैं, जहां प्रत्येक किनारे को किनारे से पार करने के लिए आवश्यक चाल के साथ एनोटेट किया गया है। उस जगह के साथ, मैं बस का उपयोग कर पथ पा सकते हैं FindShortestPathऔर फिर के साथ इसी किनारे लेबल निकाल सकते हैं PropertyValue[..., EdgeLabels]।
बाकी कोड केवल उपरोक्त एल्गोरिथ्म को सीधे लागू करने के लिए इसका उपयोग करता है।
वास्तविक ग्राफ डेटा को layoutsCJam स्क्रिप्ट के साथ संग्रहित किया गया था, जो पुलिस पोस्ट में वर्णित संख्याओं को डिकोड करता है और उन्हें एक गणितीय सूची में बदल देता है, जिसे आसानी से एक ग्राफ में बदला जा सकता है।
कोड:
#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))#(#(!(-)(#(-)()))())(*!(-)(#(-)()))#(*#(!(-)(#(-)()))()!(-)(-)#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(#(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))!(-)(#(-)()))#(!(-)(#(-)()))())(!(#(!(-)(#(-)())*#(!(-)(#(-)()))())(!(-)(#(-)()))!(-)(#(-)()))(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(-)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))()))))#(!(-)(#(-)()))())#(!(-)(#(-)()))())))#(!(-)(#(-)()))())!(-)(#(-)()))#(#(!(-)(#(-)()))())(*!(-)(#(-)())))(#(*)())#(!(-)(#(-)()))())(!(-)(#(-)()))!($)(!(!(-)(#(-)())#(!(-)(#(-)()))())(!(!(-)(#(-)())#(!(-)(#(-)()))())(#(*)()#(!(-)(#(-)()))())))!(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)(#(#(*#(!(-)(#(-)()))())(!(-)(#(-)()))-)())#(!(-)(#(-)()))()
सबसे पहले ... कोड उत्पन्न किया गया था, हाथ से लिखा (या टाइप नहीं)।
भाषा के बारे में तथ्य:
कार्यक्रम निम्नलिखित psuedocode का उपयोग करता है:
global item
global list = input()
biggest()
remove()
biggest()
remove()
biggest()
print()
def remove():
while item != list[0]:
rotate_list
list.remove(0)
def print():
rotate_list until item == list[0]
do until no change:
list.pop()
subtract
removeList()
def biggest():
item = 0
while hasListWithElements():
if item < list1[0]:
item = list1[0]
list.remove(0)
restore listपर्यावरण में लगभग हमेशा केवल 1 सूची और 1 पूर्णांक होता है।
इसे हल करने के लिए, मैंने इस भाषा के लिए एक छोटा मैक्रो इंजन बनाया। यह टिप्पणियों की भी अनुमति देता है। यहाँ मैक्रो इंजन है:
import sys
code = {}
filename = sys.argv[1]
f = open(filename, 'r')
prog = f.read()
f.close()
def c(prog):
for n in prog.splitlines():
if n.startswith('def'):
parts = n[4:].split(' ', 2)
code[parts[0]] = int(parts[1]) ,parts[2]
prog = prog.replace(n, '', 1)
elif n.strip().startswith('//'):
prog = prog.replace(n, '', 1)
return compile(prog)
def compile(prog):
ret = ''
while prog:
n = prog[0]
if n == '<':
name = prog[1:prog.find('>')]
args_count, formatter = code[name]
if args_count == 0:
prog = prog[prog.find('>') + 1:]
ret += compile(formatter)[0]
continue;
prog = prog[prog.find('>') + 2:]
args = []
for n in range(args_count):
arg, prog = compile(prog)
if n == args_count - 1:
arg = arg[:-1]
args.append(arg)
ret += compile(formatter.format(*args))[0]
elif n == ')':
return ret + ')', prog[1:]
elif n == ',':
return ret, prog[1:]
elif n == '(':
c, prog = compile(prog[1:])
ret += '(' + c
else:
ret += n
prog = prog[1:]
return ret.replace('\n','').replace(' ',''), prog
print(c(prog)[0]) #Use pipes to put into file.मैक्रो इंजन का निर्माण करने के बाद, मैंने धीरे-धीरे इस भाषा के लिए उपयोगी कार्यों का निर्माण किया। यहाँ कोड है कि इंजन कार्यक्रम बनाने के लिए संसाधित किया गया है:
//While loop
def w 2 !({1})({0})
//Detects changes
def c 1 #({0})()
//Do while it changes:
def wc 1 <w>(<c>({0}), {0})
//Remove all items:
def rint 0 <wc>(-)
//Contains list:
def clist 0 <rint>
//Remove all lists:
def rlist 0 #(<rint>)()
//Contains item:
def cint 0 <rlist>
//False (empty environment):
def false 0 <rint><rlist>
//Not:
def not 1 !(<false>)({0})
//Bool (if expression does not evaluate to an empty environment,
// restore the environment to its previous state.
def bool 1 <not>(<not>({0}))
//And
def and 2 <bool>({0}){1}
//Or
def or 2 <not>(<and>(<not>({0}), <not>({1})))
//Combine parts (takes the integer parts of first argument and
//combines them with the list parts of second argument):
def p 2 #({0}<rlist>)({1}<rint>)
//If, executes an expression if condition evalutates to true. Only works in standard environment.
def if 2 <p>(!({1}<rlist>)(<and>({0}, <rint>)),!({1}<rint>)(<and>({0}, <rlist>)))
//equal (compares item to list[0]) for equality:
def eq 0 <not>(#(*)()<rlist>)
//list.remove(0), does not change item:
def listr 0 <p>(, *)
//remove, removes item from list, goes into infinite loop if list does not contain item.
def remove 0 <w>(<not>(<eq>), $)<listr>
//Greater than or equal, item >= list[0]:
def ge 0 <w>(<and>(<not>(<eq>), <rlist>), -)<rlist>
//Less than, item < list[0]:
def lt 0 <not>(<ge>)
//Zero, sets item to zero:
def zero 0 <p>(*<rlist>!(-)(-), )
//Biggest, puts biggest item in the list into item:
def biggest 0 <zero><p>(<w>(<c>(*), <if>(<lt>, <p>(<rint>*, ))<listr>), )
//print item, item must be somewhere on list.
def print 0 <w>(<not>(<eq>), $)<wc>(<p>(*, )-)<rlist>
//The actual program!!!!
<biggest>
<remove>
<biggest>
<remove>
<biggest>
<print>निम्नलिखित पायथन 2.7 प्रोग्राम मेरे ब्रायन और चक प्रोग्राम को आउटपुट करता है, ब्रायन एंड चक में एक ब्रेनफक प्रोग्राम का अनुवाद करके ( .हमेशा अपवाद के साथ 1, क्योंकि यह एकमात्र ऐसा चरित्र है जिसे हमें आउटपुट की आवश्यकता है)।
ब्रायन कोड में सही स्थिति में ब्रायन को भेजने के लिए ब्रायन को चक के टेप कमांड पर लिखने के जादू से नियंत्रण प्रवाह काम करता है ।
ध्यान दें कि व्हाट्सएप और []बी एंड सी प्रोग्राम में जोड़े गए सजावटी हैं।
def brainfuck_to_brianchuck(code):
# find biggest jump needed
biggest_jump = 0
idx = 0
while idx < len(code):
if code[idx] == '[':
end = matching_bracket(code,idx)
jump = sum(c == '[' for c in code[idx:end])
if jump > biggest_jump:
biggest_jump = jump
idx = end
idx += 1
block_size = biggest_jump*4 + 4
fragments = []
depth = 0
for idx,c in enumerate(code):
if c in '<>':
fragments.append(block_size*c)
elif c == '[':
end = matching_bracket(code,idx)
jump = sum(c == '[' for c in code[idx:end])
fragments.append('\n' + ' '*depth)
fragments.append('[ ' + open_while(jump))
depth += 1
fragments.append('\n' + ' '*depth)
elif c == ']':
start = matching_bracket(code,idx)
jump = sum(c == '[' for c in code[start:idx])
depth -= 1
fragments.append('\n' + ' '*depth)
fragments.append('] ' + close_while(jump))
fragments.append('\n' + ' '*depth)
elif c == '.':
fragments.append('>' + write('0>.?',True) + '<<<?1<<<' + write('0>.?',False) + '<<<<')
elif c in ',+-':
fragments.append(c)
return ''.join(fragments) + '\n```'
def open_while(jump):
fragments = []
right = '0' + '}>}>'*jump + '?'
fragments.append('>' + write(right,True))
r = len(right)-1
fragments.append('<'*r + '?' + '_0')
left = '{<{<'*jump + '>>?'
l = len(left)-1
fragments.append('<'*l)
fragments.append(write(left,False))
fragments.append('<'*l + '<')
return ''.join(fragments)
def close_while(jump):
fragments = []
right = '0' + '}>}>'*jump + '?'
fragments.append('>' + write(right,True))
r = len(right)-1
fragments.append('_0' + '<'*r)
fragments.append(write(right,False))
fragments.append('<'*r)
left = '{<{<'*jump + '>>?'
l = len(left)-1
fragments.append(write(left,True))
fragments.append('<'*l + '<' + '?>')
fragments.append(write(left,False))
fragments.append('<'*l + '<')
return ''.join(fragments)
# returns the code to write s, or erase it if increment is False
def write(s,increment):
c = '+' if increment else '-'
return '>'.join(c*ord(a) for a in s)
def matching_bracket(code, idx):
bracket = code[idx]
other_bracket = ']' if bracket == '[' else '['
direction = 1 if bracket == '[' else -1
idx += direction
while code[idx] != other_bracket:
if code[idx] == bracket:
idx = matching_bracket(code, idx)
idx += direction
return idx
print brainfuck_to_brianchuck('''
-
>,------------------------------------------------[
,------------------------------------------------[
->+>>>[>+<<<<->>>-]<[>+<<<->>-]<[>+<<->-]>>>[<+>-]<<<<[>+<-]
>>>>>,------------------------------------------------
]
<+[-<<<<<<+]-
>,------------------------------------------------
]
>>>>[.>>>>>>].
''')कार्य, टिप्पणी कोड:
_ Beginning of the loop where one iteration reads one unary number.
- Decrement to cancel the next +, which is part of the loop.
+ Increment... this is executed once for each 1 we read.
, Read a character.
^ "eval"
# Negate.
* Double three times to get -8 if we read a 1 and 0 otherwise.
*
*
% If we read a 1, jump back to the +. Otherwise, continue.
# Negate the resulting number to reverse the sort order later.
` Duplicate...
~ Logical NOT twice, to turn non-zero results into 1 (zeroes remain zeroes).
~
* Double, double, square, double, negate, to get -32 if the last number
* we read was non-zero. The double-0 at the end of the input leads to a
| zero being read as a unary number, which we use as the termination
* condition. When this is the case, the current cell will be 0 instead
# of -32. The next lines are padding to get the jump right...
% So... if the unary number was not 0, jump back to the _.
\ Sort the list... the sort is descending, but we negated all the values...
< That means the largest value next to the pointer now, just with a minus
< sign. We move to the left three times to find the place where the third
< largest value is.
# Negate to get its positive value again.
` Duplicate to ensure we've got a cell to the left of the result.
< Move left to the other copy.
~ Logical NOT twice, to turn it into a 1.
~
> Move right to the result.
! This moves the pointer to the left (onto the 1) and executes "." (print)
. "result" times, printing the result in unary. Yay!
यह दुभाषिया पर निर्भर करता है जैसा कि वर्तमान में पुलिस के जवाब में प्रदान किया गया है, जो दस्तावेज के संबंध में थोड़ा विरोधाभास करता है %और !।
यहाँ मुख्य चुनौती इनपुट पार्स कर रही थी, क्योंकि \तीसरा सबसे बड़ा मूल्य खोजने के लिए काफी सरल है।
इस लैंग्वेज में भयानक तुलनात्मक समर्थन है।
Count b while 0 {
}
Count c while 0 {
}
Count a while N-48 {
Count q while N-48 {
}
Count a while _ {
_ - 1
}
a - (q + 1)
Count z while (z-(10^6+1)) * (_ - z) {
}
Count x while (_ - z) {
b
Count c while _ {
_ - 1
}
a
Count b while _ {
_ - 1
}
q
Count a while _ {
_ - 1
}
z
}
z-((10^6)+1)
Count x while _ {
b - (q + 1)
Count f while (f-(10^6+1)) * (_ - f) {
}
Count x while (_ - f) {
b
Count c while _ {
_ - 1
}
q
Count b while _ {
_ - 1
}
f
}
f-((10^6)+1)
Count x while _ {
c - (q + 1)
Count k while (k-(10^6+1)) * (_ - k) {
}
Count x while (_ - k) {
q
Count c while _ {
_ - 1
}
k
}
0
}
0
}
0
Count j while (a - _) {
_ + 1
}
}
c
Write 49
Count h while _ {
Write 49
_ - 1
}
count [varname] while 0शुरुआत में बयान चर सबसे बड़ी संख्या, दूसरी सबसे बड़ी संख्या है, तीसरा सबसे बड़ा संख्या, और इतने पर पकड़े घोषित करने के लिए कर रहे हैं। तुलनाओं को दो संख्याओं को घटाकर पूरा किया जाता है, फिर यह जाँच कर कि यदि परिणाम एक संख्या कम है, तो जाँचकर परिणाम नकारात्मक है 10^6।
यह इतना कठिन नहीं था, एक बार मैं समझ गया कि भाषा कैसे काम करती है। कठिन हिस्सा हालांकि पार्सर त्रुटियों को प्राप्त करना था, लेकिन कुछ अति सुंदर कोष्ठकों को जोड़ने से यह तय हो गया। यहाँ समाधान है:
let
+=cut
in {d:{c:({b:{a:S^((#S)-_)-1}^_})+0$#c}^_=2}
पहली और दूसरी पंक्तियों में, मैं ऑपरेशन +होने को परिभाषित करता हूं cut। बाकी की समझ है। आइए इनपुट 101011101100को एक उदाहरण के रूप में लेते हैं , और अंतरतम एक से शुरू करते हैं:
{a:S^((#S)-_)-1}
यह उन तत्वों aको इनपुट सेट से लेता है S = {1,0,1,0,1,1,1,0,1,1,0,0}जिनके सूचकांक नहीं है len(S)-1, इसलिए सभी लेकिन अंतिम एक। मैंने देखा कि यह सेट को उलट भी देता है, इसलिए इसका परिणाम है A = {0,1,1,0,1,1,1,0,1,0,1}। अगला, समझ
{b:A^_}
Aपहले को छोड़कर सभी तत्व लेता है और इसे फिर से उलट देता है, जिसके परिणामस्वरूप B = {1,0,1,0,1,1,1,0,1,1}। फिर, हम s Bपर विभाजित होते हैं 0(इसके परिणाम {1,1,{1,1,1},{1,1}}या इसके उलट होने पर, मैंने जांच नहीं की कि कौन सा है), और परिणाम को लंबाई के अनुसार क्रमबद्ध करें। सिंगलटन सेट चपटा हुआ है, लेकिन वे सभी 1एस हैं इसलिए उनकी लंबाई अभी भी है 1. यहां कोड है:
{c:(B)+0$#c}
इसी का परिणाम है C = {{1,1,1},{1,1},1,1}। अंत में, हम सूचकांक 2 पर तत्व को छोड़कर सब कुछ फ़िल्टर करते हैं
{d:C^_=2}
यह D = {1}हमारे मामले में सेट में परिणाम देता है । सामान्य तौर पर, इसका रूप हो सकता है {{1,1,..,1}}, लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि केवल 1एस मुद्रित हैं।
यह मजेदार था।
संपादित करें: इस कार्यक्रम को बीएमएसी के दुभाषिया पर काम करने के लिए एक नई लाइन के साथ तैयार किया जाना चाहिए। मुझे कोड ब्लॉक में प्रदर्शित होने के लिए नई लाइन नहीं मिल सकती है।
!p#eXj0sXj0sp#exj#ss
n Apw w n w
s w
s w s w s w s w e s
eXj0seXj0sn ep0Yp+yXj0nYp#exj+sneXp exj#seXj+snep+eXj#sxj+nseXp exj#ss
n w ej#ns e n n w e n n w n w
n w
s w
e s
y
s Yw
eXj+np yjCs C n
ejBs B pC n
e A pB n
ej0n 0 pA n
s w
e s
exj#s X eXj#nsejCsp1s
n w n w w
w
@>
#
कार्यक्रम को 4 निष्पादन वर्गों में विभाजित किया गया है।
पहला, पंक्ति 1 पर, #इनपुट 00को 2 के 0साथ खोजने और बदलने के द्वारा इनपुट के अंत में जोड़ता है #। यह सभी 1s को भी बदलता है A, क्योंकि मैं चाहता था 1कि स्रोत कोड में कुछ s संभव हो।
लाइन 5 पर दूसरा खंड, इनपुट में दूसरे नंबर को लाता है, और इसे +एस के एक स्ट्रिंग के रूप में पहले नंबर से नीचे रखता है । उदाहरण के लिए, यदि इनपुट है 11011101100, तो यह निम्नलिखित में परिणाम देगा:
#AA00000AA0#
#+++
तीसरे खंड, लाइन 12 पर, की स्ट्रिंग को जोड़ती +पहले नंबर के साथ: प्रत्येक 0एक से ऊपर +हो जाता है A, Aहो जाता है B, Bहो जाता है C, और Cअपरिवर्तित रहता है। बाद में, हम अगले नंबर लाने के लिए 2 सेक्शन में वापस जाते हैं।
एक बार जब सभी संख्याओं को इस तरह जोड़ दिया जाता है, तो हम अंतिम खंड पर पहुंचते हैं 18 पंक्ति में। Cs की संख्या हमारा वांछित आउटपुट है, इसलिए हम इन्हें बदलकर 1s पर लाते हैं, पहले को छोड़ते हुए Cक्योंकि 1स्रोत कोड में एक ही है जो साथ में छपा है आउटपुट के साथ।