ब्रूट-बल स्विचबोर्ड

Question

दूसरे दिन, हमारी टीम एक भागने वाले कमरे में गई। पहेली में से एक में छह यांत्रिक स्विच का एक बोर्ड शामिल था जहां आपको एक बॉक्स को अनलॉक करने के लिए चालू और बंद का सही संयोजन खोजना था, कुछ इस तरह से:

-v-v-v-
-v-v-v-

डेवलपर्स होने के नाते, हमने फैसला किया कि यह वास्तव में पहेली को हल करने की तुलना में 2 ^ 6 = 64 संयोजनों में से हर एक को आज़माने के लिए अधिक कुशल होगा। इसलिए हमने कुछ गरीबों को कुछ बाइनरी काउंटिंग करने के लिए सौंपा:

-v-v-v-
-v-v-v-

-v-v-v-
-v-v-^-

-v-v-v-
-v-^-v-

-v-v-v-
-v-^-^-

और इसी तरह।

चुनौती
एक प्रोग्राम लिखें जो स्विच ऑफ स्थिति में सभी को ऊपर दिए गए स्ट्रिंग के रूप में दिया गया हो, किसी भी क्रम में चालू और बंद के सभी संयोजनों को उत्पन्न करता है।

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

इनपुट स्ट्रिंग्स रेगेक्स से मेल खाएंगे r'((-v)+-)(\n(-v)+-)*'और सभी स्विचों के साथ एक बोर्ड का प्रतिनिधित्व करेंगे । इसका मतलब कोई शून्य मामला नहीं है, और स्विच बाएं-संरेखित हैं। प्रत्येक पंक्ति में समान स्विच नहीं हो सकते हैं।

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

चूंकि रनटाइम स्विच की संख्या में स्वाभाविक रूप से O (2 ^ n) है, आपके कोड को किसी भी व्यवस्था में 10 से अधिक स्विच पर परीक्षण नहीं किया जाएगा।

यह कोड-गोल्फ है, इसलिए बाइट्स की संख्या में सबसे कम कोड जीतता है।

नमूना इनपुट और आउटपुट

इनपुट:

-v-

संभावित उत्पादन:

-v-
-^-

इनपुट:

-v-
-v-

संभावित उत्पादन:

-^-
-^-
-^-
-v-

-v-
-^-


-v-
-v-

चूंकि बड़ी संख्या में स्विच के लिए आपके उत्तर की जांच करना बहुत कठिन है, यहाँ एक पवित्र जाँच उपकरण के रूप में पायथन लिपि है। (मैंने एक वर्तमान में टिप्पणी की गई स्निपेट को किसी दिए गए इनपुट फ़ाइल से अपेक्षित आउटपुट उत्पन्न करने के लिए शामिल किया है यदि आप अधिक परीक्षण मामले चाहते हैं।) यह विशेष रूप से कल्पना की तुलना में इनपुट और आउटपुट के मामले में काफी कम लचीला है; इनपुट स्ट्रिंग को 'इनपुट' नाम की फाइल में डालें और उसी निर्देशिका में 'आउटपुट' नाम की फाइल में न्यूलाइन-सेपरेटेड आउटपुट (सॉरी, नो लिस्ट फॉर्मेटिंग) डालें और चलाएं python3 sanitycheck.py।

Comments

अच्छी पहली चुनौती!

— गिउसेप्पे

उम्मीद है, "गरीब आदमी" ग्रे कोड के बारे में जानता था ताकि प्रत्येक संयोजन के बीच केवल एक बिट फ्लिप हो।

— एरिक डुमिनील

समय हमारी सबसे कीमती संपत्ति है, इसे व्यर्थ मत गंवाओ।

— पेड्रो लोबिटो

विषय को देखते हुए, मैं निराश हूं कि आपको एक ऐसे आदेश की आवश्यकता नहीं है जिसके लिए कम से कम टॉगल की आवश्यकता हो (जैसे 00-> 01-> 11-> 10 में 3 टॉगल हैं, जबकि 00-> 01-> 10-> 11 में 4 हैं ) - फैलो ब्रूट फोर्स एस्कैपर

— ikegami

@EricDuminil: यदि यांत्रिक स्विच बटन नहीं थे (और शायद हो भी सकता है), तो सबसे अधिक संभावना है, अंतर एक, दो और तीन लगातार स्विच करने के बीच के समय की आवश्यकता है (जो आप शायद लगभग एक साथ कर सकते हैं) बहुत बड़ा नहीं होगा ग्रे कोड का पालन करने के लिए अतिरिक्त मानसिक कार्य को ऑफसेट करना।

— टॉमस जूल

Answer 1

हास्केल , 25 24 23 17 बाइट्स

mapM$min"^v".pure

इसे ऑनलाइन आज़माएं!

-1 बाइट धन्यवाद @ H.PWiz

-1 बाइट @ @ मिमी के लिए धन्यवाद

तार की सूची लौटाता है। TIO में फंक्शन डिक्लेरेशन के लिए 2 अतिरिक्त बाइट्स हैं - मैंने देखा है कि अन्य लोग इसे छोड़ देते हैं जब वे फंक्शन पॉइंटफ्री लिखते हैं तो मैं वही कर रहा हूं जब तक कि अन्यथा न बताया जाए।

पिछला उत्तर (25 बाइट्स)

g 'v'="v^"
g x=[x]
mapM g

स्पष्टीकरण पिछले जवाब के लिए सभी हैं, जो उसी तरह से बहुत अधिक काम करता है, सिवाय मैंने इसकी परिभाषा को रेखांकित किया है g। जिस तरह से gअब काम करता है वह विकल्प के ^vलिए शाब्दिक तुलना का उपयोग करके है vऔर बाकी सब कुछ उसी तरह रखें।

दिलचस्प है, यह मनमाने ढंग से स्विचबोर्ड के लिए काम करता है:

>>> mapM g "-----^-----"
  ["-----v-----", "-----^-----"]

स्पष्टीकरण (लघु)

g 'v'="v^" -- for 'v', choose between 'v' or '^'
g x=[x]    -- for any other character, choose just that character
mapM g     -- find all ways to choose characters using g on the given input

स्पष्टीकरण (लंबा)

mapMहास्केल से परिचित नहीं लोगों के लिए एक बहुत डरावना कार्य है। लेकिन इस संदर्भ में समझना कठिन नहीं है। इसे Stringएस पर काम करके (जो हास्केल पात्रों की सूची हैं), मैंने इसे सूचियों के लिए इसकी परिभाषा के लिए विशेष कर दिया है। तो इस संदर्भ में, इसका प्रकार हस्ताक्षर है

mapM :: (a -> [b]) -> [a] -> [[b]]
--      ^^^^^^^^^^                  arg 1: a function from any a to a list of b
--                    ^^^           arg 2: a list of a
--                           ^^^^^ return: a list of list of b

यह वास्तव में इसके उपयोग में और भी अधिक विशिष्ट है - aऔर bदोनों हैं Char- इसलिए हम इस प्रकार के हस्ताक्षर देख सकते हैं

mapM :: (Char -> String) -> String -> [String]

आइए जल्दी से देखें कि gकैसे mapMकाम करता है यह समझाने से पहले ।

g :: Char -> String
g 'v' = "v^"
g  x  = [x]

gChar 'v'स्ट्रिंग में परिवर्तित करने के लिए पैटर्न मिलान का उपयोग करता है "v^"; बाकी सब कुछ एक सिंगलटन स्ट्रिंग में परिवर्तित हो जाता है (याद रखें, तार सिर्फ एस की सूची है Char, इसलिए हम xएक सिंगलटन सूची में डाल सकते हैं )। REPL पर परीक्षण, हम पाते हैं कि यह मामला है

>>> g 'a'
  "a"
>>> g 'b'
  "b"
>>> g 'v'
  "v^"

ध्यान दें कि gएक तर्क का सही प्रकार है mapM(बिना सोचे समझे!)।

हम यह बताएंगे कि mapMयह कैसे काम करता हैg और तर्क

"-v-\n-v-"

इनपुट के रूप में।

mapMपहले नक्शे gपर String, और क्योंकि एस करने के लिए gधर्मान्तरित , यह हमें की एक सूची देता हैCharStringsStrings

["-", "v^", "-", "\n", "-", "v^", "-"]

जबकि यह सही आउटपुट प्रकार है, mapMथोड़ा और अधिक करता है। आप इसे सभी के रूप में सोच सकते हैंStringयदि आप इस सूची से बना सकते हैं, तो आप सकते हैं यदि आपको Stringइसमें (क्रम में) प्रत्येक से एक ही चरित्र चुनना था ।

तो पहले तत्व के लिए, आपके पास इसे लेने के अलावा कोई विकल्प नहीं है Char '-'। दूसरे तत्व के लिए, आप चुन सकते हैं'v' और '^'पर इतना और इतना आगे।

यह लगभग इस अजगर कोड के बराबर है:

result = []
for x1 in "-":
  for x2 in "v^":
    for x3 in "-":
      ...
        result.append(''.join([x1, x2, x3, x4, x5, x6, x7]))

सिवाय इसके कि जब हास्केल Charएस और Stringएस के बीच अलग हो जाता है, जब यह डाल देता हैChar एस को एक सूची में , तो joinउन्हें इसकी आवश्यकता नहीं है।

तो अंतिम आउटपुट है

["-v-\n-v-", "-v-\n-^", "-^-\n-v-", "-^-\n-^-"]

जैसी इच्छा।

Comments

ओह, मैं एक विशुद्ध रूप से कार्यात्मक उत्तर की प्रतीक्षा कर रहा हूं, इसने मुझे वास्तव में उड़ा दिया कि यह कितना संक्षिप्त था।

— रिन का फूरियर

@ रिनफॉरिएंट्रांसफॉर्म मैं mapMइस चुनौती के लिए कितनी अच्छी तरह से काम कर रहा था, मैं पहले से ही इसे तैयार कर चुका था, sequence . map gलेकिन जैसा कि इसे कॉम्पैक्ट रूप से व्यक्त किया जा सकता है mapM id . map gऔर फिर मैंने देखा कि मैं सिर्फmapM g

— Cole

मुझे लगता है कि आप स्वैप कर सकते हैं =='v'के लिए>'-'

— H.PWiz

Answer 2

पर्ल 6 , 32 बाइट्स

{[X~] .comb».&{$_,('^'if /v/)}}

इसे ऑनलाइन आज़माएं!

• .comb स्ट्रिंग को वर्णों में विभाजित करता है।
• ».&{...} ब्रेसिज़ के बीच फ़ंक्शन के अनुसार पात्रों को मैप करता है।
• $_, ('^' if /v/)प्रत्येक वर्ण के लिए विकल्पों की एक सूची तैयार करता है। केवल vएक विकल्प है ^:।
• [X~]स्ट्रिंग-संघनन क्रॉस-उत्पाद ऑपरेटर के साथ उस सूची को कम करता है X~।

Answer 3

जेली , 7 बाइट्स

«Ƭ€”^Œp

इसे ऑनलाइन आज़माएं!

आउटपुट जेली स्ट्रिंग्स की एक सूची है।

स्पष्टीकरण:

«Ƭ€”^Œp  Arguments: 1
«Ƭ€”^    Dyad-nilad pair
  €       Map over left argument
 Ƭ         Apply repeatedly until a result that has previously been seen is seen
           again, return original and intermediate results
«           Dyad: Minimum of arguments
   ”^     Nilad: Literal: '^'
         Note: 'v' is the only character that is greater than '^' and can
         appear in the input, so, while for every character c other than 'v'
         this operation returns [c], for 'v' it returns ['v', '^']. In this way,
         duplicates are never going to appear in the output.
     Œp  Monad: Cartesian product of elements

Comments

मैं वास्तव में जेली कोड पृष्ठों के माध्यम से यह पता लगाने की कोशिश कर रहा हूं कि पहले उत्तर ने हर एक दूसरे उत्तर को लगातार कैसे बढ़ाया है, लगभग हमेशा एक बहुत अच्छे अंतर से ... क्या आप यह समझाने की परवाह करेंगे कि यह कैसे काम करता है?

— रिन का फूरियर

@ रिन के फाउटरट्रांसफॉर्म मैंने एक स्पष्टीकरण जोड़ा है।

— निकोलग्राफ

Answer 4

पर्ल 5 , 29 बाइट्स

sub{glob"\Q@_"=~s/v/{v,^}/gr}

इसे ऑनलाइन आज़माएं!

मेरा पहला सबमिशन!

---

आम तौर पर, पर्ल 5 गोल्फर sub{}न्यूनतम पर शामिल होने से बचाने के लिए कार्यों के बजाय कार्यक्रम प्रस्तुत करते हैं । लेकिन वे जोड़ने के लिए say, say␠, say forया say for␠विदेशी मुद्रा में।

उप दृष्टिकोण पर जाकर, मैं छोटा कर सकता था

say for glob"\Q$_"=~s/v/{v,^}/gr        # Perl 5, -0n, 32 bytes

सेवा मेरे

sub{glob"\Q@_"=~s/v/{v,^}/gr}           # Perl 5, 29 bytes

---

स्पष्टीकरण काफी सरल है। पर्ल 5 में एक बिलिन globऑपरेटर होता है जो शेल-जैसे ग्लोब पैटर्न को स्वीकार करता है जिसका उपयोग फ़ाइल नाम (जैसे foo*.txt) या स्ट्रिंग्स की सूची (जैसे ) उत्पन्न करने के लिए किया जा सकता है {a,b,c}। पकड़ यह है कि न्यूलाइन को बचाना होगा, जिसे मैंने उपयोग किया है quotemeta(जैसा कि \Q)।

Answer 5

कश्मीर (NGN / ट) , 27 25 बाइट्स

{?(,/,/:\:)/x,'"^"/"v"\x}

इसे ऑनलाइन आज़माएं!

"^"/"v"\के "v"साथ बदलें"^"

x,' मूल वर्णों के साथ ज़िप करें

(,/,/:\:)/ कार्टेसियन उत्पाद खत्म

? uniq

Comments

.. और यहाँ मुझे लगता है कि मैं 44 बाइट्स में ठीक किया था!

— स्ट्रीट जूल

Answer 6

APL (Dyalog Classic) , 21 17 15 बाइट्स

⊃⊢∘.,.∪'v'⎕r'^'

इसे ऑनलाइन आज़माएं!

मेरे k समाधान के समान

स्ट्रिंग्स का एक n- आयामी सरणी देता है (स्विच की संख्या =)

फ़ॉर्म को समझाने में आसान: ⊃(∘.,⌿ ⊢ ∪¨ 'v'⎕r'^')

'v'⎕r'^'की जगह vके साथ ^रों

⊢ ∪¨... मूल पात्रों में से प्रत्येक के साथ यूनियनों। यह लंबाई 1 या 2 के तारों का एक वेक्टर है

∘.,⌿ कार्टेशियन उत्पाद में कमी

⊃ खुलासा

पूरी तरह से गोल्फ संस्करण में आने के लिए हम पैटर्न का पालन करते हैं f⌿ A g¨ B-> A f.g B:

∘.,⌿ ⊢ ∪¨ 'v'⎕r'^' -> ⊢ ∘.,.∪ 'v'⎕r'^'

एक पक्ष प्रभाव के रूप में कोष्ठक की अब आवश्यकता नहीं है

Comments

एक बाहरी उत्पाद आंतरिक उत्पाद के साथ कुछ भी +1 के योग्य है।

— एडम जूल

Answer 7

जे , 42 बाइट्स

]`('v'I.@e.~[)`[}"1'v^'{~2#:@i.@^1#.e.&'v'

इसे ऑनलाइन आज़माएं!

व्याख्या

]`('v' I.@e.~ [)`[}"1 ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')

लेने दो

-v-
-v-

हमारे उदाहरण इनपुट के रूप में।

• ('v^' {~ 2 #:@i.@^ 1 #. e.&'v')इनपुट प्रारूप को अनदेखा करते हुए, बस स्विच के सभी संभव कॉम्बो बनाता है। हमारे उदाहरण के लिए यह उत्पादन:

  vv
  v^
  ^v
  ^^
  

  • 1 #. e.&'v'vइनपुट में s की संख्या गिनता है ।
  • 2 #:@i.@^, कि सत्ता में 2 को जन्म देती है 0 से पूर्णांकों का उत्पादन है कि संख्याi. है, और उन्हें बाइनरी में धर्मान्तरित#:
  • 'v^' {~बाइनरी अंकों में परिवर्तन vऔर^
• ]`('v' I.@e.~ [)`[}"1मूल इनपुट में संशोधन करता है, पिछले चरण में वर्णित परिणाम की प्रत्येक पंक्ति के लिए इसकी एक प्रति का उत्पादन करता है (यानी, सभी संभव v/ ^कॉम्बोस)। प्रत्येक कॉपी में vमूल इनपुट v/ के एक संभावित अनुक्रम के साथ प्रतिस्थापित किया जाता है ^।

Answer 8

जावा, 202 197 189 191 बाइट्स

हां, यह तुलनात्मक रूप से मौखिक भाषा है, लेकिन यही मैं शास्त्रीय गोल्फिंग के रूप में मानता हूं:

import java.util.function.Function;

public class SwitchBored
{
    public static void main(String[] args)
    {
        Function<String, String> f = s->{byte i,j,k,m=1,u='^',d='v',a[]=(s+"\n\n").getBytes();for(i=0,s="";i<m;i++,s+=new String(a))for(j=0,k=0;k<a.length;k++){if(a[k]==d||a[k]==u){a[k]=(i&1<<j++)!=0?u:d;m<<=i>0?0:1;}}return s;};

        //System.out.println(f.apply("-v-"));
        System.out.println(f.apply("-v-v-v-\n-v-v-v-"));
        //System.out.println(f.apply("-v-v-v-\n-v-v-"));
        //System.out.println(f.apply("-v-v-v-v-v-\n-v-"));
        //System.out.println(f.apply("-v-v-v-v-v-\n-v-v-v-v-v-"));
    }
}

मैंने सोचा था कि लाइन लेआउट से निपटने का एक "सरल" तरीका जो उचित लेआउट को प्राप्त करने के लिए आवश्यक है, वास्तव में मूल इनपुट चरित्र सरणी का फिर से उपयोग करना है, और केवल इसे 'v'एस और के साथ भरना है'^' उपयुक्त पदों पर एस के ।

अपडेट:

यह पता चला है कि पदों को संग्रहीत नहीं करने से intऔर सरणी चर घोषणाओं को कम करने की अनुमति मिलती है (सरणी की प्रत्येक स्थिति की जांच करने की लागत चाहे वह एक हो vया ^मक्खी पर), 5 बाइट्स बचाती है।

एक और 8 बाइट्स ऊपरी सीमा को (1<<numberOfSwitches)अधिक कॉम्पैक्ट रूप से गणना करके सहेजे गए हैं ।

टिप्पणी में उल्लिखित नियम के अनुसार, फ़ंक्शन घोषणा को गिना जाना चाहिए, इसलिए अब यह लंबोदर है ...

Comments

मुझे पूरा यकीन है कि आपको String generate(String s) {...}अपने बाइट की गिनती में फ़ंक्शन परिभाषा ( ) को शामिल करना होगा । यहाँ 191 बाइट्स के लिए एक निश्चित / लैम्ब्डा संस्करण है । मैंने 3 बाइट्स से दाढ़ी बनाने के लिए कुछ मामूली गोल्फिंग की

— बेंजामिन अर्कहार्ट

@BenjaminUrquhart ठीक है, ये "नियमों" का विवरण है, जिससे मैं परिचित नहीं हूँ (मैं नियमित रूप से यहाँ गोल्फ नहीं खेल रहा हूँ)। मैंने सोचा था कि वास्तविक { function body }प्रासंगिक होना चाहिए, क्योंकि इससे कोई फर्क नहीं पड़ता कि आपने इसे एक फ़ंक्शन में रखा है staticया नहीं, और निश्चित रूप से, यदि घोषणा स्कोर की ओर गिना जाता है, तो कोई इसे लंबोदर अभिव्यक्ति में बदल सकता है। लेकिन अभी जो किया गया है, यह इंगित करने के लिए धन्यवाद।

— मार्को 13

कुछ सुझाव: 1. एससी-कोड का उपयोग करें, चार्ट ( d=94) नहीं। 2. iघोषणा जब आप इसे घोषित करते हैं। 3. i++<mअलग-अलग वेतन वृद्धि के बजाय उपयोग करें (एक स्थान पर लूप की सामग्री को संशोधित करने की आवश्यकता है, लेकिन यह कोई लागत नहीं जोड़ता है)। 4. क्या आप दूर जा सकते हैं (i&1<<j++)>0? 5. मुझे नहीं लगता कि आपको {}आंतरिक forलूप की आवश्यकता है। 6. आप बदल सकते हैं a[k]==d||a[k]==uके साथ a[k]>45, मुझे लगता है। 7. साथ जाओ j=k=0। वह सब जो 19bytes को निकालना चाहिए।

— विजुअलमेलन

@VisualMelon इनमें से कुछ "शास्त्रीय गोल्फिंग" दृष्टिकोण हैं, और मैंने उनमें से कुछ को पहले ही लागू कर दिया है। वे लागू होते हैं या नहीं यह निर्भर करता है - मुझे लगता है कि कुछ {}आवश्यक हैं, लेकिन मैं एक और नज़र रख सकता हूं। a[k]>45एक साफ चाल हालांकि हो सकता है। बेशक, मैंने इसे शुरू करने के लिए एक बैठक के इंतजार में कुछ समय बर्बाद करने के लिए लिखा था (इसलिए वर्ग का नाम - यह जानबूझकर; ;-)) लेकिन शायद मुझे एक और नज़र होगी - किसी भी मामले में धन्यवाद!

— मार्को 13

@ Marco13 वास्तव में, वे क्लासिक चालें हैं, लेकिन सभी विशेष रूप से यहां लागू होते हैं। मैं आपको उनके आधार पर मेरा 172 बाइट समाधान देकर मज़ा खराब नहीं करूँगा (यह बीटीडब्ल्यू, ऐसा लगता है कि आपका 192 है, 191 नहीं है, लेकिन मुझे नहीं पता कि लैम्ब्डा गिनती कैसे काम करती है: मैं किसी भी मामले में इसका विरोध करता हूं। )।

— विजुअलमेल

Answer 9

जम्मू , 41 40 24 बाइट्स

[:>@,@{<@(,'^'$~'v'=])"0

इसे ऑनलाइन आज़माएं!

Comments

बहुत प्रभावशाली। के उपयोग से प्यार है {। हालांकि मुझे लगता है कि [:>@,@{<@(,'^'$~'v'=])"0"प्रत्येक आउटपुट बोर्ड इनपुट के समान सटीक प्रारूप का होना चाहिए" और इनपुट बॉक्सिंग नहीं होने के कारण थोड़ा अधिक उचित होगा।

— योना

@ जोना धन्यवाद ठीक कर दिया।

— 23

Answer 10

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

def f(s):i=s.find('v');return(i>=0and f(s[:i].replace('^','v')+'^'+s[i+1:])+'\n'or'')+s

इसे ऑनलाइन आज़माएं!

एक गैर-रेगेक्स दृष्टिकोण।

Comments

एक तरह से मेरा, अच्छा काम से अधिक संक्षिप्त दृष्टिकोण!

— २०:४०

Answer 11

सी (जीसीसी) , 75 74 70 बाइट्स

-5 बाइट थैंक्स टू @ceilingcat

*b=0;f(char*s){b=b?b:s;*s?f(s+1),*s>46?*s=94,f(s+1),*s='v':0:puts(b);}

इसे ऑनलाइन आज़माएं!

स्मृति sबिंदुओं को लिखने योग्य बनाने की आवश्यकता होती है

Comments

@cielingcat सही है: tio.run/##S9ZNT07@/z85I7FIK8nWwDpNA8ws1qxOsk2yT7IqttYqtk/…

— ब्रायन मिंटन

@ ब्रायनमिंटन वास्तव में। और मैंने यह कोशिश करने के बारे में कभी नहीं सोचा होगा। अच्छा!

— ngn

Answer 12

पायथन 3.8 (पूर्व-रिलीज़) , 129 117 116 110 106 बाइट्स

-10 बाइट्स @ धन्यवाद ब्राउन

f=lambda s:{s.replace('v','{}').format(*['v^'[c<'1']for c in bin(x+i)[::-1]])for i in range(x:=1<<len(s))}

इसे ऑनलाइन आज़माएं!

Comments

PPCG में आपका स्वागत है! एक समान विचार का उपयोग करते हुए 123 बाइट्स ।

— चास ब्राउन

119 बाइट्स (इस टिप्पणी में पहले गलत लिंक)।

— चास ब्राउन

Answer 13

सी (जीसीसी) , 102 बाइट्स

i,j,l;f(char*s){for(l=j=0;l++<1<<j;puts(""))for(i=j=0;s[i];i++)putchar(s[i]>64?l&1<<j++?118:94:s[i]);}

इसे ऑनलाइन आज़माएं!

Answer 14

K4 , 44 बाइट्स

समाधान:

-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2};

उदाहरण:

q)k)-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-";
-v-
-^-

q)k)-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-\n-v-";
-v-
-v-
-v-
-^-
-^-
-v-
-^-
-^-

q)k)-1{@[x;&w;:;]@/:"v^"@a\:'!*/a:(+/w:"v"=x)#2}"-v-v-\n-v-v-v-\n-v-";
-v-v-
-v-v-v-
-v-
-v-v-
-v-v-v-
-^-
-v-v-
-v-v-^-
-v-
-v-v-
-v-v-^-
-^-
-v-v-
-v-^-v-
-v-
-v-v-
-v-^-v-
-^-
-v-v-
-v-^-^-
-v-
-v-v-
-v-^-^-
-^-
-v-v-
-^-v-v-
-v-
-v-v-
-^-v-v-
-^-
-v-v-
-^-v-^-
-v-
-v-v-
-^-v-^-
-^-
-v-v-
-^-^-v-
-v-
-v-v-
-^-^-v-
-^-
-v-v-
-^-^-^-
-v-
-v-v-
-^-^-^-
-^-
-v-^-
-v-v-v-
-v-
-v-^-
-v-v-v-
-^-
-v-^-
-v-v-^-
-v-
-v-^-
-v-v-^-
-^-
-v-^-
-v-^-v-
-v-
-v-^-
-v-^-v-
-^-
-v-^-
-v-^-^-
-v-
-v-^-
-v-^-^-
-^-
-v-^-
-^-v-v-
-v-
-v-^-
-^-v-v-
-^-
-v-^-
-^-v-^-
-v-
-v-^-
-^-v-^-
-^-
-v-^-
-^-^-v-
-v-
-v-^-
-^-^-v-
-^-
-v-^-
-^-^-^-
-v-
-v-^-
-^-^-^-
-^-
-^-v-
-v-v-v-
-v-
-^-v-
-v-v-v-
-^-
-^-v-
-v-v-^-
-v-
-^-v-
-v-v-^-
-^-
-^-v-
-v-^-v-
-v-
-^-v-
-v-^-v-
-^-
-^-v-
-v-^-^-
-v-
-^-v-
-v-^-^-
-^-
-^-v-
-^-v-v-
-v-
-^-v-
-^-v-v-
-^-
-^-v-
-^-v-^-
-v-
-^-v-
-^-v-^-
-^-
-^-v-
-^-^-v-
-v-
-^-v-
-^-^-v-
-^-
-^-v-
-^-^-^-
-v-
-^-v-
-^-^-^-
-^-
-^-^-
-v-v-v-
-v-
-^-^-
-v-v-v-
-^-
-^-^-
-v-v-^-
-v-
-^-^-
-v-v-^-
-^-
-^-^-
-v-^-v-
-v-
-^-^-
-v-^-v-
-^-
-^-^-
-v-^-^-
-v-
-^-^-
-v-^-^-
-^-
-^-^-
-^-v-v-
-v-
-^-^-
-^-v-v-
-^-
-^-^-
-^-v-^-
-v-
-^-^-
-^-v-^-
-^-
-^-^-
-^-^-v-
-v-
-^-^-
-^-^-v-
-^-
-^-^-
-^-^-^-
-v-
-^-^-
-^-^-^-
-^-

स्पष्टीकरण:

यथा-स्थान के प्रतिस्थापन "^"। स्विच के संयोजनों की संख्या निर्धारित करें (जैसे 2 ^ n), बाइनरी में गणना करें, स्विच को बदलें ...

-1{@[x;&w;:;]@'"v^"@a\:'!*/a:(+/w:"v"=x)#2}; / the solution
-1                                         ; / print to STDOUT, swallow -1
  {                                       }  / lambda taking implicit x
                                        #2   / take 2
                             (         )     / do this together
                                  "v"=x      / does input = "v" ?
                                w:           / save as w
                              +/             / sum up
                           a:                / save as a
                         */                  / product
                        !                    / range 0..n
                    a\:'                     / convert each to base-2
               "v^"@                         / index into "v^"
             @'                              / apply each
   @[x;&w;:;]                                / apply assignment to x at indexes where w is true

Answer 15

आर , 116 बाइट्स

function(x,u=utf8ToInt(x))apply(expand.grid(rep(list(c(118,94)),sum(u>45))),1,function(i)intToUtf8(`[<-`(u,u>45,i)))

इसे ऑनलाइन आज़माएं!

नई लाइन से अलग बोर्डों के एक वेक्टर लौटाने का कार्य

Comments

आह, मैं बहुत कठिन तरीके से इनपुट लेने पर ध्यान केंद्रित कर रहा था कि मैंने इस एक की सहजता की उपेक्षा की। का अच्छा उपयोग "[<-"!

— गिउसेप्पे

@Giuseppe: मैं इस समाधान से बहुत संतुष्ट नहीं हूँ ... लेकिन मैंने अन्य तरीकों से संयोजनों को उत्पन्न करने की कोशिश की (जैसे द्विआधारी रूपांतरण का उपयोग करके) लेकिन यह सबसे कम समय तक समाप्त हो गया।

— डाइजेक्सिल

Answer 16

जावास्क्रिप्ट, 88 बाइट्स

s=>(g=n=>n--?g(n)+`
`+s.replace(/v/g,_=>'v^'[i=n&1,n>>=1,i]):'')(2**~-s.split`v`.length)

इसे ऑनलाइन आज़माएं!

Comments

n>>=1->n/=2

— ngn

Answer 17

रेटिना 0.8.2 , 29 बाइट्स

T`¶v`;#
+%1`#
v$'¶$`^
%`;|$
¶

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

T`¶v`;#

मार्करों में ;एस और vएस में newlines बदलें #।

+%1`#

#बाएं से दाएं एक समय में एक को बदलें ।

v$'¶$`^

प्रत्येक पंक्ति को दो लाइनों में बदलें, एक को एक के साथ #बदल दिया गयाv , एक के साथ, एक के साथ बदल दिया गया ^।

%`;|$
¶

;एस वापस newlines में बदलें और परिणामों को अलग रखें।

Answer 18

पर्ल 5 -0 , 51 बाइट्स

$_=<>;s/\s/P/g;s/v/{v,^}/g;say s/P|$/\n/gr for glob

इसे ऑनलाइन आज़माएं!

Comments

40 ( संस्करण 1

— ikegami

३ ९ ३ 39 ३२ २ ९

— ikegami

ओह, मूल टिप: प्रयोग -nकरने से जरूरत पड़ने पर बच जाता$_=<>;

— ikegami

Answer 19

जावास्क्रिप्ट (Node.js) , 80 73 68 बाइट्स

f=([x,...y],g=c=>f(y).map(z=>c+z))=>x?g(x).concat(x>'a'?g`^`:[]):[y]

इसे ऑनलाइन आज़माएं!

Answer 20

पायथन 3 - निर्माण, 203 बाइट्स

def f(a):
 b=[0]
 for l in a.split():b+=[b[-1]+l.count('v')]
 return'\n'.join(''.join(f"{k:b}".zfill(b[-1])[x:y]+'-\n'for x,y in zip(b,b[1:]))for k in range(2**b[-1])).replace('0','-v').replace('1','-^')

इसे ऑनलाइन आज़माएं!

पहली कोशिश, बहुत छोटी नहीं बल्कि काम करती है। पायथन में कोई सुरुचिपूर्ण स्ट्रिंग प्रतिस्थापन नहीं है ...

पहला लूप बिट सूचकांकों के लिए लाइनों की मैपिंग का निर्माण करता है, यानी प्रत्येक पंक्ति के लिए, बिट काउंटर में पहले बिट के सूचकांक को संग्रहीत किया जाता है। यह अगले लूप में बिट काउंटर को इंडेक्स करने के लिए उपयोग किया जाता है।

दूसरा लूप एक बाइनरी काउंटर चलाता है, प्रत्येक पंक्ति और पुनरावृत्ति के लिए बिट्स निकालता है और उन्हें जोड़ता है। सब कुछ एक साथ जुड़ने के बाद, यह स्ट्रिंग रिप्लेसमेंट का उपयोग करते हुए वापस स्विच मैप फॉर्मेट में अनुवादित होता है।

मुझे लगता है, इनपुट स्ट्रिंग को फिर से बनाने के बजाय इसे फिर से बनाने के द्वारा एक और अधिक सुंदर तरीका है।

संपादित करें: पायथन 3.8 उत्तर से प्रेरित है , यहां बहुत कम जगह का संस्करण है

पायथन 3 - प्रतिस्थापित, 123 बाइट्स

def f(a):r=range;n=a.count('v');return'\n'.join(a.replace('v','{}').format(*('v^'[k&2**i>0]for i in r(n)))for k in r(2**n))

इसे ऑनलाइन आज़माएं!

Answer 21

माणिक , 64 बाइट्स

Returns an array. Gets numbers from $1$ to $2^v$ (where $v$ is the number of "v" in the input) and flips switches based on the $v$ least significant bits. This allows us to save a byte over iterating from $0$ to $2^v-1$, because the $v$ least significant bits in $2^v$ are all zero.

In Ruby, i[j] returns the jth bit of i starting from the least significant bit, aka it is equivalent to (i>>j)&1.

->s{(1..2**s.count(?v)).map{|i|j=-1;s.gsub(/v/){'v^'[i[j+=1]]}}}

Try it online!

Answer 22

Charcoal, 28 bytes

⪫ＥＸ²№θv⭆θ⎇⁼λv§v^÷ιＸ²№…θμv붶

Try it online! Link is to verbose version of code. Explanation:

   ²                            Literal 2
  Ｘ                             Raised to power
    №                           Count of
      v                         Literal `v`
     θ                          In input string
 Ｅ                              Map over implicit range
        θ                       Input string
       ⭆                        Map over characters and join
           λ                    Current character
          ⁼                     Equal to
            v                   Literal `v`
         ⎇                      Then
              v^                Literal `v^`
             §                  Circularly indexed by
                 ι              Outer index
                ÷               Integer divided by
                   ²            Literal 2
                  Ｘ             Raised to power
                    №           Count of
                        v       Literal `v`
                      θ         In input string
                     …          Truncated to length
                       μ        Inner index
                         λ      Else current character
⪫                         ¶¶    Join with newlines
                                Implicitly print

Answer 23

PHP, 93 bytes

for(;$j<1<<$x;$j+=print$s)for($x=0,$s=$argv[1];$i=strpos($s,v,$i+1);$s[$i]=$j&1<<$x++?'^':v);

Try it online!

Standalone program, input via command line.

Loop the number of possible permutations of the input string based on the number of v's. While counting up in binary, replace each binary 1 with a ^ and each binary 0 with a v in the input string.