सप्ताह के लिए चौथा ग्रेड गणित का होमवर्क: एक सबसे अक्षम यात्रा विक्रेता

Question

मेरी बेटी ने अपने गणित के होमवर्क के लिए निम्नलिखित कार्य किया था। एक लाइन पर रहने वाले छह दोस्तों की कल्पना करें, जिनका नाम E, F, G, H, J और K है। लाइन पर उनकी स्थिति नीचे बताई गई है (स्केल नहीं)।

इस प्रकार, एफ ई से पांच इकाइयाँ, और दो इकाइयाँ G से और इसी तरह आगे रहता है।

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

Comments

यह बेहतर एक प्रोग्राम है जो लेता है इनपुट के रूप में हो सकता है (उदा। [0, 5, 7, 13, 16, 17]और 62) ताकि आप यकीन है कि यह नहीं विशेष रूप से इस मामले को हार्ड-कोडेड बना सकते हैं।

— दरवाज़े

@Doorknob, अच्छी बात है। मैंने अपने अनुसार असाइनमेंट एडजस्ट कर लिया है।

— माइकल स्टर्न

क्या रास्ते की शुरुआत किसी दोस्त से होती है?

— xnor

क्या मैं इनपुट और आउटपुट स्ट्रिंग्स के प्रारूप को परिभाषित कर सकता हूं? क्या इनपुट जैसा है "[0, 5, 7, 13, 16, 17], 62"और आउटपुट "(7, 16, 0, 17, 5, 13)"ठीक है?

— लॉजिक नाइट

@Geobits मेरी ओर से सिर्फ फूहड़पन। सही किया।

— माइकल स्टर्न

Answer 1

जे, 54 बाइट्स

आउटपुट एक सही मार्ग है। यदि कोई मार्ग मौजूद नहीं है तो यह कुछ भी नहीं उत्पन्न करता है।

   f=.4 :'{.(x=+/|:2|@-/\"#.s A.y)#(s=.i.!6)A.''EFGHJK'''

   62 f 0 5 7 13 16 17
GJEKFH

52-बाइट कोड जो सभी मार्गों (एक प्रति पंक्ति) को आउटपुट करता है:

f=.4 :'(x=+/|:2|@-/\"#.s A.y)#(s=.i.!6)A.''EFGHJK'''

38-बाइट कोड जो अक्षरों के बजाय पदों को आउटपुट करता है:

f=.4 :'p#~x=+/|:2|@-/\"#.p=.(i.!6)A.y'

Comments

मैं कोड को वेट नहीं कर सकता, लेकिन आपके सारांश के अनुसार, यह सबसे छोटी प्रविष्टि प्रतीत होती है, जिसमें समस्या के लिए आवश्यक सभी चीजें हैं।

— माइकल स्टर्न

Answer 2

गणितज्ञ, 55 या 90 बाइट्स

गणितज्ञ आपने कहा? ;)

FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&

यह एक अनाम फ़ंक्शन है जो पहले दोस्तों (किसी भी क्रम में) की स्थिति लेता है, और फिर लक्ष्य की लंबाई। यह लौटता है Missing[NotFound], अगर ऐसा कोई रास्ता मौजूद नहीं है।

FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&[{0, 5, 7, 13, 16, 17}, 62]
(* {7, 16, 0, 17, 5, 13} *)

मैं चार बाइट्स बचा सकता हूं अगर सभी वैध रास्तों को वापस करने की अनुमति है ( FirstCase-> Cases)।

स्ट्रिंग्स की एक सरणी लौटना थोड़ा अधिक बोझिल है:

FromCharacterCode[68+#]&/@Ordering@FirstCase[Permutations@#,p_/;Tr@Abs@Differences@p==#2]&

Comments

क्या आप समायोजित कर सकते हैं ताकि यह केवल स्थानों के बजाय अक्षरों के साथ प्रतिक्रिया करे?

— माइकल स्टर्न

@ मिचेल स्टर्न यह सवाल वास्तव में स्पष्ट नहीं है कि कितना हार्डकोड किया जाना चाहिए और मापदंडों का कितना हिस्सा होना चाहिए? क्या इनपुट को अक्षरों से पदों तक मैपिंग की तरह होना चाहिए?

— मार्टिन एंडर

मान लें कि अक्षर हमेशा संख्या रेखा में दिए गए क्रम में हैं (ई, एफ, जी, एच, जे, के)। उन दोनों के बीच की दूरी को फ़ंक्शन में पास किया जाना चाहिए जैसा कि आप अपने समाधान में करते हैं।

— माइकल स्टर्न

@MichaelStern मैंने एक ऐसा संस्करण जोड़ा है जो स्ट्रिंग की एक सरणी देता है। यह सूची में किसी भी स्थिति का समर्थन करता है, लेकिन बाद Zमें अगले ASCII वर्णों के साथ जारी रहेगा (ऐसा नहीं है कि आप मेरे कोड को n> 20 के लिए वैसे भी चलाना चाहते हैं: D)।

— मार्टिन एंडर

Answer 3

पायथन 2, 154 148 बाइट्स

(या सामान्य समाधान के लिए 118 बाइट्स)

यह कार्यक्रम स्टैण्ड पर एक सूची और पूर्णांक जैसे '[0, 5, 7, 13, 16, 17], n' को स्वीकार करता है और लंबाई n के उत्पादन पर एक पथ प्रिंट करता है या यदि असंभव हो तो कुछ भी नहीं।

# echo "[0, 5, 7, 13, 16, 17], 62" | python soln.py 
['G', 'J', 'E', 'K', 'F', 'H']

पायथन में छोटे कार्यक्रमों को लिखना चुनौतीपूर्ण है, जिन्हें क्रमपरिवर्तन की आवश्यकता होती है। यह आयात और उपयोग बहुत महंगा है।

from itertools import*
a,c=input()
for b in permutations(a):
 if sum(abs(p-q)for p,q in zip(b[1:],b))==c:print['EFGHJK'[a.index(n)]for n in b];break

मिनिस्टर से पहले ओपी आवश्यकता के लिए स्रोत:

from itertools import*

puzzle, goal = input()
for option in permutations(puzzle):
    if sum(abs(p-q) for p,q in zip(option[1:], option)) == goal :
        print ['EFGHJK'[puzzle.index(n)] for n in option];
        break

सामान्य समाधान (छोटा नहीं):

from itertools import*

puzzle, goal = input()
for option in permutations(puzzle):
    if sum(abs(p-q) for p,q in zip(option[1:], option)) == goal :
        print option;
        break

सरल एल्गोरिथ्म और संयोजनों की विशाल संख्या के कारण, 20 से अधिक प्रारंभिक पदों के लिए निष्पादन बहुत धीमी गति से होगा।

Comments

आप के साथ कुछ बाइट्स बचा सकता है from itertools import*। इसके अलावा, पायथन 3 के साथ कम हो सकता है input()और *a,c=map(...)अगर यह आपके बाकी कार्यक्रम के साथ काम कर सकता है।

— grc

आयात टिप के लिए धन्यवाद। मैं अपने कोड बेस के py3 इंस्टॉल और रूपांतरण का विरोध कर रहा हूं। मैं तब तक इंतजार कर रहा हूं जब तक कि मेरे द्वारा उपयोग किए जाने वाले हर तीसरे पक्ष के मॉड्यूल py3 के तहत उपलब्ध और स्थिर नहीं होते (मैं कई पुराने और अस्पष्ट उपयोग करता हूं)।

— लॉजिक नाइट

क्या आप समायोजित कर सकते हैं ताकि यह केवल स्थानों के बजाय अक्षरों के साथ प्रतिक्रिया करे?

— माइकल स्टर्न

chr(a.index(n)+69)?

— मार्टिन एंडर

अच्छा अनुकूलन। लेकिन मुझे लगता है कि @MichaelStern वास्तव में 'EFGHJK' देखना चाहता है, और यह काफी आसान था इसलिए मैंने इस तरह से कोड लिखा।

— लॉजिक नाइट

Answer 4

जे (48 या 65)

मैं परिकल्पना करता हूं कि यह एक बहुत अधिक का एक नर्क हो सकता है। इसे आगे बढ़ने के लिए जंपिंग पॉइंट के रूप में उपयोग करने के लिए स्वतंत्र महसूस करें

]A.~[:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#))))

या पत्रों के साथ:

([:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#)))))A.[:(a.{~65+[:i.#)]

यह क्या करता है:

   62 (]A.~[:I.(=([:([:+/}:([:|-)}.)"1(A.~([:i.[:!#))))) 0 5 7 13 16 17
 7 16  0 17  5 13
 7 16  5 17  0 13
 7 17  0 16  5 13
 7 17  5 16  0 13
13  0 16  5 17  7
13  0 17  5 16  7
13  5 16  0 17  7
13  5 17  0 16  7

(मुझे आशा है कि यह I / O प्रारूप ठीक है ...)

यह कैसे होता है:

(A.~([:i.[:!#))

इनपुट के सभी क्रमपरिवर्तन उत्पन्न करता है

([:+/}:([:|-)}.)"1

दूरी की गणना करता है

(]A.~[: I. (= ([:distance perms)))

वे परिणाम जो इनपुट के समान हैं, और उन क्रमपरिवर्तन को फिर से उत्पन्न करता है (मुझे संदेह है कि कुछ वर्णों को यहां से हटा दिया जा सकता है)

पत्रों के साथ:

((a.{~65+[:i.#))

पहले n अक्षरों की एक सूची बनाएँ, जहाँ n इनपुट सूची की लंबाई है

indices A. [: letters ]

ऊपर जैसा ही करता है

Comments

क्या आप पत्रों के संदर्भ में उत्तर रिपोर्ट करने के लिए इसे समायोजित कर सकते हैं?

— माइकल स्टर्न

@MichaelStern मैं कर सकता था, लेकिन यह चरित्र की गिनती में काफी थोड़ा जोड़ देगा (जे तार के साथ भयानक है)। मैं अब यह कोशिश करूँगा, यह देखने के लिए कि नुकसान क्या हो सकता है।

— atı

Answer 5

ऑक्टेव, 73

function r=t(l,d,s)r=perms(l)(find(sum(abs(diff(perms(d)')))==s,1),:);end

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

octave:15> t(["E" "F" "G" "H" "J" "K"],[0 5 7 13 16 17],62)
ans = HEJFKG

जो 13-0-16-5-17-7 => 13 + 16 + 11 + 12 + 10 = 62 है।

octave:16> t(["E" "F" "G" "H" "J" "K"],[0 5 7 13 16 17],2)
ans = 

(असंभव इनपुट के लिए रिक्त)

Comments

मुझे नहीं पता कि सौदा क्या है, लेकिन perms()ideone.com पर ऑक्टेव 3.6.2 में स्ट्रिंग्स के वेक्टर के साथ समस्याएं हैं।

— एलेक्स ए।

दिलचस्प। मेरे पास स्थानीय स्तर पर 3.8.1 हैं।

— dcsohl

Answer 6

मतलाब (86)

x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))

उदाहरण जिसमें एक समाधान मौजूद है:

>> x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))
[0, 5, 7, 13, 16, 17]
62
DBFAEC
>>

उदाहरण जिसमें कोई समाधान मौजूद नहीं है:

>> x=input('');X=perms(1:6);disp(char(X(find(sum(abs(diff(x(X).')))==input(''),1),:)+64))
[0, 5, 7, 13, 16, 17]
100
>> 

---

मतलाब (62)

यदि आउटपुट स्वरूप अक्षरों के बजाय पदों का निर्माण करके और कोई समाधान मौजूद होने पर रिक्त मैट्रिक्स का उत्पादन करके आराम किया जा सकता है:

X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)

उदाहरण जिसमें एक समाधान मौजूद है:

>> X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)
[0, 5, 7, 13, 16, 17]
62
ans =
    13     5    17     0    16     7

उदाहरण जिसमें कोई समाधान मौजूद नहीं है:

>> X=perms(input(''));X(find(sum(abs(diff(X.')))==input(''),1),:)
[0, 5, 7, 13, 16, 17]
62
ans =
   Empty matrix: 0-by-6

---

मतलाब (54)

यदि यह कार्यक्रम के लिए सभी मान्य पथ प्रदान करने के लिए स्वीकार्य है :

X=perms(input(''));X(sum(abs(diff(X.')))==input(''),:)

उदाहरण जिसमें एक समाधान मौजूद है:

>> X=perms(input(''));X(sum(abs(diff(X.')))==input(''),:)
[0, 5, 7, 13, 16, 17]
62
ans =
    13     5    17     0    16     7
    13     5    16     0    17     7
    13     0    17     5    16     7
    13     0    16     5    17     7
     7    16     5    17     0    13
     7    16     0    17     5    13
     7    17     5    16     0    13
     7    17     0    16     5    13

Answer 7

हास्केल, 109 बाइट्स

import Data.List
a%b=abs$snd a-snd b
n#l=[map(fst)p|p<-permutations(zip['E'..]l),n==sum(zipWith(%)p(tail p))]

उपयोग उदाहरण: 17 # [0, 5, 7, 13, 16, 17]जो सभी मान्य पथों को आउटपुट करता है, अर्थात ["EFGHIJ","JIHGFE"]। यदि कोई मान्य पथ नहीं है, तो रिक्त सूची []वापस आ जाती है।

पत्रों की सूची में शामिल हैं I(आशा है कि यह ठीक है)।

यह कैसे काम करता है: (name, position)जोड़े की एक सूची बनाएं, अनुमति दें और उन लोगों को ले जाएं जहां पथ की लंबाई बराबर होती है nऔर स्थिति भाग को हटा देती है।