कीस्ट्रोक्स ए, Ctrl + A, Ctrl + C और Ctrl + V का उपयोग करने वाले अधिकतम वर्ण

Question

यह google का एक साक्षात्कार प्रश्न है। मैं इसे खुद से हल नहीं कर पा रहा हूं। क्या कोई प्रकाश को बहा सकता है?

कीस्ट्रोक्स के अनुक्रम को प्रिंट करने के लिए एक प्रोग्राम लिखें जैसे कि यह अधिकतम वर्ण की संख्या उत्पन्न करता है। आप केवल 4 कुंजी का उपयोग करने की अनुमति है: A, Ctrl+ A, Ctrl+ Cऔर Ctrl+ V। केवल N कीस्ट्रोक्स की अनुमति है। सभी Ctrl+ वर्णों को एक कीस्ट्रोके माना जाता है, इसलिए Ctrl+ Aएक कीस्ट्रोकेक है।

उदाहरण के लिए, अनुक्रम A, Ctrl+ A, Ctrl+ C, Ctrl+ V4 कीस्ट्रोक्स में दो ए बनाता है।

• Ctrl + A सभी का चयन करें
• Ctrl + C कॉपी है
• Ctrl + V पेस्ट है

मैंने कुछ गणित किया। किसी भी N के लिए, A, a Ctrl+ A, one Ctrl+ Cऔर y Ctrl+ के x नंबरों का उपयोग करके V, हम A की अधिकतम (N-1) / 2) ² संख्या उत्पन्न कर सकते हैं । कुछ एन> एम के लिए, यह Ctrl+ Aकी + संख्या के रूप में कई + के, Ctrl+ Cऔर Ctrl+ Vदृश्यों का उपयोग करना बेहतर है ।

अनुक्रम Ctrl+ A, Ctrl+ V, Ctrl+ Cमौजूदा चयन को अधिलेखित नहीं करेगा। यह कॉपी किए गए चयन को चयनित को अपग्रेड करेगा।

Comments

कई पाठ संपादकों ^Aमें आमतौर पर "सभी का चयन करें", ^C"कॉपी" है, ^V"पेस्ट" है। क्या यह आपको एक विचार देता है?

— निकोलाई Fetissov

मेरा मतलब है 'ए' की संख्या। उदाहरण के लिए, N = 7 के लिए हम 9 A के कीस्ट्रोक A, A, A, CTRL + A, CTRL + C, CTRL + V, CTRL + V

— mund

उह, यह 7 कीस्ट्रोक्स है।

— जॉन डिब्लिंग

@ जॉन "सभी CTRL + वर्णों को एक कीस्ट्रोक माना जाता है, इसलिए CTRL + A एक कीस्ट्रोक है।"

— फ्रेडली

मैंने C ++ टैग हटा दिया है, यह पूरी तरह से एक एल्गोरिथ्म प्रश्न है और उम्मीद है कि यह नाखुश c ++ फ़ॉलोअर्स को डाउनवोट / वोट को बंद करने से रोकेगा।

— Matthieu M.

Answer 1

एक गतिशील प्रोग्रामिंग समाधान है। हम 0 कुंजी जानना शुरू कर सकते हैं हमें 0 ए बना सकते हैं। फिर हम दो चीजों iको करने n, एक बार दबाने और पेस्ट करने के jसमय के बाद सभी + कॉपी का चयन करने के लिए पुनरावृति करते हैं (वास्तव में j-i-1नीचे; नोट यहां ट्रिक पर ध्यान दें: सामग्री अभी भी क्लिपबोर्ड में हैं, इसलिए हम इसे कई बार बिना पेस्ट कर सकते हैं। हर बार नकल)। हमें केवल 4 लगातार पेस्टल्स पर विचार करना है, चूंकि सेलेक्ट, कॉपी, पेस्ट एक्स 5 सेलेक्ट, कॉपी, पेस्ट, सिलेक्ट, कॉपी, पेस्ट के बराबर है और बाद वाला बेहतर है क्योंकि यह क्लिपबोर्ड में हमें अधिक छोड़ देता है। एक बार जब हम पहुंच गए n, तो हमारा वांछित परिणाम है।

जटिलता ओ (एन) प्रतीत हो सकती है, लेकिन चूंकि संख्या एक घातीय दर से बढ़ती है, यह वास्तव में बड़ी संख्याओं को गुणा करने की जटिलता के कारण ओ (एन ² ) है। नीचे पायथन कार्यान्वयन है। एन = 50,000 के लिए गणना करने में लगभग 0.5 सेकंड लगते हैं।

def max_chars(n):
  dp = [0] * (n+1)
  for i in xrange(n):
    dp[i+1] = max(dp[i+1], dp[i]+1) # press a
    for j in xrange(i+3, min(i+7, n+1)):
      dp[j] = max(dp[j], dp[i]*(j-i-1)) # press select all, copy, paste x (j-i-1)
  return dp[n]

कोड में, jकुंजियों के हमारे नए अनुक्रम के बाद दबाए गए कुंजी की कुल संख्या का प्रतिनिधित्व करता है। iइस चरण में हमारे पास पहले से ही कीपेस हैं, और 2 नए कीप्स सेलेक्ट-ऑल और कॉपी पर जाते हैं। इसलिए हम पेस्ट j-i-2बार मार रहे हैं । चूंकि चिपकाने के मौजूदा अनुक्रम में जोड़ता है dp[i] A, हमें 1इसे बनाने की आवश्यकता है j-i-1। यह j-i-1दूसरी-अंतिम पंक्ति में व्याख्या करता है।

यहाँ कुछ परिणाम ( n= A की संख्या) दिए गए हैं:

• 7 => 9
• 8 => 12
• 9 => 16
• 10 => 20
• 100 => 1391569403904
• 1,000 => 326816000195374378378327270206631190344853389404948600842626248121757146615064636953144900245 17464291106495202828858546304
• 50,000 => बहुत बड़ी संख्या!

मैं @ एसबी से सहमत हूं कि आपको हमेशा अपनी मान्यताओं को बताना चाहिए: मेरा यह है कि आपको वर्णों की संख्या को दोगुना करने के लिए दो बार पेस्ट करने की आवश्यकता नहीं है। यह 7 के लिए जवाब मिलता है, इसलिए जब तक मेरा समाधान गलत है धारणा सही होनी चाहिए।

मामले में किसी को चमत्कार कारण है कि मैं फार्म के दृश्यों की जाँच नहीं कर रहा हूँ में Ctrl+ A, Ctrl+ C, A, Ctrl+ V: अंतिम परिणाम हमेशा की तरह ही होगा A, Ctrl+ A, Ctrl+ C, Ctrl+ Vजो मैं करना पर विचार करें।

Comments

वह है n => resultया result => n? किसी भी तरह से, मुझे लगता है कि यह गलत है। हम 7 कीस्ट्रोक्स के साथ 9 टाइप कर सकते हैं। यदि यह n => resultनिश्चित रूप से गलत है। आप जितने टाइप कर सकते हैं, उससे कम नहीं हो सकता है n।

— IVlad

@IVlad यह है n => result। आप कहते हैं, "हम 7 कीस्ट्रोक्स के साथ 9 टाइप कर सकते हैं", जो कि मुझे मिलता है। "ट्रिक" पढ़ें, जिसे मैंने अभी संपादित किया है।

— मोइनुद्दीन

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

— एंड्रयू क्लार्क

@marcog - आपका अंकन कम से कम भ्रमित करने वाला और सबसे गलत है। nवह कीस्ट्रोक्स है जिसका आपको उपयोग करने की अनुमति है। आपको यह साबित करना होगा कि आप कितने nकीस्ट्रोक्स के साथ टाइप कर सकते हैं । तो 7 => 7कोई मतलब नहीं है।

— 18 दिसंबर को IVlad

सही लगता है, + 1. अब देखते हैं कि क्या कोई इसे नीचे O(n)या यहाँ तक ले सकता है O(1):)।

— IVlad

Answer 2

Marcog के समाधान का उपयोग करके मुझे एक पैटर्न मिला जो शुरू होता है n=16। यहाँ इस उदाहरण देकर स्पष्ट करने के लिए कीस्ट्रोक्स हैं n=24अप करने के लिए n=29, मैं प्रतिस्थापित ^ एस (चुनें) के साथ एक, ^ पठनीयता के लिए पी (पेस्ट) के साथ सी (कॉपी), और साथ सी ^ वी:

24: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P
       4   *    4    *    4    *    4    *    4     = 1024
25: A,A,A,A,S,C,P,P,P,S,C,P,P,S,C,P,P,S,C,P,P,S,C,P,P
       4   *    4    *   3   *   3   *   3   *   3    = 1296
26: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,S,C,P,P,S,C,P,P
       4   *    4    *    4    *   3   *   3   *   3    = 1728
27: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,S,C,P,P
       4   *    4    *    4    *    4    *   3   *   3    = 2304
28: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P
       4   *    4    *    4    *    4    *    4    *   3    = 3072
29: A,A,A,A,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P,S,C,P,P,P
       4   *    4    *    4    *    4    *    4    *    4     = 4096

प्रारंभिक 4 आस के बाद, आदर्श पैटर्न का चयन करना, कॉपी करना, चिपकाना, चिपकाना और दोहराना है। यह प्रत्येक 5 कीस्ट्रोक्स के रूप में अस की संख्या को 4 से गुणा करेगा। यदि यह 5 कीस्ट्रोक पैटर्न 4 कीस्ट्रोके पैटर्न (SCPP) की कुछ संख्याओं पर शेष कीस्ट्रोक्स का उपभोग नहीं कर सकता है, तो SCPPP की जगह (या पास्ट में से एक को हटाकर) अंतिम कीस्ट्रोक्स का उपभोग करता है। 4 कीस्ट्रोके पैटर्न 3 हर 4 कीस्ट्रोक्स द्वारा कुल गुणा करते हैं।

इस पैटर्न का उपयोग करते हुए कुछ पायथन कोड है, जो marcog के समाधान के समान परिणाम प्राप्त करता है, लेकिन O (1) संपादित होता है : यह वास्तव में O (लॉग एन) है क्योंकि घातांक के कारण आईवीडीएल को धन्यवाद दिया गया है।

def max_chars(n):
  if n <= 15:
    return (0, 1, 2, 3, 4, 5, 6, 9, 12, 16, 20, 27, 36, 48, 64, 81)[n]
  e3 = (4 - n) % 5
  e4 = n // 5 - e3
  return 4 * (4 ** e4) * (3 ** e3)

ई 3 की गणना: कीस्ट्रोक सूची के अंत में हमेशा 0 और 4 एससीपीपी पैटर्न के बीच n % 5 == 4होते हैं, 4 के लिए, n % 5 == 13 n % 5 == 2होते हैं, 2 n % 5 == 3होते हैं, 1 होते हैं, और n % 5 == 40. होते हैं। इसे सरल बनाया जा सकता है (4 - n) % 5।

ई 4 की गणना: जब भी n % 5 == 0यह संख्या निकलती है तो पैटर्न की कुल संख्या 1 से बढ़ जाती है n / 5। फर्श विभाजन का उपयोग करके हम कुल पैटर्न प्राप्त कर सकते हैं, कुल संख्या पैटर्न पैटर्न की कुल संख्या e4है e3। पायथन से अपरिचित लोगों के //लिए, फर्श विभाजन के लिए भविष्य के सबूत संकेतन है।

Comments

अच्छा है! परीक्षण किया गया और यह काम करता है n=3000, इसलिए यह शायद सही है। (आज मैं वोटों से बाहर हूं: /)

— मोइनुद्दीन 21

+1, बहुत अच्छा। माइनर नाइटिक हालांकि: यह वास्तव O(1)में नहीं है क्योंकि निरंतर समय में घातांक नहीं किया जा सकता है। यह है O(log n)।

— IVlad

दरअसल, अनुक्रम 'SCPPP' केवल वर्णों की संख्या को तीन से गुणा करेगा: पहला पेस्ट केवल चयनित पाठ को अधिलेखित करता है।

— निक जॉनसन

@ प्रश्न में अंतिम पंक्ति: "अनुक्रम Ctrl + A, Ctrl + V, Ctrl + C मौजूदा चयन को अधिलेखित नहीं करेगा। यह कॉपी किए गए चयन को चयनित एक में जोड़ देगा।"

— मोइनुद्दीन

@marcog हां, मैंने उस पर ध्यान नहीं दिया। मैं किसी भी OS के बारे में नहीं जानता जो उस फैशन में व्यवहार करता है, हालांकि।

— निक जॉनसन

Answer 3

यहां बताया गया है कि मैं इसे कैसे देखूंगा:

• मान लेना CtrlA= सभी का चयन करना
• मान लेना CtrlC= चयन करना
• मान लिया CtrlV= कॉपी किए गए चयन को चिपकाएँ

कुछ पाठ दिए गए हैं, इसे नक़ल करने के लिए 4 कीस्ट्रोक्स लगते हैं:

• CtrlA यह सब का चयन करने के लिए
• CtrlC इसे कॉपी करने के लिए
• CtrlV चिपकाने के लिए (यह चयन पर पेस्ट करेगा - अपने प्रश्नों का उत्तर दें)
• CtrlV फिर से पेस्ट करने के लिए जो इसे दोगुना करता है।

वहां से, आप 4 या 5 ए के करने पर विचार कर सकते हैं, फिर ऊपर से लूपिंग कर सकते हैं। ध्यान दें कि ctrl + a, c, v, vजैसे ही आप लूप के माध्यम से अपना पाठ तेजी से बढ़ाएंगे। यदि शेष स्ट्रोक <4, बस एक करते रहोCtrlV

Google जैसी @ जगहों का साक्षात्कार करने की कुंजी आपकी मान्यताओं को बताना और आपकी सोच को संप्रेषित करना है। वे जानना चाहते हैं कि आप समस्याओं को कैसे हल करते हैं।

Comments

साक्षात्कार तकनीक के बारे में अच्छी बात, सही उत्तर प्राप्त करना अंत में स्पष्ट रूप से संवाद करने से कम महत्वपूर्ण नहीं है!

— फ्रेडली

अच्छा उत्तर। एल्गोरिथ्म के लिए, एक लालची-से-दो त्रुटि: ACVV-VVVVV7 से ACVV-ACVV-Vगुणा , 6 से गुणा। शेष स्ट्रोक के लिए तो Ctrl-V <6 के बजाय 4।

— मार्सेल जैकवर्थ

Answer 4

यह O (1) में हल करने योग्य है: फाइबोनैचि संख्याओं की तरह, मुद्रित संख्या की गणना करने के लिए एक सूत्र है (और कीस्ट्रोक्स का क्रम):

---

1) हम समस्या का वर्णन सरल कर सकते हैं:

• केवल [ए], [सीए] + [सीसी], [सीवी] और एक खाली कॉपी-पेस्ट-बफर होने के बाद

बराबरी

• कॉपी-पेस्ट-बफर में केवल [सीए] + [सीसी], [सीवी] और "ए" होने।

---

2) हम कीस्ट्रोक्स के अनुक्रम को '' * ',' V ',' v '} से N वर्णों की एक स्ट्रिंग के रूप में वर्णित कर सकते हैं, जहां' v 'का अर्थ है [Cv] और' * 'का अर्थ है [Ca] और' V ' 'का अर्थ है [सीसी]। उदाहरण: "vvvv * Vvvv * Vvvv"

उस तार की लंबाई अभी भी एन के बराबर है।

उस स्ट्रिंग में Vv- शब्दों की लंबाई का उत्पाद उत्पादित अस की संख्या के बराबर होता है।

---

3) उस स्ट्रिंग के लिए एक निश्चित लंबाई N और शब्दों की एक निश्चित संख्या K को देखते हुए, परिणाम अधिकतम होगा यदि सभी शब्दों में लगभग लंबाई हो। उनकी जोड़ी-वार अंतर-1 से अधिक नहीं है।

अब, यदि N दिया गया है, तो इष्टतम संख्या K क्या है?

---

4) मान लीजिए, हम किसी एक शब्द की लंबाई L को जोड़कर शब्दों की संख्या बढ़ाना चाहते हैं, तो हमें किसी भी पिछले शब्द को एक 'v' से घटाकर L + 1 करना होगा। उदाहरण: "... * Vvv * Vvv * Vvv * Vvvv" -> "..." * Vvv * Vvv * Vvv * Vvv * Vvv "

अब, इष्टतम शब्द लंबाई L क्या है?

(5 * 5 * 5 * 5 * 5) <(4 * 4 * 4 * 4 * 4) * 4, (4 * 4 * 4 * 4)> ((3 * 3 * 3 * 3) * 3

=> इष्टतम एल = 4 है।

---

5) मान लीजिए, हमारे पास लंबाई 4 के कई शब्दों के साथ एक स्ट्रिंग पैदा करने के लिए पर्याप्त एन है, लेकिन कुछ कीस्ट्रोक्स बाकी हैं; हमें उनका उपयोग कैसे करना चाहिए?

• यदि 5 या अधिक बचे हैं: लंबाई 4 के साथ एक और शब्द जोड़ें।

• अगर 0 बचे हैं: हो गया।

• यदि 4 बचे हैं: हम या तो कर सकते हैं

  a) लंबाई 3: 4 * 4 * 4 * 4 * 3 = 768 के साथ एक शब्द को जोड़ो।

  b) या 4 शब्दों को बढ़ाकर 5: 5 * 5 * 5 * 5 = 625 किया। => एक शब्द को लागू करना बेहतर है।

• यदि 3 बचे हैं: हम या तो कर सकते हैं

  a) या एक शब्द को लंबाई 3 के साथ प्रीविअस शब्द को 4 से 3: 4 * 4 * 4 * 2 = 128 <4 * 4 * 3 * 3 = 144 में समायोजित करके।

  b) 3 शब्दों को बढ़ाकर 5: 5 * 5 * 5 = 125 करें। => एक शब्द को लागू करना बेहतर है।

• यदि 2 बचे हैं: हम या तो कर सकते हैं

  a) या एक शब्द को लंबाई 3 के साथ जोड़कर प्रीविअस दो शब्दों को लंबाई 4 से 3: 4 * 4 * 1 = 16 <3 * 3 * 3 = 27 तक समायोजित करें।

  b) 2 शब्दों को बढ़ाकर 5: 5 * 5 = 25 करें। => एक शब्द को लागू करना बेहतर है।

• अगर 1 बचा है: हम या तो कर सकते थे

  a) या एक शब्द को लंबाई 3 से जोड़कर प्रीविअस तीन शब्दों को लंबाई 4 से 3: 4 * 4 * 4 * 0 = 0 <3 * 3 * 3 * 3 = 81 में समायोजित करें।

  b) एक शब्द को बढ़ाकर ५: ४ * ४ * ५ = to०। => एक शब्द को लागू करना बेहतर है।

---

6) अब, अगर हमारे पास 5 में नियमों का उपयोग करने के लिए "पर्याप्त बड़े एन" नहीं है तो क्या होगा? हमें योजना बी के साथ रहना होगा), यदि संभव हो तो! छोटे N के तार निम्नलिखित हैं:

1: "v", 2: "vv", 3: "vvv", 4: "vvvv"

5: "vvvvv" → 5 (प्लान बी)

6: "vvvvvv" → 6 (प्लान बी)

7: "vvv * Vvv" → 9 (a) योजना

8: "vvvv * Vvv" → 12 (योजना a)

9: "vvvv * Vvvv" → 16

10: "vvvv * Vvvvv" → 20 (योजना बी)

11: "vvv * Vvv * Vvv" → 29 (योजना a)

12: "vvvv * Vvv * Vvv" → 36 (योजना a)

13: "vvvv * Vvvv * Vvv" → 48 (योजना a)

14: "vvvv * Vvvv * Vvvv" → 64

15: "vvv * Vvv * Vvv * Vvv" → 81 (योजना a)

...

---

7) अब, लंबाई N की एक स्ट्रिंग में शब्दों का इष्टतम संख्या K क्या है?

यदि एन <7 तो के = 1 और यदि 6 <एन <11 तो के = 2; अन्यथा: K = छत ((एन + 1) / ५)

C / C ++ / Java में लिखा है: int K = (N<7)?(1) : (N<11)?(2) : ((N+5)/5);

और यदि एन> 10, तो लंबाई 3 के साथ शब्दों की संख्या होगी: के * 5-1-एन। इसके साथ, हम मुद्रित संख्या की गणना कर सकते हैं:

यदि N> 10, As की संख्या होगी: 4 ^ {N + 1-4K} · 3 ^ {5K-N-1}

Comments

सही लगता है, @ एंड्रयू के उत्तर द्वारा दिए गए उदाहरणों के लिए काम करता है, लेकिन आपका उत्तर भी O (1) के बजाय O (लॉग एन) है, है ना?

— रासना

यह ओ (लॉग एन) कैसे हो सकता है? As की संख्या की गणना करने का गणितीय सूत्र O (1) में परिकलित किया गया है। कीस्ट्रोक प्रिंट करने के लिए एल्गोरिथ्म या तो ओ (एन) है क्योंकि प्रिंट करने के लिए ओ (एन) कीस्ट्रोक्स हैं, या ओ (1) यदि आप इसे नियमित अभिव्यक्ति के रूप में प्रिंट करने की अनुमति देते हैं।

— कोमोनॉड com

प्रतिपादक की गणना O (log N) है क्योंकि N पर 4 के साथ घातांक बढ़ जाता है। यदि आप असमान संख्या की संख्या को तथ्यात्मक रूप में छापते हैं तो यह O (1) है।

— एंड्रयू क्लार्क

आह अच्छा। वास्तव में पूर्णांक अंकगणित के साथ संख्या की गणना के बारे में कभी नहीं सोचा। मुझे केवल सूत्र या फ़्लोटिंग पॉइंट सन्निकटन में रुचि होगी। लेकिन निश्चित रूप से, इसे अन्य संख्याओं से तुलना करने में सक्षम होने के लिए, इसकी सटीक गणना करनी होगी।

— कोमनाड

Answer 5

का उपयोग CtrlA+ CtrlC+ CtrlVके बाद ही 4 'ए का एक फायदा है।

इसलिए मैं कुछ इस तरह से करूँगा (छद्म-बुनियादी-कोड में, क्योंकि आपने कोई उचित भाषा निर्दिष्ट नहीं की है):

// We should not use the clipboard for the first four A's:
FOR I IN 1 TO MIN(N, 4)
    PRINT 'CLICK A'
NEXT
LET N1 = N - 4

// Generates the maximum number of pastes allowed:
FOR I IN 1 TO (N1 DIV 3) DO
    PRINT 'CTRL-A'
    PRINT 'CTRL-C'
    PRINT 'CTRL-V'
    LET N1 = N1 - 3
NEXT

// If we still have same keystrokes left, let's use them with simple CTRL-Vs
FOR I IN N1 TO N
    PRINT 'CTRL-V'
NEXT

संपादित करें

1. CtrlVमुख्य लूप में एक का उपयोग करने के लिए वापस ।
2. जो कुछ मैं यहाँ करने की कोशिश कर रहा हूँ उसे समझाने के लिए कुछ टिप्पणियां जोड़ीं।
3. "पहले चार ए के" ब्लॉक के साथ एक मुद्दा फिक्स्ड।

Comments

@ एसबी: मैं केवल पिछले पेस्ट्स के लिए CTRL-V कर रहा हूं । आपने अपने उत्तर में जो कहा है, वही है। इसका मतलब है कि हम ऐसा ही सोचते हैं, इसलिए मुझे नहीं पता कि आप मेरी आलोचना क्यों कर रहे हैं - या शायद मुझे कुछ याद आ रहा है?

— रासना

Google कभी भी लिखने के लिए एक उचित भाषा निर्दिष्ट नहीं करता है, जो आप कभी भी चाहते हैं।

— स्पूक्स

Answer 6

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

for (i = 3 + n%3; i>0 && n>0; n--, i--) {
    print("a");
}

for (; n>0; n = n-3) {
    print("ctrl-a");
    print("ctrl-c");
    print("ctrl-v");
}

संपादित करें:

यह भयानक है, मैं पूरी तरह से खुद से आगे निकल गया और प्रत्येक कॉपी के लिए कई पेस्टों पर विचार नहीं किया।

2 संपादित करें:

मेरा मानना ​​है कि 3 बार चिपकाना इष्टतम है, जब आपके पास इसे करने के लिए पर्याप्त कीस्ट्रोक्स हैं। 5 कीस्ट्रोक्स में आप अपनी संख्या 4 से गुणा करते हैं। यह 4 कीस्ट्रोक्स का उपयोग करके 3 से गुणा करना बेहतर है और 6 कीस्ट्रोक्स का उपयोग करके 5 से गुणा करना बेहतर है। मैंने प्रत्येक विधि को कीस्ट्रोक्स की समान संख्या देकर इसकी तुलना की, पर्याप्त है ताकि वे एक ही समय (60) में एक चक्र को समाप्त कर सकें, 3-गुणक को 15 चक्र करते हैं, 4-गुणक 12 चक्र करते हैं, और 5- गुणक 10 चक्र करते हैं। 3 ^ 15 = 14,348,907, 4 ^ 12 = 16,777,216, और 5 ^ 10 = 9,777,625। यदि केवल 4 कीस्ट्रोक्स बचे हैं, तो 3-गुणक करना 4 से अधिक बार चिपकाने से बेहतर है, अनिवार्य रूप से पिछले 4 गुणक को 8-गुणक बन जाता है। यदि केवल 3 कीस्ट्रोक्स बचे हैं, तो 2-गुणक सबसे अच्छा है।

Answer 7

मान लें कि आपके पास क्लिपबोर्ड में x वर्ण और पाठ क्षेत्र में x वर्ण हैं; चलो इसे "राज्य एक्स" कहते हैं।

चलो "पेस्ट" को कुछ बार दबाएं (मैं इसे m-1सुविधा के लिए निरूपित करता हूं ), फिर "सिलेक्ट-ऑल" और "कॉपी"; इस क्रम के बाद, हम "राज्य एम * x" पर पहुंचते हैं। यहां, हमने कुल m + 1 कीस्ट्रोक्स बर्बाद किया। तो विषमतापूर्ण विकास (कम से कम) कुछ ऐसा है f^n, जहां एफ = m^(1/(m+1))। मेरा मानना ​​है कि यह अधिकतम संभव विषमता है, हालांकि मैं इसे (अभी तक) साबित नहीं कर सकता।

M के विभिन्न मूल्यों को आज़माना दर्शाता है कि f के लिए अधिकतम प्राप्त किया जाता है m=4।

आइए निम्नलिखित एल्गोरिथ्म का उपयोग करें:

Press A a few times
Press Select-all
Press Copy
Repeat a few times:
    Press Paste
    Press Paste
    Press Paste
    Press Select-all
    Press Copy
While any keystrokes left:
    Press Paste

(यकीन नहीं है कि यह इष्टतम है)।

A को शुरू में दबाने के लिए समय की संख्या 3 है: यदि आप इसे 4 बार दबाते हैं, तो आप A की संख्या को 3 और कीस्ट्रोक्स में दोगुना करने का अवसर चूक जाते हैं।

अंत में पेस्ट को प्रेस करने की संख्या 5 से अधिक नहीं है: यदि आपके पास 6 या अधिक कीस्ट्रोक्स बचे हैं, तो आप इसके बजाय पेस्ट, पेस्ट, पेस्ट, चयन-सभी, कॉपी, पेस्ट का उपयोग कर सकते हैं।

तो, हम निम्नलिखित एल्गोरिथ्म प्राप्त करते हैं:

If (less than 6 keystrokes - special case)
    While (any keystrokes left)
        A
Else
    First 5 keystrokes: A, A, A, Select-all, Copy
    While (more than 5 keystrokes left)
        Paste, Paste, Paste, Select-all, Copy
    While (any keystrokes left)
        Paste

(यकीन नहीं है कि यह इष्टतम है)। इसे निष्पादित करने के बाद वर्णों की संख्या कुछ इस प्रकार है

3 * pow(4, floor((n - 6) / 5)) * (2 + (n - 1) % 5)।

नमूना मूल्य: 1,2,3,4,5,6,9,12,15,18,24,36,48,60,72,96,144,192,240,288, ...

Answer 8

निम्नानुसार ओपी के दूसरे संपादन का उपयोग करता है जो चिपकाने से मौजूदा पाठ को प्रतिस्थापित नहीं करता है ।

कुछ बातें नोटिस करें:

• ^ ए और ^ सी को एक एकल क्रिया माना जा सकता है जो दो कीस्ट्रोक्स लेता है, क्योंकि यह उन्हें व्यक्तिगत रूप से करने के लिए कभी भी समझ में नहीं आता है। वास्तव में, हम ^ A ^ C को ^ K ^ V के सभी उदाहरणों से बदल सकते हैं, जहां ^ K एक कुंजी "कट" ऑपरेशन है (चलो इसे एक्स संक्षिप्त करें)। हम देखेंगे कि ^ K के साथ व्यवहार करना दो-लागत ^ A ^ C की तुलना में बहुत अच्छा है।
• मान लेते हैं कि क्लिपबोर्ड में एक 'ए' शुरू होता है। तब ^ V (चलो इसे संक्षिप्त करें Y) A से कड़ाई से बेहतर है और हम बाद के सभी विचारों से हट सकते हैं। (वास्तविक समस्या में, यदि क्लिपबोर्ड खाली होना शुरू हो जाता है, तो हम निम्नलिखित के साथ Y की जगह A को पहले V के बाद V से बदल देंगे।)

प्रत्येक उचित कीस्ट्रोक अनुक्रम को इस प्रकार Xs द्वारा अलग किए गए Ys के समूह के रूप में व्याख्या किया जा सकता है, उदाहरण के लिए YYYXYXYYXY। V (s) द्वारा अनुक्रम के द्वारा निर्मित 'A की संख्या। तब V (nXm) = V (n) * V (m), क्योंकि X अनिवार्य रूप से V (n) 'A' के साथ प्रत्येक Y को m से बदलता है।

कॉपी-पेस्ट की समस्या इस प्रकार निम्नलिखित समस्या के लिए समसामयिक है: "एम + 1 संख्या का उपयोग करते हुए जो एनएम को योग करते हैं, उनके उत्पाद को अधिकतम करते हैं।" उदाहरण के लिए, जब N = 6, उत्तर m = 1 और संख्या (2,3) है। 6 = 2 * 3 = V (YYXYYY) = V (AA ^ A ^ C ^ V ^ V) (या V (YYYXYY) = V (AAA ^ A ^ C ^ V)।)

हम कुछ अवलोकन कर सकते हैं:

के एक निश्चित मूल्य के लिए m, चुनने के लिए संख्याएं हैं ceil( (N-m)/(m+1) )और floor( (N-m)/(m+1) )(जो भी संयोजन में योग का काम करता है; और विशेष रूप से आपको आवश्यकता होगी (N-m) % (m+1) ceilsऔर बाकी floorएस)। इसका कारण यह है है, के लिए a < b, (a+1)*(b-1) >= a*b।

दुर्भाग्य से मुझे इसका मूल्य खोजने का आसान तरीका नहीं दिखता है m। यदि यह मेरा साक्षात्कार होता तो मैं इस बिंदु पर दो समाधान प्रस्तावित करता:

विकल्प 1. हर संभव पर लूप m। एक ओ ( n log n) समाधान।

C ++ कोड:

long long ipow(int a, int b)
{
  long long val=1;
  long long mul=a;

  while(b>0)
    {
      if(b%2)
    val *= mul;
      mul *= mul;
      b/=2;
    }
  return val;
}

long long trym(int N, int m)
{
  int floor = (N-m)/(m+1);
  int ceil = 1+floor;
  int numceils = (N-m)%(m+1);
  return ipow(floor, m+1-numceils) * ipow(ceil, numceils);
}

long long maxAs(int N)
{
  long long maxval=0;
  for(int m=0; m<N; m++)
    {
      maxval = std::max(maxval, trym(N,m));
    }
  return maxval;
}

विकल्प 2. mगैर-पूर्णांक मूल्यों को प्राप्त करने की अनुमति दें और इसकी जड़ के लिए [(N-m)/(m+1)]^mसम्मान mऔर हल के साथ व्युत्पन्न लेने के द्वारा इसका इष्टतम मूल्य खोजें । कोई विश्लेषणात्मक समाधान नहीं है, लेकिन रूट को न्यूटन की विधि का उपयोग करके पाया जा सकता है। फिर उस रूट के फर्श और छत का उपयोग मूल्य के लिए करें m, और जो भी सबसे अच्छा हो उसे चुनें।

Answer 9

public int dp(int n) 
{
    int arr[] = new int[n];
    for (int i = 0; i < n; i++)
        arr[i] = i + 1;
    for (int i = 2; i < n - 3; i++) 
    {
        int numchars = arr[i] * 2;
        int j = i + 3;
        arr[j] = Math.max(arr[j], numchars);
        while (j < n - 1) 
        {
            numchars = numchars + arr[i];
            arr[++j] = Math.max(arr[j], numchars);
        }
    }
    return arr[n - 1];
}

Answer 10

यहाँ नीचे कोड के साथ मेरा दृष्टिकोण और समाधान है।

दृष्टिकोण:

तीन अलग-अलग ऑपरेशन किए जा सकते हैं।

1. कीस्ट्रोक ए - आउटपुट एक वर्ण 'ए'
2. कीस्ट्रोक (Ctrl-A) + (Ctrl-C) - आउटपुट कुछ भी अनिवार्य नहीं है। इन दो कीस्ट्रोक्स को एक ऑपरेशन में जोड़ा जा सकता है क्योंकि इनमें से प्रत्येक कीस्ट्रोक्स व्यक्तिगत रूप से कोई मतलब नहीं रखते हैं। इसके अलावा, यह कीस्ट्रोक अगले पेस्ट ऑपरेशन के लिए आउटपुट सेट करता है।
3. कीस्ट्रोक (Ctrl-V) - इस कीस्ट्रोक के लिए आउटपुट वास्तव में पिछले (दूसरे) ऑपरेशन पर निर्भर करता है और इसलिए हमें अपने कोड में इसके लिए ध्यान देना होगा।

अब तीन अलग-अलग संचालन और उनके संबंधित आउटपुट को देखते हुए, हमें इन ऑपरेशनों के सभी क्रमपरिवर्तन के माध्यम से चलना होगा।

---

कल्पना:

अब, इस समस्या के कुछ संस्करण में कहा गया है कि कीस्ट्रोक्स, Ctrl + A -> Ctrl + C -> Ctrl + V का अनुक्रम, हाइलाइट किए गए चयन को अधिलेखित करता है। इस धारणा में कारक के लिए, कोड की केवल एक पंक्ति को नीचे दिए गए समाधान में जोड़ने की आवश्यकता होती है, जहां केस 2 में मुद्रित चर 1 0 पर सेट है।

        case 2:
        //Ctrl-A and then Ctrl-C
            if((count+2) < maxKeys)
            {
                pOutput = printed;

                //comment the below statement to NOT factor 
                //in the assumption described above
                printed = 0;    
            }

इस समाधान के लिए

नीचे दिया गया कोड कुछ दृश्यों को प्रिंट करेगा और अंतिम अनुक्रम किसी दिए गए N के लिए सही उत्तर है। उदाहरण के लिए N = 11 यह सही अनुक्रम होगा।

धारणा के साथ

ए, ए, ए, ए, ए, सी, एस, वी, वी, वी, वी: 20:

बिना धारणा के

ए, ए, ए, सी, एस, वी, वी, सी, एस, वी, वी: 27:

मैंने इस समाधान के लिए धारणा को बनाए रखने का फैसला किया है।

---

कीस्ट्रोक किंवदंती:

'ए' - ए

'C' - Ctrl + A

'S' - Ctrl + C

'V' - Ctrl + V

---

कोड:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void maxAprinted(int count, int maxKeys, int op, int printed, int pOutput, int *maxPrinted, char *seqArray)
{
    if(count > maxKeys)
        return;

    if(count == maxKeys)
    {
        if((*maxPrinted) < printed)
        {
            //new sequence found which is an improvement over last sequence
            (*maxPrinted) = printed;

            printf("\n");
            int i;
            for(i=0; i<maxKeys; i++)
                printf(" %c,",seqArray[i]);
        }

        return;
    }

    switch(op)
    {
        case 1:
        //A keystroke
            printed++;

            seqArray[count] = 'A';
            count++;
            break;

        case 2:
        //Ctrl-A and then Ctrl-C
            if((count+2) < maxKeys)
            {
                pOutput = printed;

                //comment the below statement to NOT factor 
                //in the assumption described above
                printed = 0;    
            }

            seqArray[count] = 'C';
            count++;
            seqArray[count] = 'S';
            count++;
            break;

        case 3:
        //Ctrl-V
            printed = printed + pOutput;

            seqArray[count] = 'V';
            count++;
            break;
    }

    maxAprinted(count, maxKeys, 1, printed, pOutput, maxPrinted, seqArray);
    maxAprinted(count, maxKeys, 2, printed, pOutput, maxPrinted, seqArray);
    maxAprinted(count, maxKeys, 3, printed, pOutput, maxPrinted, seqArray);    
}

int main()
{
    const int keyStrokes = 11;

    //this array stores the sequence of keystrokes
    char *sequence;
    sequence = (char*)malloc(sizeof(char)*(keyStrokes + 1));

    //stores the max count for As printed for a sqeuence
    //updated in the recursive call.
    int printedAs = 0;

    maxAprinted(0, keyStrokes,  1, 0, 0, &printedAs, sequence);

    printf(" :%d:", printedAs);

    return 0;
}    

Answer 11

ऊपर दिए गए उत्तरों में उल्लिखित ट्रिक का उपयोग करके गणितीय रूप से, समाधान को एक समीकरण में समझाया जा सकता है,

4 + 4 ^ [(एन -4) / 5] + ((एन -4)% 5) * 4 ^ [(एन -4) / 5]। जहां [] सबसे बड़ा पूर्णांक कारक है

Answer 12

मुद्रण mA की मैन्युअल रूप से छपाई, फिर Ctrl+ A, Ctrl+ Cऔर Nm-2 Ctrl+ का उपयोग करने के बीच एक व्यापार बंद है V। सबसे अच्छा समाधान बीच में है। यदि अधिकतम कुंजी स्ट्रोक = 10, सबसे अच्छा समाधान 5 ए या 4 ए टाइप कर रहा है।

इस का उपयोग करके देखें इस http://www.geeksforgeeks.org/how-to-print-maximum-number-of-a-using-given-four-keys/ पर नज़र डालें और शायद मध्य के आसपास के परिणामों की तलाश में थोड़ा सा अनुकूलन करें बिंदु।

Answer 13

यहां नेस्टेड लूप के बिना, डायनेमिक प्रोग्रामिंग के साथ मेरा समाधान है, और जो वास्तविक पात्रों को प्रिंट करता है जिन्हें आपको टाइप करना होगा:

N = 52

count = [0] * N
res = [[]] * N
clipboard = [0] * N

def maybe_update(i, new_count, new_res, new_clipboard):
  if new_count > count[i] or (
      new_count == count[i] and new_clipboard > clipboard[i]):
    count[i] = new_count
    res[i] = new_res
    clipboard[i] = new_clipboard

for i in range(1, N):
  # First option: type 'A'.
  # Using list concatenation for 'res' to avoid O(n^2) string concatenation.
  maybe_update(i, count[i - 1] + 1, res[i - 1] + ['A'], clipboard[i - 1])

  # Second option: type 'CTRL+V'.
  maybe_update(i, count[i - 1] + clipboard[i - 1],  res[i - 1] + ['v'],
               clipboard[i - 1])

  # Third option: type 'CTRL+A, CTRL+C, CTRL+V'.
  # Assumption: CTRL+V always appends.
  if i >= 3:
    maybe_update(i, 2 * count[i - 3],  res[i - 3] + ['acv'], count[i - 3])

for i in range(N):
  print '%2d %7d %6d %-52s' % (i, count[i], clipboard[i], ''.join(res[i]))

यह आउटपुट है ('a' का अर्थ 'CTRL + A', आदि)

 0       0      0                                                     
 1       1      0 A                                                   
 2       2      0 AA                                                  
 3       3      0 AAA                                                 
 4       4      0 AAAA                                                
 5       5      0 AAAAA                                               
 6       6      3 AAAacv                                              
 7       9      3 AAAacvv                                             
 8      12      3 AAAacvvv                                            
 9      15      3 AAAacvvvv                                           
10      18      9 AAAacvvacv                                          
11      27      9 AAAacvvacvv                                         
12      36      9 AAAacvvacvvv                                        
13      45      9 AAAacvvacvvvv                                       
14      54     27 AAAacvvacvvacv                                      
15      81     27 AAAacvvacvvacvv                                     
16     108     27 AAAacvvacvvacvvv                                    
17     135     27 AAAacvvacvvacvvvv                                   
18     162     81 AAAacvvacvvacvvacv                                  
19     243     81 AAAacvvacvvacvvacvv                                 
20     324     81 AAAacvvacvvacvvacvvv                                
21     405     81 AAAacvvacvvacvvacvvvv                               
22     486    243 AAAacvvacvvacvvacvvacv                              
23     729    243 AAAacvvacvvacvvacvvacvv                             
24     972    243 AAAacvvacvvacvvacvvacvvv                            
25    1215    243 AAAacvvacvvacvvacvvacvvvv                           
26    1458    729 AAAacvvacvvacvvacvvacvvacv                          
27    2187    729 AAAacvvacvvacvvacvvacvvacvv                         
28    2916    729 AAAacvvacvvacvvacvvacvvacvvv                        
29    3645    729 AAAacvvacvvacvvacvvacvvacvvvv                       
30    4374   2187 AAAacvvacvvacvvacvvacvvacvvacv                      
31    6561   2187 AAAacvvacvvacvvacvvacvvacvvacvv                     
32    8748   2187 AAAacvvacvvacvvacvvacvvacvvacvvv                    
33   10935   2187 AAAacvvacvvacvvacvvacvvacvvacvvvv                   
34   13122   6561 AAAacvvacvvacvvacvvacvvacvvacvvacv                  
35   19683   6561 AAAacvvacvvacvvacvvacvvacvvacvvacvv                 
36   26244   6561 AAAacvvacvvacvvacvvacvvacvvacvvacvvv                
37   32805   6561 AAAacvvacvvacvvacvvacvvacvvacvvacvvvv               
38   39366  19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacv              
39   59049  19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvv             
40   78732  19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvv            
41   98415  19683 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvvv           
42  118098  59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacv          
43  177147  59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv         
44  236196  59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvv        
45  295245  59049 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvvv       
46  354294 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacv      
47  531441 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv     
48  708588 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvv    
49  885735 177147 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvvv   
50 1062882 531441 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacv  
51 1594323 531441 AAAacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvvacvv 

Answer 14

यदि एन कुंजी स्ट्रोक की अनुमति है, तो परिणाम एन -3 है।

ए -> एन -3

CTRL+ A-> उन N वर्णों का चयन: +1

CTRL+ C-> उन N वर्णों की प्रतिलिपि बनाना: +1

Ctrl+ V-> एन अक्षर चिपकाना। : +1 अर्थात, (चूंकि हमने CTRL+ का उपयोग करके पूरे वर्णों का चयन किया है A) इन मौजूदा N-3 वर्णों को कॉपी किए गए N-3 वर्णों के साथ प्रतिस्थापित किया जा रहा है (जो समान वर्णों को ओवरराइड कर रहा है) और परिणाम N-3 है।

Comments

StackOverflow में आपका स्वागत है! सामग्री स्वरूपण जोड़ना सीखें और संभवतः वास्तविक तीर प्रतीक का उपयोग करें →। इससे आपके उत्तर की पठनीयता में सुधार होगा!

— एम। मिम्पेन