सिम्पसन विविधता सूचकांक

19

सिम्पसन सूचकांक डुप्लिकेट के साथ आइटम का संग्रह की विविधता का एक उपाय है। यादृच्छिक रूप से एक समान रूप से प्रतिस्थापन किए बिना दो अलग-अलग वस्तुओं को खींचने की संभावना है।

साथ nके समूह में आइटम n_1, ..., n_kसमान आइटम का, दो अलग अलग मदों की संभावना है

$$ 1- \ sum_ {i = 1} ^ k \ frac {n_i (n_i-1)} {n (n -1)} $$

उदाहरण के लिए, यदि आपके पास 3 सेब, 2 केले और 1 गाजर है, तो विविधता सूचकांक है

D = 1 - (6 + 2 + 0)/30 = 0.7333

वैकल्पिक रूप से, विभिन्न मदों की अनियंत्रित जोड़ियों की संख्या 3*2 + 3*1 + 2*1 = 11कुल मिलाकर 15 जोड़ियों में से है, और 11/15 = 0.7333।

इनपुट:

पात्रों Aका एक तार Z। या, ऐसे पात्रों की एक सूची। इसकी लंबाई कम से कम 2 होगी। आप इसे छांटना नहीं मान सकते।

आउटपुट:

उस तार में वर्णों की सिम्पसन विविधता सूचकांक, यानी, संभावना है कि प्रतिस्थापन के साथ यादृच्छिक रूप से लिए गए दो वर्ण अलग-अलग हैं। यह 0 और 1 समावेशी के बीच की एक संख्या है।

जब एक नाव, प्रदर्शन में कम से कम 4 अंक outputting, जैसे सटीक आउटपुट समाप्त हालांकि 1या 1.0या 0.375ठीक हैं।

आप बिल्ट-इन का उपयोग नहीं कर सकते हैं जो विशेष रूप से विविधता सूचकांकों या एन्ट्रापी उपायों की गणना करते हैं। वास्तविक यादृच्छिक नमूना ठीक है, जब तक आपको परीक्षण मामलों पर पर्याप्त सटीकता नहीं मिल जाती है।

परीक्षण के मामलों

AAABBC 0.73333
ACBABA 0.73333
WWW 0.0
CODE 1.0
PROGRAMMING 0.94545

लीडरबोर्ड

यहां मार्टिन ब्यूटनर के सौजन्य से एक भाषा-भाषी लीडरबोर्ड मौजूद है ।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके सबमिशन का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

code-golf  math 
— XNOR
स्रोत
आप गिन्नी-सिम्पसन इंडेक्स का उपयोग कर रहे हैं, जब उपयोग करने के लिए बेहतर उपाय उलटा सिम्पसन इंडेक्स उर्फ ​​प्रभावी प्रकार की संख्या है।
— जो जेड।
1
मूल रूप से 1/इसके बजाय 1-। [शौकिया सांख्यिकीविद रैंट हैट से दूर हैं]
— जो जेड।

जवाबों:

5

अजगर 2, 72

इनपुट एक स्ट्रिंग या एक सूची हो सकती है।

def f(s):l=len(s);return sum(s[i%l]<>s[i/l]for i in range(l*l))/(l-1.)/l

मुझे पहले से ही पता है कि यह पायथन 3 में 2 बाइट्स छोटा होगा इसलिए कृपया मुझे सलाह न दें :)

— feersum
स्रोत
कोण कोष्ठक <>36 की स्थिति में क्या कर रहे हैं ? मैंने उस वाक्य-विन्यास को पहले कभी नहीं देखा है।
— अप्रोचडार्कनेसफिश
@ टुट्टीफ्रूटीजैक्युज़ी: यह एक पर्यायवाची है !=।
— रेमकोगर्लिच
1
@TuttiFruttiJacuzzi जब तक आप केवल 2 अजगर नहीं हैंfrom __future__ import barry_as_FLUFL
— मैट
@ Vioz- l=len(s);वहाँ के साथ नहीं
— Sp3000
@ Sp3000 राइट, ध्यान नहीं दिया गया कि कितनी बार इसका इस्तेमाल किया गया था।
— केड
4

पायथ - 19 13 12 11 बाइट्स

N के बारे में बताने के लिए @isaacg को धन्यवाद

.cसंयोजन समारोह के साथ जानवर बल दृष्टिकोण का उपयोग करता है ।

csnMK.cz2lK

इसे यहाँ ऑनलाइन प्रयास करें ।

टेस्ट सूट ।

c                Float division
 s               Sum (works with True and False)
  nM             Map uniqueness
   K             Assign value to K and use value
    .c 2         Combinations of length 2
      z          Of input
 lK              Length of K
— Maltysen
स्रोत
आप के .{साथ बदल सकते हैं n- वे यहाँ समकक्ष हैं।
— इसहाक
@isaacg ओह पता नहीं था कि यह स्वचालित रूप से विभाजित, शांत है।
— माल्टेसन
4

SQL (PostgreSQL), 182 बाइट्स

समारोह में एक समारोह के रूप में।

CREATE FUNCTION F(TEXT)RETURNS NUMERIC AS'SELECT 1-sum(d*(d-1))/(sum(d)*(sum(d)-1))FROM(SELECT COUNT(*)d FROM(SELECT*FROM regexp_split_to_table($1,''''))I(S)GROUP BY S)A'LANGUAGE SQL

व्याख्या

CREATE FUNCTION F(TEXT) -- Create function f taking text parameter
RETURNS NUMERIC         -- declare return type
AS'                     -- return definition
    SELECT 1-sum(d*(d-1))/(sum(d)*(sum(d)-1)) -- Calculate simpson index
    FROM(
        SELECT COUNT(*)d  -- Count occurrences of each character
        FROM(             -- Split the string into characters
            SELECT*FROM regexp_split_to_table($1,'''')
            )I(S)
        GROUP BY S        -- group on the characters
        )A 
'
LANGUAGE SQL

उपयोग और टेस्ट रन

SELECT S, F(S)
FROM (
    VALUES
    ('AAABBC'),
    ('ACBABA'),
    ('WWW'),
    ('CODE'),
    ('PROGRAMMING')
   )I(S)

S              F
-------------- -----------------------
AAABBC         0.73333333333333333333
ACBABA         0.73333333333333333333
WWW            0.00000000000000000000
CODE           1.00000000000000000000
PROGRAMMING    0.94545454545454545455
— MickyT
स्रोत
4

जे, 26 बाइट्स

1-+/((#&:>@</.~)%&(<:*])#)

ठंडा हिस्सा

मैंने प्रत्येक चरित्र की गिनती </.को स्ट्रिंग के ~लिए ( प्रतिवर्त के लिए) कुंजी लगाकर पाया, फिर प्रत्येक बॉक्स के अक्षरों की गिनती की।

— protist
स्रोत
1
(#&:>@</.~)हो सकता है (#/.~)और (<:*])हो सकता है (*<:)। यदि आप एक उचित फ़ंक्शन का उपयोग करते हैं तो यह देता है (1-(#/.~)+/@:%&(*<:)#)। जैसा कि आस-पास के ब्रेसिज़ आमतौर पर यहां नहीं गिने जाते हैं (छोड़ते हुए 1-(#/.~)+/@:%&(*<:)#, फ़ंक्शन का शरीर) यह 20 बाइट्स देता है।
— रैंडम जूल
4

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

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

Sp3000 के लिए 8 बाइट्स (!) की बचत की।

lambda s:1-sum(x-1for x in map(s.count,s))/len(s)/~-len(s)

उपयोग:

>>> f=lambda s:1-sum(x-1for x in map(s.count,s))/len(s)/~-len(s)
>>> f("PROGRAMMING")
0.945454

या

>>> (lambda s:1-sum(x-1for x in map(s.count,s))/len(s)/~-len(s))("PROGRAMMING")
0.945454
— Kade
स्रोत
3

एपीएल, 39 36 बाइट्स

{n←{≢⍵}⌸⍵⋄N←≢⍵⋄1-(N-⍨N×N)÷⍨+/n-⍨n×n}

यह एक अनाम मोनाड बनाता है।

{
  n ← {≢⍵}⌸⍵               ⍝ Number of occurrences of each letter
  N ← ≢⍵                   ⍝ Number of characters in the input
  1-(N-⍨N×N)÷⍨+/n-⍨n×n     ⍝ Return 1 - sum((n*n-n)/(N*N-N))
}

आप इसे ऑनलाइन आज़मा सकते हैं !

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

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

csnM*zz*lztlz

@ Feersum के समाधान का बहुत शाब्दिक अनुवाद।

— orlp
स्रोत
2

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

l$_e`0f=_:(.*:+\,_(*d/1\-

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

प्रश्न में सूत्र का प्रत्यक्ष रूप से कार्यान्वयन।

स्पष्टीकरण:

l     Get input.
$     Sort it.
_     Copy for evaluation of denominator towards the end.
e`    Run-length encoding of string.
0f=   Map letter/length pairs from RLE to only length.
      We now have a list of letter counts.
_     Copy list.
:(    Map with decrement operator. Copy now contains letter counts minus 1.
.*    Vectorized multiply. Results in list of n*(n-1) for each letter.
:+    Sum vector. This is the numerator.
\     Bring copy of input string to top.
,     Calculate length.
_(    Copy and decrement.
*     Multiply. This is the denominator, n*(n-1) for the entire string.
d     Convert to double, otherwise we would get integer division.
/     Divide.
1\-   Calculate one minus result of division to get final result.
— रेटो कोराडी
स्रोत
1

जे, 37 बाइट्स

(1-([:+/]*<:)%+/*[:<:+/)([:+/"1~.=/])

लेकिन मेरा मानना ​​है कि इसे अभी भी छोटा किया जा सकता है।

उदाहरण

(1-([:+/]*<:)%+/*[:<:+/)([:+/"1~.=/]) 'AAABBC'

यह निम्नलिखित कार्य का सिर्फ एक मौन संस्करण है:

   fun =: 3 : 0
a1=.+/"1 (~.y)=/y
N=.(+/a1)*(<:+/a1)
n=.a1*a1-1
1-(+/n)%N
)
— gar
स्रोत
कुछ अतिरिक्त गोल्फिंग और इसे एक उचित कार्य करने के बाद: (1-(%&([:+/]*<:)+/)@(+/"1@=))29 बाइट्स देता है। 27 अगर हम फ़ंक्शन के आस-पास के ब्रेसिज़ की गिनती नहीं करते हैं (1-(%&([:+/]*<:)+/)@(+/"1@=))क्योंकि यह यहाँ आम है। नोट्स: =yबिलकुल सही है (~.=/])yऔर कंपोजिशन ( x u&v y= (v x) u (v y)) भी बहुत मददगार था।
— रैंडम जूल
सुझाव के लिए धन्यवाद! मैं अभी भी खुद को टैसी भाव लिखना सीख रहा हूं। अभी के लिए, मैं 13: 0 का उपयोग करता हूं ताकि टैसीट परिभाषाओं को भाग और संयोजन द्वारा उत्पन्न किया जा सके।
— गरमा
1

सी, 89

स्कोर fकेवल फ़ंक्शन के लिए है और अनावश्यक व्हाट्सएप को बाहर करता है, जो केवल स्पष्टता के लिए शामिल है। mainसमारोह केवल परीक्षण के लिए है।

i,c,n;
float f(char*v){
  n=strlen(v);
  for(i=n*n;i--;)c+=v[i%n]!=v[i/n]; 
  return 1.0*c/(n*n-n);
}

main(int C,char**V){
  printf("%f",f(V[1]));
}

यह हर चरित्र की हर दूसरे चरित्र से तुलना करता है, फिर कुल तुलनाओं की संख्या से विभाजित होता है।

— स्तर नदी सेंट
स्रोत
1

पायथन 3, 56

lambda s:sum(a!=b for a in s for b in s)/len(s)/~-len(s)

असमान तत्वों के जोड़े को गिना जाता है, फिर ऐसे जोड़े की संख्या से विभाजित होता है।

— XNOR
स्रोत
1

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

मुझे पता है मुझे देर हो गई है, यह पता चला, पोस्ट करना भूल गया था। Haskell के साथ Kinda inelegant ने मुझे पूर्णांक को उन संख्याओं में बदलने की आवश्यकता की, जिन्हें आप एक दूसरे से विभाजित कर सकते हैं।

s z=(l(filter id p)-l z)/(l p-l z) where p=[c==d|c<-z,d<-z]
l=fromIntegral.length
— लीफ़ विलर्ट्स
स्रोत
0

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

1r$e`{0=,~}%_:+\,,:+d/-

बाइट-वार, यह @ रेटोकोरडी के उत्तर पर बहुत मामूली सुधार है , लेकिन यह एक साफ चाल का उपयोग करता है:

पहले n गैर-ऋणात्मक पूर्णांकों का योग n (n - 1) / 2 के बराबर होता है , जिसका उपयोग हम अंश और हर की गणना करने के लिए कर सकते हैं, दोनों को प्रश्न के सूत्र में भिन्न से 2 से विभाजित करते हैं।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

 r$                     e# Read a token from STDIN and sort it.
   e`                   e# Perform run-length encoding.
     {    }%            e# For each [length character] pair:
      0=                e#   Retrieve the length of the run (L).
        ,~              e#   Push 0 1 2 ... L-1.
                        e# Collect all results in an array.
            _:+         e# Push the sum of the entries of a copy.
               \,       e# Push the length of the array (L).
                 ,:+    e# Push 0 + 1 + 2 + ... + L-1 = L(L-1)/2.
                    d/  e# Cast to Double and divide.
1                     - e# Subtract the result from 1.
— डेनिस
स्रोत
0

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

{1-+/÷/{⍵×⍵-1}({⍴⍵}⌸⍵),≢⍵}

स्पष्टीकरण:

  • ≢⍵: के पहले आयाम की लंबाई प्राप्त करें ⍵। यह ⍵माना जाता है कि इसे एक स्ट्रिंग माना जाता है, इसका अर्थ है स्ट्रिंग की लंबाई।
  • {⍴⍵}⌸⍵: प्रत्येक अद्वितीय तत्व ⍵के लिए, घटनाओं की सूची के प्रत्येक आयाम की लंबाई प्राप्त करें। यह प्रत्येक आइटम के लिए एक 1×≢⍵मैट्रिक्स के रूप में होने वाले समय की मात्रा देता है ।
  • ,: क्षैतिज अक्ष के साथ दोनों को मिलाएं। जबसे≢⍵ एक अदिश राशि है, और दूसरा मान एक कॉलम है, हमें एक 2×≢⍵मैट्रिक्स मिलता है जहां पहले कॉलम में प्रत्येक आइटम के लिए एक आइटम होने की मात्रा होती है, और दूसरे कॉलम में कुल आइटम होते हैं।
  • {⍵×⍵-1}: मैट्रिक्स में प्रत्येक सेल के लिए, गणना करें N(N-1)।
  • ÷/: विभाजन द्वारा पंक्तियों को कम करें। यह कुल के लिए मूल्य द्वारा प्रत्येक आइटम के लिए मूल्य को विभाजित करता है।
  • +/: प्रत्येक पंक्ति के लिए परिणाम का योग।
  • 1-: इसे 1 से घटाएं
— मारीनस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.