चंकी बनाम स्मूद स्ट्रिंग्स

29

लंबाई N की एक स्ट्रिंग पर विचार करें, जैसे कि Peanut ButterN = 13. ध्यान दें कि स्ट्रिंग में N-1 जोड़े पड़ोसी वर्ण हैं। के लिए Peanut Butter, 12 जोड़े में Peसे पहला है ea, दूसरा है , अंतिम है er।

जब जोड़े ज्यादातर अलग-अलग वर्ण होते हैं, तो स्ट्रिंग में एक चंकी गुणवत्ता होती है, जैसे chUnky।
जब ये जोड़े ज्यादातर एक ही चरित्र होते हैं, तो स्ट्रिंग में एक चिकनी गुणवत्ता होती है, जैसे sssmmsss।

दो अलग-अलग वर्णों के जोड़े की कुल संख्या (N-1) के साथ जोड़े की संख्या का अनुपात होने के लिए एक स्ट्रिंग के चंकनेस को परिभाषित करें ।

जोड़े की कुल संख्या (N-1) के लिए दो समान वर्णों के साथ जोड़े की संख्या का अनुपात होने के लिए एक स्ट्रिंग की चिकनाई को परिभाषित करें ।

उदाहरण के लिए, Peanut Butterसमरूप वर्णों ( tt) के साथ केवल एक जोड़ा होता है , इसलिए इसकी चिकनाई 1/12 या 0.0833 है और इसकी शुद्धता 11/12 या 0.9167 है।

केवल एक वर्ण के साथ खाली तार और तार को 100% चिकनी और 0% चंकी के रूप में परिभाषित किया गया है।

चुनौती

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

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

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

उदाहरण

Peanut Butter→ Chunkiness: 0.91666666666, चिकनाई: 0.08333333333
chUnky→ Chunkiness: 1.0, चिकनाई: 0.0
sssmmsss→ Chunkiness: 0.28571428571, चिकनाई: 0.71428571428
999→ Chunkiness: 0.0, चिकनाई: 1.0
AA→ Chunkiness: 0.0, चिकनाई: 1.0
Aa→ Chunkiness: 1.0, चिकनाई: 0.0
!→ Chunkiness: 0.0, चिकनाई: 1.0
[रिक्त स्ट्रिंग] → Chunkiness: 0.0, चिकनाई:1.0

बोनस प्रश्न: आप किसे पसंद करते हैं , चंकी या चिकने तार ?

code-golf  string  arithmetic 
— केल्विन के शौक
स्रोत
8
-1 कोई ओवरहैंडेड टैग नहीं।
— डेनिस
22
+1 कॉनक्लूसिव सबूत कि चंकी पीनट बटर डिफ़ॉल्ट होना चाहिए।
— ब्रेनसैट
कुछ भाषाओं में एक कठिन समय होता है जिसमें कोई इनपुट नहीं होता है। क्या यह मान लेना उचित होगा कि इनपुट नया है?
— डेनिस
@ डेनिस हां, यह ठीक है।
— केल्विन के शौक
9
यदि आप एक कंप्यूटर हैं तो @BrainSteel चंकी केवल डिफ़ॉल्ट होना चाहिए; वे उपलब्ध विखंडू पसंद करते हैं। लोगों के लिए बनाया गया पीनट बटर उन कार्यान्वयन विवरणों को छिपाना चाहिए, और उपयोगकर्ता के लिए रेशम की तरह चिकना होना चाहिए।
— जोबिट्स

जवाबों:

7

एपीएल, 10 बाइट्स

यह स्टड से इनपुट पढ़ता है और chunkiness को stdout में प्रिंट करता है। एल्गोरिथ्म वही है जो J समाधान के लिए उपयोग किया जाता है।

(+/÷⍴)2≠/⍞
— FUZxxl
स्रोत
19

CJam, 19 बाइट्स

q_1>_@.=:!1b\,d/4mO

100% चंकी स्रोत कोड जो chunkiness की गणना करता है ।

इस चंकी अच्छाई को ऑनलाइन आज़माएं।

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

q_                  e# Read from STDIN and push a copy.
  1>_               e# Discard the first character and push a copy.
     @              e# Rotate the original on top.
      .=            e# Vectorized comparison (1 if equal, 0 if not).
        :!          e# Mapped logical NOT (0 if equal, 1 if not).
          1b        e# Base 1 conversion (sum).
            \,      e# Swap with the shortened string and push its length.
              d/    e# Cast to double and divide.
                4mO e# Round to four decimal places.

जाहिर है, 4 दशमलव स्थानों पर गोल NaN 0 है।

— डेनिस
स्रोत
1
मुझे नहीं लगता कि आपको इसे 4 अंकों के लिए गोल करने की आवश्यकता है। यह कहता है "4 या अधिक", और अनुगामी शून्य की आवश्यकता नहीं है। 2ewमेरे द्वारा किए गए दृष्टिकोण की तुलना में यह बहुत अधिक सुरुचिपूर्ण है । 0/1 पत्र विशेष मामले मुझे मार रहे थे।
— रेटो कोराडी
@RetoKoradi राउंडिंग मैप्स NaN से 0. मैं एक छोटे तरीके से नहीं जानता।
— डेनिस
हां, इसके साथ कुछ और खेलते हुए, मैंने सिर्फ यह देखा कि आपको 1-चरित्र इनपुट के लिए NaN मिलता है। शॉर्ट इनपुट इस एक के साथ अब तक का सबसे दर्दनाक हिस्सा है। BTW, ऑनलाइन लिंक आपके द्वारा पोस्ट किए गए संस्करण की तुलना में थोड़ा अलग कोड है। एक _चला गया। यकीन नहीं होता अगर यह मायने रखता है।
— रेटो कोरदी
@RetoKoradi ज़रूर करता है। लिंक कोड 100% चंकी नहीं होगा। : पी
— डेनिस
3
@AlexA। फलों के टुकड़ों के साथ जाम कम से कम 10% चंकी है।
— डेनिस
13

पायथ, 13 12 बाइट्स

csJnVztz|lJ1

पूरी तरह से चंकी कोड की गणना chunkiness।

प्रदर्शन। दोहन ​​परीक्षण।

csJnVztz|lJ1
                 Implicit: z = input()
   nV            n, !=, vectorized over
     z           z
      tz         z[:-1]
                 V implitly truncates.
  J              Store it in J.
 s               sum J
c                floating point divided by
         |       logical or
          lJ     len(J)
            1    1
— isaacg
स्रोत
ऑनलाइन संस्करण में, जब मैं इनपुट खाली छोड़ता हूं तो मुझे एक त्रुटि मिलती है। जहाँ तक मैं बता सकता हूँ, यह पिछले परीक्षण मामले में विफल रहता है।
— रेटो कोराडी जूल
@RetoKoradi यह अजीब है - यह ऑफ़लाइन संस्करण में ठीक काम करता है। यह शायद ऑनलाइन वेबसाइट के साथ एक बग है।
— isaacg
@RetoKoradi ने पुष्टि की - zऑनलाइन खाली इनपुट पर त्रुटि का कारण है। मैं जाऊंगा और उस बग को ठीक करूंगा। यह कोड हालांकि ठीक है।
— isaacg
यह काम करता है अगर मैं एक बार इनपुट बॉक्स में रिटर्न मारता हूं। लेकिन अन्य तारों को अंत में वापसी की आवश्यकता नहीं है। इनपुट बॉक्स में टाइप किए गए कुछ के साथ, ऐसा लगता है कि इसमें कोई इनपुट नहीं है, और जब यह इनपुट का उपयोग करने की कोशिश करता है तो आपका कोड उड़ जाता है।
— रेटो कोरदी
@RetoKoradi धन्यवाद मुझे लगता है कि मुझे समस्या का पता है, इसे ठीक करना मुश्किल नहीं होना चाहिए।
— isaacg
8

टीआई-बेसिक, 46 बाइट्स

Input Str1
If 2≤length(Str1
mean(seq(sub(Str1,X,1)=sub(Str1,X-1,1),X,2,length(Str1
Ans

sub(x1,x2,x3x1संख्या पर स्ट्रिंग शुरू (एक-आधारित) का विकल्प देता है और संख्या x2पर समाप्त होता है x3, फिर seq(एक अनुक्रम बनाता है।

चिकनाई मूल्य देता है। Ansचर रहा है 0ताकि हम एक की जरूरत नहीं है, डिफ़ॉल्ट रूप से Elseकरने के लिए Ifया करने के लिए दुकान करने के लिए कुछ भी बयान है, Ansपहले से।

— lirtosiast
स्रोत
7

मतलाब ( 37 36 बाइट्स)

यह निम्नलिखित अनाम फ़ंक्शन के साथ किया जा सकता है, जो चंकनेस लौटाता है:

f=@(x)nnz(diff(x))/max(numel(x)-1,1)

टिप्पणियाँ:

  • पुराने Matlab संस्करणों (जैसे R2010b) में आपको +वर्ण सरणी xको दोहरे सरणी में डालने की आवश्यकता है:

    f=@(x)nnz(diff(+x))/max(numel(x)-1,1)`

    लेकिन हाल के संस्करणों (R2014b में परीक्षण) में ऐसा नहीं है, जो एक बाइट बचाता है। जोनास को उसकी टिप्पणी के लिए धन्यवाद।

  • maxएक-चरित्र और शून्य-चरित्र के मामलों की अभिव्यक्ति (chunkiness के लिए)

उदाहरण:

>> f=@(x)nnz(diff(x))/max(numel(x)-1,1)
f = 
    @(x)nnz(diff(x))/max(numel(x)-1,1)

>> f('Peanut Butter')
ans =
   0.9167
— लुइस मेंडो
स्रोत
R2014b पर, diff('abc')चेतावनी नहीं देगा।
— जोनास
6

> <> , 40 36 बाइट्स

00ii:0(?v:@=1$-{+{1+}}20.
~:0=+,n;>~

यह प्रोग्राम एक स्ट्रिंग के chunkiness को लौटाता है।

व्याख्या

00i         Push 0 (# unequal pairs), 0 (length of string - 1) and read first char

[main loop]

i           Read a char
:0(?v       If we've hit EOF, go down a row
:@=1$-      Check (new char != previous char)
{+          Add to unequal pairs count
{1+         Increment length by 1
}}20.       Continue loop

[output]

~~          Pop last two chars (top one will be -1 for EOF)
:0=+        Add 1 to length if zero (to prevent division by zero errors)
,           Divide, giving chunkiness
n;          Output and halt

पिछला सबमिशन (37 + 3 = 40 बाइट्स)

l1)?v1n;
n,$&\l1-}0& \;
l2(?^$:@=&+&>

यह प्रोग्राम एक स्ट्रिंग की चिकनाई देता है। इनपुट -sध्वज के माध्यम से है , उदाहरण के लिए

py -3 fish.py chunkiness.fish -s "Peanut Butter"
— Sp3000
स्रोत
6

सी#, 94 89 बाइट्स

100 बाइट्स, इसलिए मुझे लगता है कि यह अपने आप में जीत का कोई रूप है?

यह एक फ़ंक्शन परिभाषा है (कल्पना के अनुसार अनुमति दी गई है) जो इनपुट स्ट्रिंग की चिकनाई लौटाती है :

Func<string,float>(s=>s.Length>1?s.Zip(s.Skip(1),(a,b)=>a==b?1f:0).Sum()/(s.Length-1):1);

बहुत सीधा है, अगर लंबाई 0 या 1 है तो यह 1 रिटर्न देता है, अन्यथा यह स्ट्रिंग की तुलना पहले चरित्र से कम करता है, फिर समान जोड़े की संख्या को जोड़े की संख्या से विभाजित करता है।

संपादित करें - प्रतिस्थापन को छोड़ें के साथ प्रतिस्थापित किया गया। रूकी गलती!

— सोक
स्रोत
5

जे, 14 13 बाइट्स

चंकीनेस की गणना करता है। 0 % 0० के बराबर होने के लिए कुदोस जे को परिभाषित करने के लिए।

(]+/%#)2~:/\]

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

यहाँ एक स्पष्टीकरण है:

   NB. sample input
   in =. 'sssmmsss'

   NB. all infixes of length 2
   2 ]\ in
ss
ss
sm
mm
ms
ss
ss

    NB. are the parts of the infix different?
    2 ~:/\ in
0 0 1 0 1 0 0

    NB. sum and item count of the previous result
    (+/ , #) 2 ~:/\ in
2 7

    NB. arithmetic mean: chunkiness
    (+/ % #) 2 ~:/\ in
0.285714

    NB. as a tacit verb
    (] +/ % #) 2 ~:/\ ]

    NB. 0 divided by 0 is 0 in J
    0 % 0
0
— FUZxxl
स्रोत
(]+/%#)2~:/\]1 बाइट बचाता है।
— FrownyFrog
@FrownyFrog कूल! मैं इसे कैसे याद कर सकता हूं?
— फ़ूजएक्सएक्सएल
क्या आप परीक्षण कोड के साथ एक TIO- लिंक जोड़ सकते हैं ?
— केविन क्रूज़सेन
4

सीजेएम, 23 बाइट्स

q_,Y<SS+@?2ew_::=:+\,d/

स्पष्टीकरण:

q                           e# read input
 _,                         e# its length
   Y<                       e# is less than 2?
     SS+                    e# then a smooth string
        @?                  e# otherwise the input
          2ew               e# pairs of consecutive characters
             _::=           e# map to 1 if equal, 0 if not
                 :+         e# sum (number of equal pairs)
                   \,       e# total number of pairs
                     d/     e# divide

यह चिकनाई अनुपात का उत्पादन करता है।

— Ypnypn
स्रोत
4

सीजेएम, 16 बाइट्स

1q2ew::=_:+\,d/*

चेटी स्रोत कोड जो चिकनाई की गणना करता है ।

लंबाई 0 या 1 के इनपुट के लिए, यह एक त्रुटि से बाहर निकलने से पहले सही परिणाम प्रिंट करता है। जावा दुभाषिया के साथ, त्रुटि आउटपुट STDERR को जाता है ( जैसा कि यह होना चाहिए )।

यदि आप कोड को ऑनलाइन आज़माते हैं , तो बस सब कुछ अनदेखा करें, लेकिन आउटपुट की अंतिम पंक्ति।

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

1q               e# Push a 1 and read from STDIN.
  2ew            e# Push the overlapping slices of length 2.
                 e# This will throw an error for strings of length 0 or 1,
                 e# so the stack (1) is printed and the program finishes.
     ::=         e# Twofold vectorized comparision.
        _:+      e# Push a copy and add the Booleans.
           \,    e# Swap with the original and compute its length.
             d/  e# Cast to double and divide.
               * e# Multiply with the 1 on the bottom of the stack.
— डेनिस
स्रोत
3

जूलिया, 52 बाइट्स

चिकनाई!

s->(n=length(s))<2?1:mean([s[i]==s[i+1]for i=1:n-1])

यह एक अनाम फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक संख्यात्मक मान लौटाता है।

यदि इनपुट की लंबाई 2 से कम है, तो चिकनाई 1 है, अन्यथा हम तार्किक सरणी के अर्थ को लेकर समान आसन्न वर्णों के अनुपात की गणना करते हैं।

— एलेक्स ए।
स्रोत
3

निम, 105 96 91 बाइट्स

proc f(s):any=
 var a=0;for i,c in s[.. ^2]:a+=int(s[i+1]!=c)
 a.float/max(s.len-1,1).float

निम सीखने की कोशिश कर रहा है। यह एक स्ट्रिंग के chunkiness की गणना करता है।

( अगर मैं इसे पढ़ने की कोशिश करता हूं तो पायथन इंडेंटेशन गड़बड़ हो जाता है ... अब यह रूबी की तरह दिखता है ...)

— Sp3000
स्रोत
3

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

यह एक अनाम मेमने का कार्य है जो तर्क के रूप में एक स्ट्रिंग लेता है, और इसे चंकनेस देता है।

lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)

इसका उपयोग करने के लिए, इसे एक नाम दें और इसे कॉल करें।

f=lambda n:~-len(n)and sum(x!=y for x,y in zip(n,n[1:]))/~-len(n)
f("Peanut Butter") -> 0.08333333333333333
f("!")             -> 0
f("")              -> -0.0
— Kade
स्रोत
अनाम फ़ंक्शन के बजाय, आप उपयोग कर सकते हैं: def f(n):जिसमें ठीक उसी तरह की संख्या है जैसे कि वर्ण हैं lambda n:। यह आपके फ़ंक्शन को नाम देने की आवश्यकता को निकालता है।
— ट्रिस्टन रीड
@TristanReid def f(n):भी एक की जरूरत हैreturn
— Sp3000
ऊप्स! अच्छी पकड़ - मैं कोडगुल्फ के लिए नया हूं, मुझे यह सोचना चाहिए कि इस बारे में अधिक सोचा गया है और स्थानीय स्तर पर परीक्षण किया गया है। क्षमा याचना!
— ट्रिस्टन रीड
3

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

lambda s:sum(map(str.__ne__,s,s[1:]))/(len(s)-1or 1)

यह chunkiness की गणना करता है, और -0.0खाली स्ट्रिंग के लिए आउटपुट । यदि आपको नकारात्मक शून्य पसंद नहीं है, तो आप हमेशा इसे अतिरिक्त बाइट के साथ ठीक कर सकते हैं:

lambda s:sum(map(str.__ne__,s,s[1:]))/max(len(s)-1,1)
— Sp3000
स्रोत
2

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

f[]=1
f[_]=1
f x=sum[1|(a,b)<-zip=<<tail$x,a==b]/(sum(x>>[1])-1)

सुचारू उत्पादन। जैसे f "Peanut Butter"-> 8.333333333333333e-2।

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

f[]=1                               -- special case: empty list
f[_]=1                              -- special case: one element list

f x=                                -- x has at least two elements
         (a,b)<-zip=<<tail$x        -- for every pair (a,b), drawn from zipping x with the tail of itself
                            ,a==b   -- where a equals b
      [1|                        ]  -- take a 1
   sum                              -- and sum it
              /                     -- divide  by
                   (x>>[1])         -- map each element of x to 1
               sum                  -- sum it
                           -1       -- and subtract 1

sum(x>>[1])एक्स की लंबाई है, लेकिन क्योंकि हास्केल के मजबूत प्रकार के सिस्टम के लिए अंशों को खिलाने की आवश्यकता होती है /, मैं lengthपूर्णांक रिटर्न का उपयोग नहीं कर सकता । पूर्णांकों को भिन्न से परिवर्तित करना fromInteger$length xबहुत लंबा है।

— nimi
स्रोत
क्या आपने तर्कसंगत के साथ काम करने की कोशिश की ?
— recursion.ninja
@ recursion.ninja: नहीं, मैंने नहीं किया क्योंकि मुझे लगता है कि 18 बाइट import Data.Ratioबहुत महंगी है।
— नीमी
2

जावास्क्रिप्ट (ईएस 6), 55 बाइट्स

चिकनाई, 56 बाइट्स

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

चंकीनेस, 55 बाइट्स

f=x=>(z=x.match(/(.)(?!\1)/g))&&--z.length/--x.length||0

डेमो

चिकनाई की गणना करता है, जैसा कि मुझे पसंद है। अभी के लिए फ़ायरफ़ॉक्स में काम करता है, क्योंकि यह ES6 है।

f=x=>(z=x.match(/(.)(?=\1)/g))?z.length/--x.length:+!x[1]

O.innerHTML += f('Peanut Butter') + '\n';
O.innerHTML += f('chUnky') + '\n';
O.innerHTML += f('sssmmsss') + '\n';
O.innerHTML += f('999') + '\n';
O.innerHTML += f('AA') + '\n';
O.innerHTML += f('Aa') + '\n';
O.innerHTML += f('!') + '\n';
O.innerHTML += f('') + '\n';
<pre id=O></pre>
स्निपेट का विस्तार करें

— rink.attendant.6
स्रोत
2

केडीबी (क्यू), ३०

चिकनाई लौटाता है।

{1^sum[x]%count x:1_(=':)(),x}

व्याख्या

                         (),x    / ensure input is always list
                x:1_(=':)        / check equalness to prev char and reassign to x
   sum[x]%count                  / sum equalness divide by count N-1
 1^                              / fill null with 1 since empty/single char will result in null
{                             }  / lamdba

परीक्षा

q){1^sum[x]%count x}1_(=':)(),x}"Peanut Butter"
0.08333333
q){1^sum[x]%count x:1_(=':)(),x}"sssmmsss"
0.7142857
q){1^sum[x]%count x:1_(=':)(),x}"Aa"
0f
q){1^sum[x]%count x:1_(=':)(),x}"aa"
1f
q){1^sum[x]%count x:1_(=':)(),x}"chUnky"
0f
q){1^sum[x]%count x:1_(=':)(),x}"!"
1f
q){1^sum[x]%count x:1_(=':)(),x}""
1f
— वूइकेंट ली
स्रोत
2

रूबी , 69 66 बाइट्स

->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}

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

छोटा सा बाइट्स का शेप इसके अलावा, रूबी के आगामी संस्करण 2.7.0 के |x,y|x!=yसाथ कुछ बाइट को बचाने के लिए संभव है@1!=@2

— daniero
स्रोत
यदि आप .to_f/~-s.sizec के असाइनमेंट में जाते हैं, तो आप टर्नरी ऑपरेशन के साथ बाइट को निकाल सकते हैं:f=->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}
— IMP1
इसके अलावा, क्या आप की जरूरत है f=? मैं उस बारे में नियमों पर 100% नहीं हूँ। चुनौती कहती है कि आप एक स्ट्रिंग लेने वाले फ़ंक्शन को वापस कर सकते हैं, जो एक स्टैम्बी लैम्ब्डा है।
— IMP1
इसके अलावा , जबकि पर्ल का उत्तर एक ही लंबाई का हो सकता है, यह 100% चंकनेस नहीं है जो यह उत्तर देता है।
— IMP1
@ IMP1 धन्यवाद :)
— daniero
1

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

किसी ने अभी तक एक पायथन समाधान पोस्ट नहीं किया है, इसलिए यहां "chunkiness" फ़ंक्शन का काफी सीधा कार्यान्वयन है। यह लंबाई की एक स्ट्रिंग पर शॉर्ट-सर्किट करता है 1, और प्रिंट करता है0 (जो एक फ्लोट के बजाय एक पूर्णांक है लेकिन नियमों के अनुसार अनुमति दी जाती है)।

एक खाली स्ट्रिंग पर, यह -0.0बजाय आउटपुट 0.0। यकीनन इसे -0.0 == 0 == 0.0रिटर्न के रूप में स्वीकार्य माना जा सकता है True।

def c(s):l=len(s)-1;return l and sum(s[i]!=s[i+1]for i in range(l))/l

उदाहरण:

>>> c(''); c('a'); c('aaa'); c("Peanut Butter")
-0.0
0
0.0
0.916666666667
>>> -0.0 == 0 == 0.0
True

(पायथन 3 का उपयोग इसके डिफ़ॉल्ट फ्लोट डिवीजन के लिए किया जाता है।)

— mathmandan
स्रोत
1

सी, 83 बाइट्स

float f(char*s){int a=0,b=0;if(*s)while(s[++a])b+=s[a]!=s[a-1];return--a?1.*b/a:b;}

एक समारोह लौटने chunkiness ।

व्याख्या

float f(char *s) {

एक सी स्ट्रिंग को स्वीकार करें, और एक फ्लोट लौटाएं (डबल काम करेगा लेकिन अधिक वर्ण है)।

int a=0, b=0;

काउंटरर्स - aकुल जोड़े के लिए, bगैर-मिलान जोड़े के लिए। intस्ट्रिंग की "मनमानी लंबाई" का उपयोग करना , लेकिन यह केवल आवश्यकताओं का मामूली उल्लंघन है और मैं इसे ठीक नहीं करने जा रहा हूं।

if (*s)

विशेष मामला खाली स्ट्रिंग - दोनों काउंटरों को शून्य छोड़ दें।

    while (s[++a])

गैर-खाली स्ट्रिंग - पूर्व-वृद्धि के साथ इसके माध्यम से पुनरावृत्ति करें (इसलिए पहली बार लूप के माध्यम से, s[a]दूसरा वर्ण होगा। यदि स्ट्रिंग में केवल एक वर्ण है, तो लूप बॉडी में प्रवेश नहीं किया जाएगा, और a1 होगा।

        b += s[a]!=s[a-1];

यदि वर्तमान वर्ण पिछले, वेतन वृद्धि से भिन्न होता है b।

return --a ? 1.*b/a : b;
}

लूप के बाद, तीन संभावनाएं हैं: खाली इनपुट के लिए 'a == 0, b == 0', एकल-वर्ण इनपुट के लिए 'a == 1, b == 0' या 'a> 1, b> मल्टी-कैरेक्टर इनपुट के लिए = 0 '। हम 1 से घटाते हैं a( ?ऑपरेटर एक अनुक्रम बिंदु है, इसलिए हम सुरक्षित हैं), और यदि यह शून्य है, तो हमारे पास दूसरा मामला है, इसलिए हम शून्य वापस आते हैं। अन्यथा, b/aहम जो चाहते हैं, लेकिन हमें बढ़ावा देना चाहिएb पहले फ्लोटिंग-पॉइंट प्रकार या हमें पूर्णांक विभाजन मिलेगा। एक खाली स्ट्रिंग के लिए, हम एक नकारात्मक शून्य के साथ समाप्त करेंगे, लेकिन नियम इसे अस्वीकार नहीं करते हैं।

टेस्ट:

#include <stdio.h>
int main(int argc, char **argv)
{
    while (*++argv)
        printf("%.6f %s\n", f(*argv), *argv);
}

जो देता है: 

./chunky 'Peanut Butter' chUnky sssmmsss 999 AA Aa '!' ''
0.916667 Peanut Butter
1.000000 chUnky
0.285714 sssmmsss
0.000000 999
0.000000 AA
1.000000 Aa
0.000000 !
-0.000000

जैसी ज़रूरत।

— टोबी स्पाईट
स्रोत
1
मेरी पिछली हटाई गई टिप्पणी पर ध्यान न दें .. 80 बाइट्स :a,b;float f(char*s){if(*s)for(a=b=0;s[++a];)b+=s[a]!=s[a-1];return--a?1.*b/a:b;}
— केविन क्रूज़सेन
संकलक ध्वज का उपयोग करके 66 बाइट्स (यदि आप उस तरह के हैं)। संपादित करें: और मैंने इसे gcc
— vazt
1

पर्ल, 69

चिकनाई लौटाने का कार्य : 

sub f{($_)=@_;$s=s/(.)(?!\1)//sgr;chop;!$_||length($s)/length;}

व्याख्या

sub f {
    # read argument into $_
    ($_) = @_;

    # copy $_ to $s, removing any char not followed by itself
    # /s to handle newlines as all other characters
    $s = s/(.)(?!\1)//sgr;

     # reduce length by one (unless empty)
    chop;

    # $_ is empty (false) if length was 0 or 1
    # return 1 in that case, else number of pairs / new length
    !$_ || length($s)/length;
}

टेस्ट

printf "%.6f %s\n", f($a=$_), $a foreach (@ARGV);

0.083333 Peanut Butter
0.000000 chUnky
0.714286 sssmmsss
1.000000 999
1.000000 AA
0.000000 Aa
1.000000 !
1.000000
— टोबी स्पाईट
स्रोत
1

गणितज्ञ, 73 72 बाइट्स

यह आकार के लिए कुछ भी नहीं जीतता है, लेकिन यह सीधा है:

चिकनाई

N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""]&

In[177]:= N@Count[Differences@#,_Plus]/(Length@#-1)&@StringSplit[#,""] &@"sssmmsss"

Out[177]= 0.285714
— rcollyer
स्रोत
Length[#]-> Length@#एक स्ट्रोक बचाता है। तो समाप्त करता है N@और बदल 1जाता है1.
— hyPotenuser
@hYPotenuser हां। ये छूट गया।
— rcollyer
1

GeL: 76 73 अक्षर

चिकनाई।

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@lua{c=@column -1\;return c<1and 1or $d/c}

नमूना रन:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gel -f smooth.gel
>     echo
> done
Peanut Butter -> 0.083333333333333
chUnky -> 0
sssmmsss -> 0.71428571428571
999 -> 1
AA -> 1
Aa -> 0
! -> 1
 -> 1

(जीईएल = गेमा + लुआ बाइंडिंग। बहुत बेहतर, लेकिन फिर भी जीतने से बहुत दूर।)

Gema: 123 120 अक्षर

चिकनाई।

@set{d;0}
?\P$1=@incr{d}
?=
\Z=@subst{\?\*=\?.\*;@cmpn{@column;1;10;10;@fill-right{00000;@div{$d0000;@sub{@column;1}}}}}

नमूना रन:

bash-4.3$ for i in 'Peanut Butter' 'chUnky' 'sssmmsss' '999' 'AA' 'Aa' '!' ''; do
>     echo -n "$i -> "
>     echo -n "$i" | gema -f smooth.gema
>     echo
> done
Peanut Butter -> 0.0833
chUnky -> 0.0000
sssmmsss -> 0.7142
999 -> 1.0000
AA -> 1.0000
Aa -> 0.0000
! -> 1.0
 -> 1.0

(यह देखने के लिए अपने आप में एक अधिक अभ्यास था कि फ्लोटिंग पॉइंट नंबर सपोर्ट के बिना भाषा में इसे हल करने की क्या संभावनाएं हैं और आमतौर पर दर्दनाक अंकगणित समर्थन। 2 पंक्ति, विशेष रूप से \Pअनुक्रम शुद्ध जादू है, अंतिम पंक्ति वास्तविक यातना है।)

— आदमी काम पर है
स्रोत
1

जावा 8, 84 82 बाइट्स

s->{float l=s.length()-1,S=s.split("(.)(?=\\1)").length-1;return l<1?1:S<1?0:S/l;}

आउटपुट स्मूथनेस।

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

स्पष्टीकरण:

s->{                     // Method with String parameter and float return-type
  float l=s.length()-1,  //  Length of the input-String minus 1 (amount of pairs in total)
        S=s.split("(.)(?=\\1)").length-1;
                         //  Length of the input split by duplicated pairs (with lookahead)
  return l<1?            //  If the length of the input is either 0 or 1:
          1              //   Return 1
         :S<1?           //  Else-if `S` is -1 or 0:
          0              //   Return 0
         :               //  Else:
          S/l;}          //   Return duplicated pairs divided by the length-1
— केविन क्रूज़सेन
स्रोत
0

पॉवरशेल, 55 बाइट्स

चिकनाई

%{$s=$_;@([char[]]$s|?{$_-eq$a;$a=$_;$i++}).count/--$i}

स्टड में एक चर पाने के लिए थोड़ा सा मूर्खतापूर्ण लगता है और फिर इसे एक पहचानकर्ता देता है, लेकिन एक फ़ंक्शन होने की तुलना में इसका तेज।

— नच - पुनः मोनिका
स्रोत
0

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

गुंडा गणना करें:

f=lambda s: sum(a!=b for a,b in zip(s,s[1:]))/max(len(s)-1,1)
— TheCrypt
स्रोत
0

रूबी, 63 बाइट्स

आउटपुट चंकनेस।

f=->s{s.chars.each_cons(2).count{|x,y|x!=y}/[s.size-1.0,1].max}

@ Daniero के समाधान के समान, लेकिन स्ट्रिंग लंबाई से सीधे विभाजित करके थोड़ा छोटा - 1 और फिर भरोसा करना। लंबाई 0 और 1 स्ट्रिंग्स के साथ शून्य होना। (मोम यह सुनिश्चित करता है कि मैं 0 या -1 से विभाजित नहीं करूंगा)।

— dgollahon
स्रोत
0

गणितज्ञ, 107 बाइट्स

प्रत्येक डग और इसके उलट के बीच में लेवेंसहाइट की आधी दूरी तय करके चंकनेस की गणना करता है।

f[s_]:=.5EditDistance@@{#,StringReverse@#}&/@StringCases[s,_~Repeated~{2},Overlaps->All]//Total@#/Length[#]&

यदि आप एक सटीक तर्कसंगत उत्तर पसंद करते हैं, तो बिना किसी दंड के अंतिम से पहले हटाएं .5और रखें । इस कार्यक्रम में स्वयं १०३/१०६, या लगभग 72 ९ unk२ है।/2&

— hYPotenuser
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.