संयोजन बाइक लॉक

Question

परिदृश्य

दफ्तर में बहुत दिन तक काम करने और ढेर होने के बाद stackexchange.com , मैं अंत में 16:58 पर दरवाजे से बाहर निकलता हूं, पहले ही दिन से थके हुए। क्योंकि मैं अभी भी केवल एक प्रशिक्षु हूं, मेरे परिवहन का वर्तमान तरीका साइकिल पर है। मैं अपने भरोसेमंद प्यूज़ो रेनॉल्ड्स 501 को सौंपता हूं, लेकिन इससे पहले कि मैं इसे दूर कर सकूं, मुझे इसे अनलॉक करने की आवश्यकता है। लॉक एक मानक चार अंकों का संयोजन लॉक (0-9) है, फ्रेम और फ्रंट व्हील के माध्यम से। जैसा कि मैं जागने की कोशिश करता हूं, मैं संयोजन में प्रवेश करने के लिए अपना हाथ ऊपर खींचता हूं।

चुनौती

क्योंकि मेरी उंगलियां थकी हुई हैं, इसलिए मैं सबसे कम आंदोलनों के साथ लॉक को सही संयोजन में बदलना चाहता हूं। एक आंदोलन को एक स्थिति (36 डिग्री) द्वारा रोटेशन के रूप में परिभाषित किया जाता है, उदाहरण के लिए एक आंदोलन 5737है 5738। हालांकि, मैं एक ही समय में किसी भी तीन लगातार रिंगों को पकड़ सकता हूं , और उन्हें एक के रूप में घुमा सकता हूं , जो केवल एक ही आंदोलन के रूप में गिना जाता है। उदाहरण के लिए वहाँ से या करने के लिए केवल एक ही आंदोलन है । से चलती करने के लिए एक आंदोलन के रूप में अंक संख्या 1,2 और 4 एक ही दिशा में ले जाया गया है, लेकिन अंकों की संख्या 3 की स्वतंत्र रूप से नहीं है।57376837562657376838

इसलिए, किसी दिए गए संयोजन के लिए मैं बाइक लॉक (किसी भी 4-अंकीय पूर्णांक) पर देख सकता हूं, सबसे कम संख्या में आंदोलनों को मैं इसे अनलॉक करने के लिए क्या कर सकता हूं, और हां, मैं किसी भी समय किसी भी दिशा में घूम सकता हूं। इसके द्वारा मेरा मतलब है कि मैं कुछ अंकों को एक दिशा में और अन्य अंकों को दूसरी दिशा में बदल सकता हूं: मेरे सभी आंदोलनों में प्रत्येक अनलॉक के लिए एटलॉकवाइज या क्लॉकवाइज नहीं होगा।

क्योंकि मैं आलसी हूं, मेरा अनलॉक कोड 0000 है।

यह कोड गोल्फ है मुझे बहुत कोड लिखने से परेशान नहीं किया जा सकता है, इसलिए बाइट्स जीत की संख्या में सबसे छोटा कार्यक्रम।

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

उदाहरण

Input: 1210
0100
0000

Input: 9871
9870
0980
0090
0000

Input: 5555
4445&3335&2225&1115&0005&0006&0007&0008&0009&0000

Input: 1234
0124 0013 0002 0001 0000

मैंने इसे http://bicycles.stackexchange.com पर पोस्ट करने की कोशिश की , लेकिन उन्हें यह पसंद नहीं आया ...

डिस्क्लेमर: पहला गोल्फ, ऐसा कुछ भी जो टूटा हुआ है / कोई गुम सूचना है मुझे बताएं! इसके अलावा, मैंने सभी उदाहरणों को हाथ से किया था, इसलिए ऐसे समाधान हो सकते हैं जिनमें कम आंदोलनों का समावेश हो!

EDIT: उन उत्तरों के लिए जिनके पास समान संख्या में आंदोलनों के साथ कई समाधान पथ हैं (व्यावहारिक रूप से उनमें से सभी), कोई पसंदीदा समाधान नहीं है।

Comments

PPCG में आपका स्वागत है; बहुत अच्छी पहली चुनौती!

— दरवाज़े

यह मुझे ठोस लग रहा है! PPCG में आपका स्वागत है!

— Mego

अच्छी चुनौती है। क्या मैं पूछ सकता हूं कि मामलों के लिए आउटपुट क्या होना चाहिए: 7478 और 3737?

— शोरगुल 2

@ noisyass2 धन्यवाद; त्रुटिपूर्ण उत्तर निम्न देता है: 7478 8588 9698 0708 0808 0908 0008 0009 0000 और 3737 2627 1517 0407 0307 0207 0107 0007 0007 0008 0000 0000 बस 3737 को देखते हुए, यह समझ में आता है: केवल पहले 3 अंकों को देखते हुए: यदि मैं सभी को स्थानांतरित करता हूं एक ही समय में पहले तीन, यह अंक 1 और 3 के लिए 3 आंदोलनों लेता है, और फिर अंक 2 के लिए एक और 4 आंदोलनों, इस प्रकार कुल सात। जबकि अगर मैं प्रत्येक को व्यक्तिगत रूप से स्थानांतरित करता हूं, तो प्रत्येक 3 चाल लेता है, इस प्रकार 9 आंदोलनों।

— लुइ

मैं सोच रहा हूं कि क्या शीर्षक "कॉम्बिनेशन लॉक" (या "बाइक लॉक") अधिक दर्शकों को आकर्षित कर सकता है।

— डेविड जेएन

Answer 1

मतलाब, 412 327 बाइट्स

गोल्फ (गोल्फ के लिए @AndrasDeak के लिए धन्यवाद s!):

s=dec2bin('iecbmgdoh'.'-97)-48;s=[s;-s];T=1e4;D=Inf(1,T);P=D;I=NaN(T,4);for i=1:T;I(i,:)=sprintf('%04d',i-1)-'0';end;G=input('');D(G+1)=0;for k=0:12;for n=find(D==k);for i=1:18;m=1+mod(I(n,:)+s(i,:),10)*10.^(3:-1:0)';if D(m)==Inf;D(m)=k+1;P(m)=n-1;end;end;end;end;n=0;X='0000';while n-G;n=P(n+1);X=[I(n+1,:)+48;X];end;disp(X)

यह कोड दिए गए नंबर से कम से कम 'पथ' खोजने के लिए कुछ गतिशील प्रोग्रामिंग का 0000उपयोग करता है केवल संभव चरणों का उपयोग करने के लिए । यह चुनौती मूल रूप से सबसे छोटा रास्ता है, जब आप वैकल्पिक रूप से कदमों को एक कम्यूटेटव समूह के रूप में समझ सकते हैं।) लेकिन कठिनाई एक कुशल कार्यान्वयन के साथ आ रही थी । बुनियादी संरचनाएं दो 10000-तत्व सरणियां हैं, एक उस सूचकांक को प्राप्त करने के लिए चरणों की संख्या को संग्रहीत करने के लिए, दूसरा हमारे ग्राफ में पिछले 'नोड' के लिए एक पॉइंटर को स्टोर करने के लिए। यह एक साथ सभी अन्य संभावित संख्याओं के लिए 'पथ' की गणना करता है।

उदाहरण:

9871
0981
0091
0001
0000

1210
0100
0000

Examples by @noisyass:

7478
8578
9678
0788
0899
0900
0000

3737
2627
1517
0407
0307
0207
0107
0007
0008
0009
0000

Own Example (longest sequence, shared with 6284)

4826
3826
2826
1826
0826
0926
0026
0015
0004
0003
0002
0001
0000    

पूर्ण कोड (कुछ टिप्पणियों को सम्मिलित करना):

%steps
s=[eye(4);1,1,0,0;0,1,1,0;0,0,1,1;1,1,1,0;0,1,1,1];
s=[s;-s];


D=NaN(1,10000);%D(n+1) = number of steps to get to n
P=NaN(1,10000);%P(n+1) was last one before n

I=NaN(10000,4);%integer representation as array
for i=0:9999; 
    I(i+1,:)=sprintf('%04d',i)-'0';
end

G=9871; % define the current number (for the golfed version replaced with input('');
D(G+1)=0;
B=10.^(3:-1:0); %base for each digit

for k=0:100; %upper bound on number of steps;
    L=find(D==k)-1;
    for n=L; %iterate all new steps
        for i=1:18; %search all new steps
            m=sum(mod(I(n+1,:)+s(i,:),10) .* [1000,100,10,1]);
            if isnan(D(m+1))
                D(m+1) = k+1;
                P(m+1)=n;
            end
        end
    end
end
n=0;%we start here
X=[];
while n~=G
    X=[I(n+1,:)+'0';X];
    n=P(n+1);
end
disp([I(G+1,:)+'0';X,''])

Comments

अच्छा! ज्यादातर मैटलैब यूजर होने के नाते मैं सोच रहा था कि यह कितना अच्छा होगा।

— लुइ

इनपुट के लिए 6444आपका कोड 6444 7554 8664 9774 0884 0994 0004 0003 0002 0001 0000 है, जबकि मुझे 6444 6333 6222 6111 6000 7000 8000 9000 000000 का उत्तर मिलता है। मेरा उत्तर 8 चरणों का है, आपका 10. है मैं नहीं देख सकता। मुद्दा, और यह वहाँ दोनों गोल्फ और ungolfed संस्करण में प्रतीत होता है। यह आपके नवीनतम संपादन में तय किया गया है।

— लूई

मैंने कोड में एक छोटी सी त्रुटि को ठीक किया। में sअंतिम पंक्ति होना चाहिए [0,1,1,1]। फिर आपको एक 8 कदम समाधान भी मिलता है! मैं असुविधा के लिए माफी चाहता हूं =)

— दोष

@Lui एक मैटलैब / ऑक्टेव चैटरूम है, अन्य सामानों के बीच यह मैटलैब-व्युत्पन्न गोल्फिंग अप्सैल MATL के लिए कुछ प्रकार का बेस है।

— दोष

4826 के लिए, मुझे 11 चाल का हल मिला: 4826 3716 2606 1506 0406 0306 0206 0106 0007 0008 0009 0000

— noisyass2

Answer 2

बैच - 288 बाइट्स

यहां तक ​​कि अगर आपने कहा कि उन्हें लगातार (रिंग्स) होना है, तो मैं तर्क से (उदाहरण के बाद) मान लेता हूं कि मैं बीच में से एक को छोड़ सकता हूं, जैसे 1234कि 0224।

सेट / px =
सेट ए =% x: ~ ०,१% और सेट बी =% x: ~ ११% और सेट सी =% x: ~ २.१% और सेट डी =% x: ~ ३,१%
: एल
@echo% x% और यदि% a% == 0 (यदि% d% NEQ 0 सेट / विज्ञापन = d-१) और सेट / आ = एक -१
@if% b% NEQ 0 सेट / ab = b-1
@if% c% NEQ 0 सेट / एसी = सी -1
@if% x% NEQ 0000 सेट x =% a %% b %% c %% d% & goto l

यह मेरा बैच समाधान है: 236 बाइट्स।

---

संपादित करें: सही समाधान

सेट / px =
सेट ए =% x: ~ ०,१% और सेट बी =% x: ~ ११% और सेट सी =% x: ~ २.१% और सेट डी =% x: ~ ३,१%
: एल
@echo% x% & set k = 1 & if% a% == 0 (यदि% d% NEQ 0 सेट / विज्ञापन = d-१ और सेट k = ०) और सेट / आ = a-१ & सेट k = १
@if% b% NEQ 0 यदि% k% == १ सेट / एब = बी -१ और सेट के = ०
@ अगर% c% NEQ 0 यदि% k% == ० सेट / एसी = सी -१
@if% x% NEQ 0000 सेट x =% a %% b %% c %% d% & goto l

नया समाधान (अंतर्निहित टिप्पणियों के अनुसार तय किया गया) 288 बाइट्स भारी है।

Comments

मैंने आपके उत्तर को बहुत गहराई से नहीं देखा है, लेकिन मैं पहले पैराग्राफ में आपके तर्क का पालन करने के लिए संघर्ष कर रहा हूं। आप किस उदाहरण का विशेष रूप से उल्लेख कर रहे हैं? और से जाने के अपने उदाहरण 1234के लिए 0224है नहीं एक आंदोलन। विचार यह है कि केवल दो उंगलियों का उपयोग करके मैं एक ही पकड़ के साथ लगातार तीन रिंगों को समझ सकता हूं।

— लुइ

मेरा मतलब था, यदि आप लगातार 3 रिंग ले जा सकते हैं, तो यह सोचना उचित है कि आप पहले और तीसरे को भी स्थानांतरित कर सकते हैं, दूसरे को टाल सकते हैं। या मुझे अपना कोड बदलना चाहिए?

— noize

आपकी धारणा गलत है; आपको अपना कोड बदलना चाहिए। क्या आप उक्त टिप्पणी में बताए गए तर्क को देखते हैं?

— लुइ

कोड तय किया। मैंने कई अलग-अलग प्रकार के संयोजनों के साथ जाँच की और यह मुझे ऐसा लगता है जैसे यह हमेशा छोटा रास्ता लेता है।

— noize

ऐसा लगता है कि यह केवल नीचे की ओर गिना जाता है, इसलिए उच्च संख्या के साथ संयोजन के लिए आवश्यक से अधिक समय लगता है (उदाहरण के लिए 9999 के लिए 18 चाल)

— faubi

Answer 3

हास्केल - 310 बाइट्स

import Data.Char
import Data.List
r=replicate
h=head
a x=map(:x)[map(`mod`10)$zipWith(+)(h x)((r n 0)++(r(4-j)q)++(r(j-n)0))|j<-[1..3],n<-[0..j],q<-[1,-1]]
x!y=h x==h y
x#[]=(nubBy(!)$x>>=a)#(filter(![(r 4 0)])x)
x#y=unlines.tail.reverse.map(intToDigit<$>)$h y
main=do x<-getLine;putStrLn$[[digitToInt<$>x]]#[]

जब तक उनमें से एक सही संयोजन नहीं हो जाता तब तक प्रत्येक संयोजन के लिए हर संभव मोड़ को लागू करके संयोजनों की एक नई सूची को बार-बार बनाने से यह काम करता है। स्मृति के उपयोग को तेजी से बढ़ने से रखने के लिए प्रत्येक पुनरावृत्ति पर सूची से डुप्लिकेट हटा दिए जाते हैं।

एक जानवर बल समाधान के रूप में, यह बहुत अक्षम है और इसे चलाने में कई मिनट लग सकते हैं।

हास्केल के साथ मुझे ज्यादा अनुभव नहीं है, इसलिए कुछ बात शायद बेहतर तरीके से की जा सकती है।

Comments

आपके दृष्टिकोण के लिए एक ठोस आधार की तरह लगता है। मैंने हास्केल के साथ अनुभव नहीं किया है, न ही (मुझे पता है कि) इसे संकलित / चलाने का कोई साधन है। एक त्वरित Google मुझे कहीं भी नहीं देता है मैं इसे या तो कोशिश कर सकता हूं। क्या आप एक लिंक देने में सक्षम हैं जो मुझे इसे आज़माने की अनुमति देता है? धन्यवाद।

— लुइ

@Lui इसे ग्लासगो हास्केल कंपाइलर के साथ संकलित किया जा सकता है , लेकिन डाउनलोड करने और उपयोग करने के अलावा मुझे इसे चलाने का कोई तरीका नहीं पता है।

— फ़ूबी १३'१६