चिकना बनाम चंकी बनाम ब्रोकन स्किगल

Question

चंकी बनाम स्मूद स्ट्रिंग्स पर आधारित है ।

/\_/\/\__/\/\/\/\_/\_/\जब आप वास्तव में ऊब जाते हैं, तो एक कीबोर्ड पर स्क्विगल्स बनाने में मज़ा आता है। लेकिन सभी स्क्विगल्स समान नहीं बनाए जाते हैं। कुछ स्क्विगल्स चिकने, जैसे \___/, और कुछ चंकी होते हैं, जैसे /\/\/\/\। दूसरों की तरह सीधे टूट रहे हैं, जैसे////_\\\

Nपात्रों के हर स्क्विगल के अंदर , N-1स्क्वीगल-जंक्शन हैं। प्रत्येक स्क्वीगल-जंक्शन को तीन प्रकारों में वर्गीकृत किया गया है:

• चिकना (कोण> "90 डिग्री"):

  \_ __ _/

• चंकी (कोण = "90 डिग्री")

  /\ \/

• टूटी हुई (कुछ भी जो कनेक्ट नहीं होती है)

  // \\ /_ _\

चलो परिभाषित चिकनाई जंक्शनों कि चिकनी, साथ कर रहे हैं के अनुपात में होना करने के लिए chunkiness और brokenness इसी प्रकार परिभाषित। प्रत्येक मान के बीच है 0और 1। एक स्क्वीगल की चिकनाई, गुदगुदाहट और टूटने का योग हमेशा 1 के बराबर होता है।

उदाहरण के लिए, स्क्वीगल /\/\\_//\_में 3 चिकने जंक्शन, 4 चंकी जंक्शन और 2 टूटे जंक्शन हैं। यह इस प्रकार 0.3333चिकनी, 0.4444चंकी और 0.2222टूटी हुई है।

केवल एक वर्ण के साथ खाली तार और तार में अपरिभाषित मूल्य होते हैं, सभी इनपुट कम से कम 2 वर्ण लंबे होंगे।

चुनौती

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

• आप STDIN, कमांड लाइन, या एक स्ट्रिंग तर्क के रूप में इनपुट के साथ एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।
• आप मान सकते हैं कि इनपुट कम से कम लंबाई = = 2 है और इसमें केवल /\_एक वैकल्पिक अनुगामी न्यूलाइन है।
• प्रिंट करें (या यदि कोई फ़ंक्शन है तो) दो कम से कम 4 डेसीमल, गोल या छंटनी की सटीकता के लिए तैरते हैं। यदि सच्चा मूल्य है 2/3, तो स्वीकार्य मानों में 0.6666और 0.6667, जैसी चीजों के बीच कोई भी मूल्य शामिल है 0.666637104। यदि सटीक मान है 1/3, तो युक्त कोई भी उत्तर 0.3333मान्य है। यदि मान एक से कम है, तो आप अनुगामी शून्य, या अग्रणी शून्य छोड़ सकते हैं।
• अपनी पसंद के अनुसार तीनों में से किसी भी जोड़ी को आउटपुट करें, बस यह सुनिश्चित करें कि कौन से दो और किस क्रम में हैं।

बाइट्स में सबसे छोटा कोड जीतता है।

उदाहरण

/\/\\/\//\\→ चिकनापन 0, चुंकापन 0.7, टूटना0.3

_/\\_/\\/__/\\\//_→ चिकनापन 0.29411764705, चुंकापन 0.29411764705, टूटना0.41176470588

//\\__/_\/→ चिकनापन 0.3333333, चुंकापन 0.2222222, टूटना0.4444444

बोनस प्रश्न: आप किसे पसंद करते हैं, चिकनी या चंकी या टूटी हुई स्क्वीगल्स?

Comments

क्या तीनों को आउटपुट करने के लिए एक बोनस हो सकता है, या क्या आपके पास केवल दो को चुनने का एक विशिष्ट कारण है?

— ᴄʜᴇʀᴏɴғᴀɪʟ

@Callodacity 2 3 को परिभाषित करने के लिए पर्याप्त है क्योंकि वे

— ट्राइकोप्लाक्स

@trichoplax अच्छा बिंदु - जाहिर है मैं बहुत लंबे समय से गोल्फ खेल रहा हूं, मैं अब साधारण चीजों को समझ नहीं सकता: पी

— A16

Answer 1

पायथ, 25 बाइट्स

mcl@.:d2.:z2tlzc2"\__//\/

परीक्षण सूट

स्मूथनेस, चंकनेस को आउटपुट करता है। असल में, यह कठोर कोडित स्ट्रिंग लेता है और इसे आधे में काटता है। प्रत्येक आधे को इसके 2 वर्ण सब्सट्रिंग्स में विघटित किया जाता है, और इनपुट के लिए भी यही किया जाता है। हम चौराहे लेते हैं, जिसके परिणामस्वरूप दक्षिण और चंकी जोड़े हैं। फिर, हम लंबाई लेते हैं, जोड़े की संख्या से विभाजित करते हैं, और प्रिंट करते हैं।

Answer 2

जाप, 42 बाइट्स

U=U¬ä@2+"\\/\\__/"bX+Y)f2};[T2]£U¬fX l /Ul

आउटपुट टूटता है, chunkyness। इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

            // Implicit: U = input string
U=UŠ@   }  // Set U to U split into chars, with each pair mapped by this function:
"..."bX+Y)  // Take the index in this string of the two chars concatenated.
            // This is 0-1 for chunky, 2-4 for smooth, and -1 for broken.
2+    f2    // Add two and floor to the nearest multiple of 2.
            // This is now 2 for chunky, 4 or 6 for smooth, and 0 for broken.
[T2]£       // Map each item X in [0,2] through this function:
U¬fX l      //  Count the occurances of X in U.
/Ul         //  Divide by U.length.
            // Implicit: output last expression

गैर-प्रतिस्पर्धी संस्करण, 36 बाइट्स

U=Uä@2+"\\/\\__/"bZ)f2};[T2]£UèX /Ul

कुछ मामूली बदलावों के साथ मूल रूप से दूसरे के समान काम करता है:

• äअब स्ट्रिंग्स पर काम करता है। वर्ण क्रम में समारोह में पारित किए जाते हैं (X, Y, X+Y)।
• è स्ट्रिंग / सरणी में तर्क की घटनाओं की संख्या को गिना जाता है।

Answer 3

पायथन 3, 149 बाइट्स

यह स्मूथनेस और चंकीनेस को आउटपुट करता है।

def f(s):
 for i in"012":s=s.replace("\_/"[int(i)],i)
 a=len(s)-1;t=["bscbssbbc"[int(s[i:i+2],3)]for i in range(a)]
 for x in"sc":print(t.count(x)/a)

Ungolfed:

def f(s):
    for i in "012":
        s = s.replace("\_/"[int(i)], i)
    a = len(s) - 1
    t = []
    for i in range(a):
        t.append("bscbssbbc"[int(s[i:i+2],3)])
    for x in "sc":
        print(t.count(x) / a)

Answer 4

रूबी, 71

स्मूथनेस, चंकनेस को आउटपुट करता है।

न्यूनतम चिकनी और चंकी तार लेता है और प्रारंभिक स्ट्रिंग में प्रत्येक दो-वर्ण स्ट्रिंग के लिए उन्हें खोजता है।

आठ बाइट्स के लिए केविन लाउ के लिए धन्यवाद !

->x{%w{\\__/ /\\/}.map{|t|(0..n=x.size-2).count{|i|t[x[i,2]]}/(n+1.0)}}

Comments

(0..x.size-2).count{|i|t[x[i,2]]}5 बाइट्स बचाता है x.chars.each_cons(2).count{|i|t[i*'']}। और अब जब आप x.sizeफ़ंक्शन में दो बार उपयोग कर रहे हैं , तो इसे एक चर में निर्दिष्ट करना और इसका उपयोग करना अतिरिक्त बाइट बचाता है।

— वैल्यू इंक

@KevinLau अपने दृष्टिकोण का उपयोग कर 8 बाइट्स बचाने के लिए प्रबंधित। धन्यवाद!

— चार्ल्स