চুনকি বনাম স্মুথ স্ট্রিংস

29

N দৈর্ঘ্যের N এর স্ট্রিং বিবেচনা করুন, যেমন Peanut ButterN = 13 সহ। লক্ষ করুন যে স্ট্রিংটিতে প্রতিবেশী অক্ষরের N-1 জোড়া রয়েছে। কারণ Peanut Butter, 12 জোড়ার মধ্যে প্রথমটি হল Pe, দ্বিতীয়টি eaসর্বশেষটি er।

জোড়া বেশিরভাগই বিভিন্ন অক্ষর, তখন স্ট্রিং যেমন একটি গাঁট্টাগোট্টা মানের হয়েছে, chUnky।
যখন এই জোড়াগুলি বেশিরভাগ ক্ষেত্রে একই চরিত্রের হয় তবে স্ট্রিংয়ের একটি মসৃণ গুণ থাকে sssmmsss।

দুটি পৃথক অক্ষরের সাথে জোড়ের সংখ্যার অনুপাত হতে একটি স্ট্রিংয়ের সংকোচনের সংজ্ঞা দাও (এন -1)।

স্ট্রিংয়ের মসৃণতাটিকে জোড়ার সংখ্যার সাথে দুটি অভিন্ন অক্ষরের সাথে মোট জোড়ার সংখ্যার (এন -1) অনুপাত হিসাবে সংজ্ঞা দিন ।

উদাহরণস্বরূপ, Peanut Butterঅভিন্ন অক্ষর ( tt) এর সাথে কেবল একটি জুড়ি রয়েছে , সুতরাং এর মসৃণতাটি 1/12 বা 0.0833 এবং এর স্বল্পতা 11/12 বা 0.9167।

কেবল একটি অক্ষরের খালি স্ট্রিং এবং স্ট্রিংগুলি 100% মসৃণ এবং 0% মজাদার হিসাবে সংজ্ঞায়িত করা হয়।

চ্যালেঞ্জ

এমন একটি প্রোগ্রাম লিখুন যা স্বেচ্ছাসেবী দৈর্ঘ্যের একটি স্ট্রিং নেয় এবং ভাসমান পয়েন্টের মান হিসাবে এর স্বল্পতা বা মসৃণতা অনুপাতকে আউটপুট দেয়।

  • স্টিডিন বা কমান্ড লাইনের মাধ্যমে ইনপুট নিন বা আপনি কোনও ফাংশন লিখতে পারেন যা স্ট্রিং নেয়।
  • আপনি ধরে নিতে পারেন ইনপুট স্ট্রিংয়ে কেবল প্রিন্টযোগ্য ASCII অক্ষর রয়েছে (এবং তাই এটি একক-লাইন)।
  • 4 বা ততোধিক দশমিক স্থানে স্টাটআউটে ফ্লোটটি মুদ্রণ করুন বা আপনি কোনও ফাংশন লিখলে আপনি এটি ফিরিয়ে দিতে বেছে নিতে পারেন। দশমিক স্থান কোনো তথ্য বহন প্রয়োজন নেই, যেমন 0পরিবর্তে জরিমানা 0.0000।
  • আপনি পছন্দ হিসাবে chunkiness বা মসৃণতা চয়ন করুন। আপনার প্রোগ্রামটি কোনটি ফলাফল বলে ঠিক তা নিশ্চিত করুন Just

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

উদাহরণ

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 চূড়ান্ত চিনাবাদাম মাখনটি ডিফল্ট হওয়া উচিত এমন সিদ্ধান্তযুক্ত প্রমাণ।
— BrainSteel
কিছু ভাষায় কোনও ইনপুট পড়ার পক্ষে খুব কষ্ট হয়। এটা অনুমান করা কি গ্রহণযোগ্য হবে যে ইনপুটটি নতুন লাইন-সমাপ্ত হয়েছে?
— ডেনিস
@ ডেনিস হ্যাঁ, ঠিক আছে।
— ক্যালভিনের শখ 4
9
@ ব্রেনস্টিল চানকি কেবলমাত্র যদি আপনি কম্পিউটার হন তবে ডিফল্ট হওয়া উচিত; তারা খণ্ডগুলি উপলব্ধ থাকতে পছন্দ করে। মানুষের জন্য তৈরি চিনাবাদাম মাখনের সেই প্রয়োগের বিবরণগুলি আড়াল করা উচিত এবং ব্যবহারকারীর জন্য সিল্কের মতো মসৃণ হওয়া উচিত।
— জিওবিটস

উত্তর:

7

এপিএল, 10 বাইট

এটি স্টিডিন থেকে ইনপুট পড়ে এবং স্টাডাউটের খণ্ডক ছাপায়। অ্যালগোরিদম হ'ল জ সলিউশনের জন্য একই ব্যবহার করা হয়।

(+/÷⍴)2≠/⍞
— FUZxxl
সূত্র
19

সিজেম, 19 বাইট

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

100% খাঁটি সোর্স কোড যা শূন্যতার গণনা করে ।

অনলাইনে এই চমকপ্রদ সদ্ব্যবহার চেষ্টা করুন।

কিভাবে এটা কাজ করে

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.

স্পষ্টতই, NaN 4 দশমিক জায়গায় গোল হয় is

— ডেনিস
সূত্র
1
আমি মনে করি না আপনি এটি 4 টি সংখ্যার মধ্যে গোল করতে হবে। এটি "4 বা ততোধিক" বলে, এবং অনুসরণীয় শূন্যগুলির প্রয়োজন হয় না। 2ewআমি চেষ্টা করার পদ্ধতির চেয়ে এটি অনেক বেশি মার্জিত । 0/1 চিঠির বিশেষ মামলাগুলি আমাকে হত্যা করছিল।
— রেটো কোরাডি
@ রিটোকোরাদি রাউন্ডিং NaN থেকে 0 টি মানচিত্রের মানচিত্রের মানচিত্রটি জানিনা I
— ডেনিস
হ্যাঁ, এটির সাথে আরও কিছু খেলতে গিয়ে আমি কেবল লক্ষ্য করেছি যে আপনি 1-চরিত্রের ইনপুটগুলির জন্য একটি NAN পেয়েছেন। সংক্ষিপ্ত ইনপুটগুলি এটির সাথে সবচেয়ে বেদনাদায়ক অংশ। বিটিডাব্লু, অনলাইন লিঙ্কটিতে আপনার পোস্ট করা সংস্করণটির চেয়ে কিছুটা আলাদা কোড রয়েছে। একজন _সরল। এটি গুরুত্বপূর্ণ কিনা তা নিশ্চিত নয়।
— রেটো কোরাাদি
পুনঃটুইট করুন লিঙ্কযুক্ত কোডটি 100% খসখসে নয়। : পি
— ডেনিস
3
@AlexA। ফলের অংশগুলির সাথে জাম কমপক্ষে 10% চুনযুক্ত।
— ডেনিস
13

পাইথ, 13 12 বাইট

csJnVztz|lJ1

পুরোপুরি চুনকি কোড গণ্যমান্যতা গণনা করে।

প্রদর্শন. পরীক্ষার জোতা।

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
সূত্র
অনলাইন সংস্করণে, আমি যখন ইনপুটটি খালি রাখি তখন আমি একটি ত্রুটি পাই। আমি যতদূর বলতে পারি, এটি শেষ পরীক্ষার ক্ষেত্রে ব্যর্থ।
— রেটো কোরাডি
@ রিটোকোরাডি এটি অদ্ভুত - এটি অফলাইন সংস্করণে দুর্দান্ত কাজ করে। এটি সম্ভবত অনলাইন ওয়েবসাইটের সাথে একটি বাগ।
— isaacg
@ রিটোকোরাডি নিশ্চিত হয়েছে - zঅনলাইনে খালি ইনপুটটিতে ত্রুটির কারণ হিসাবে খুব ব্যবহার । আমি গিয়ে বাগটি ঠিক করে দেব। তবে এই কোডটি ঠিক আছে।
— isaacg
যদি আমি ইনপুট বাক্সে একবার ফিরে আসি তবে এটি কাজ করে। তবে অন্যান্য স্ট্রিংগুলির শেষে ফেরার দরকার নেই। ইনপুট বাক্সে টাইপ করা কিছু না হলেও, কোনও ইনপুট পাওয়া যায় না বলে মনে হয় এবং ইনপুটটি ব্যবহার করার চেষ্টা করার সময় আপনার কোডটি ফুরিয়ে যায়।
— রেটো কোরাডি
ধন্যবাদ রেটোকোরাদি ধন্যবাদ। আমি মনে করি আমি সমস্যাটি জানি, এটি সংশোধন করা কঠিন হওয়া উচিত নয়।
— 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)

মন্তব্যসমূহ:

  • পুরাতন মতলব সংস্করণগুলিতে (যেমন R2010b) আপনার +চর অ্যারেটি xএকটি ডাবল অ্যারেতে কাস্ট করতে হবে :

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

    তবে সাম্প্রতিক সংস্করণগুলিতে এটি নয় (R2014 বি পরীক্ষিত), যা একটি বাইট সংরক্ষণ করে। জোনাস তার মন্তব্যের জন্য ধন্যবাদ।

  • অভিব্যক্তিটি maxএক-চরিত্র এবং শূন্য-চরিত্রের কেসগুলি পরিচালনা করে (ছিন্নমূলতার জন্য)

উদাহরণ:

>> 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;>~

এই প্রোগ্রামটি একটি স্ট্রিংয়ের বিশৃঙ্খলা ফিরিয়ে দেয়।

ব্যাখ্যা

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 % 00 এর সমান হতে সংজ্ঞায়নের জন্য কুডোস থেকে জে ।

(]+/%#)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 বাইট সাশ্রয় করে।
— ফ্রাউনফ্রোগ 6
পছন্দ করুন আমি কিভাবে এই মিস করতে পারে?
— FUZxxl
আপনি কি পরীক্ষার কোডের সাথে একটি টিআইও-লিঙ্ক যুক্ত করতে পারেন ?
— কেভিন ক্রুইজসেন
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

নিম শিখার চেষ্টা করছি। এটি একটি স্ট্রিংয়ের খণ্ডক গণনা করে।

( আমি যদি পাইথন হিসাবে এটি পড়ার চেষ্টা করি তবে ইন্ডেন্টেশনটি সমস্ত গোলমেলে দেখায় ... এখন এটি আরও রুবির মতো দেখাচ্ছে ...)

— 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:। এটি আপনার ফাংশনটির নামকরণের প্রয়োজনীয়তা সরিয়ে দেয়।
— ত্রিস্তান রিড
@ ত্রিস্তানরিডেরও def f(n):একটি দরকারreturn
— Sp3000
ওহো! ভাল ধরা - আমি কোডগল্ফে নতুন, আমার ধারণা করা উচিত যে স্থানীয়ভাবে এই বিষয়ে আরও চিন্তাভাবনা চলে গেছে। দুঃক্ষিত!
— ত্রিস্তান রিড
3

পাইথন 3, 52 বাইট

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

এটি খণ্ডন গণনা করে এবং -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
@ রিকার্সন.নিনজা: না, আমি এমনটি করিনি কারণ আমি মনে করি 18 বাইটটি import Data.Ratioখুব ব্যয়বহুল।
— নিমি
2

জাভাস্ক্রিপ্ট (ES6), 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

কেডিবি (কিউ), 30

মসৃণতা ফিরিয়ে দেয়।

{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
— WooiKent লি
সূত্র
2

রুবি , 69 66 বাইট

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

এটি অনলাইন চেষ্টা করুন!

আইএমপি-র মন্তব্য সহ কয়েকটি বাইট শেভ করা। এছাড়াও, রুবির আসন্ন সংস্করণটি ২.7.০ |x,y|x!=yসহ এর পরিবর্তে কিছু বাইট সংরক্ষণ করা সম্ভব@1!=@2

— daniero
সূত্র
আপনি যদি .to_f/~-s.sizeসি এর কার্যভারে স্থানান্তর করেন , তবে আপনি ত্রৈমাসিক ক্রিয়াকলাপটি দিয়ে একটি বাইট শেভ করতে পারেন:f=->s{(c=s.chars.each_cons(2).count{|x,y|x!=y}.to_f/~-s.size)>0?c:0}
— আইএমপি 1
এছাড়াও, আপনার কি দরকার f=? আমি এই সম্পর্কে নিয়ম 100% না। চ্যালেঞ্জটি বলে যে আপনি কোনও ফাংশন ফিরিয়ে দিতে পারেন যা স্ট্রিং নেয়, যা একটি ছুরিকাঘাত ল্যাম্বদা।
— আইএমপি 1
এছাড়াও , যখন পার্ল উত্তর একই দৈর্ঘ্য হতে পারে, তবে এটি এই উত্তরটির মতো 100% খাঁটিতা পায় নি।
— আইএমপি 1
@ আইএমপি 1 ধন্যবাদ :)
— ডানিরো
1

পাইথন 3, 69 বাইট

কেউ এখনও পাইথন সলিউশন পোস্ট করেনি, সুতরাং এখানে একটি "চুঙ্কনেস" ফাংশনটির মোটামুটি সরল বাস্তবায়ন। এটি দৈর্ঘ্যের একটি স্ট্রিংতে শর্ট সার্কিট 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]। দ্বিতীয় চরিত্র হতে হবে স্ট্রিং শুধুমাত্র একটি অক্ষর থাকে, তাহলে লুপ শরীর প্রবেশ করা হবে না, এবং aথাকবে 1।

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

যদি বর্তমানের চরিত্রটি পূর্বের, বর্ধিত থেকে পৃথক হয় b।

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

লুপের পরে, তিনটি সম্ভাবনা রয়েছে: খালি ইনপুট জন্য 'a == 0, b == 0', একটি একক-অক্ষর ইনপুট জন্য 'a == 1, খ == 0' বা 'a> 1, বি> বহু-অক্ষর ইনপুট জন্য = 0 '। আমরা এর থেকে ১ টি বিয়োগ করি 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;}
— কেভিন ক্রুইজসেন
Iler 66 বাইটস কম্পাইলার পতাকা ব্যবহার করে (আপনি যদি এই ধরণের জিনিসটিতে থাকেন তবে)। সম্পাদনা করুন: এবং আমি এটি
— জিসিসি
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

জেএল: 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

(জেএল = জেমা + লুয়া বাঁধাই। আরও অনেক ভাল, তবে এখনও জয়ের থেকে অনেক দূরে))

জেমা: 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

(ভাসমান পয়েন্ট সংখ্যা সমর্থন এবং সাধারণত বেদনাদায়ক পাটিগণিত সমর্থন ব্যতীত কোন ভাষায় এটি সমাধান করার সম্ভাবনাগুলি কী তা আমার জন্য আরও অনুশীলন ছিল The দ্বিতীয় লাইন, বিশেষত \Pক্রমটি খাঁটি যাদু, শেষ লাইনটি সত্যিকারের অত্যাচার is

— কর্মক্ষেত্রে মানুষ
সূত্র
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

রুবি, 63 বাইট

আউটপুট খিঁচুনি

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

@ ড্যানিরোর সমাধানের মতো, তবে স্ট্রিংয়ের দৈর্ঘ্য - 1 দ্বারা সরাসরি বিভাজন করে সামান্য সংক্ষেপে এবং তারপরে দৈর্ঘ্য 0 এবং 1 স্ট্রিংয়ের সাথে শূন্য হতে গণনা উপর নির্ভর করে (.ম্যাক্স নিশ্চিত করে যে আমি 0 বা -1 দ্বারা ভাগ করব না)।

— dgollahon
সূত্র
0

গণিত, 107 বাইট

প্রতিটি ডিগ্রাফ এবং এর বিপরীতের মধ্যবর্তী লেভেনস্টেইনের দূরত্বের অর্ধেক অংশ গ্রহণ করে শূন্যতার গণনা করে।

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

আপনি যদি সঠিক যুক্তিযুক্ত উত্তরটি পছন্দ করতে চান তবে কোনও জরিমানার জন্য শেষের আগে মুছুন .5এবং রাখুন । প্রোগ্রামটি নিজেই 103/106 বা প্রায় .972 এর বিশিষ্টতা রয়েছে।/2&

— hYPotenuser
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.