L' indice Simpson est une mesure de la diversité d'une collection d'articles avec des doublons. Il s'agit simplement de la probabilité de tirer au hasard deux éléments différents lors de la cueillette sans remplacement.

Avec des narticles dans des groupes d' n_1, ..., n_karticles identiques, la probabilité de deux articles différents est

Par exemple, si vous avez 3 pommes, 2 bananes et 1 carotte, l'indice de diversité est

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

Alternativement, le nombre de paires non ordonnées d'articles différents est 3*2 + 3*1 + 2*1 = 11globalement de 15 paires, et 11/15 = 0.7333.

Contribution:

Une chaîne de caractères Aà Z. Ou, une liste de ces personnages. Sa longueur sera d'au moins 2. Vous ne pouvez pas supposer qu'il est trié.

Production:

L'indice de diversité Simpson des caractères de cette chaîne, c'est-à-dire la probabilité que deux caractères pris au hasard avec remplacement soient différents. Il s'agit d'un nombre compris entre 0 et 1 inclus.

Lors de la sortie d'un flottant, affichez au moins 4 chiffres, tout en terminant les sorties exactes comme 1ou 1.0ou 0.375sont OK.

Vous ne pouvez pas utiliser de fonctions intégrées qui calculent spécifiquement des indices de diversité ou des mesures d'entropie. L'échantillonnage aléatoire réel est très bien, tant que vous obtenez une précision suffisante sur les cas de test.

Cas de test

AAABBC 0.73333
ACBABA 0.73333
WWW 0.0
CODE 1.0
PROGRAMMING 0.94545

Classement

Voici un classement par langue, gracieuseté de Martin Büttner .

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les rayant. Par exemple:

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

function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/53455/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);i=i.replace("{{PLACE}}",t++ +".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=45497;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*((?:[^,\s]|\s+[^-,\s])*)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

Python 2, 72

L'entrée peut être une chaîne ou une liste.

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

Je sais déjà que ce serait 2 octets plus court en Python 3, alors ne me conseillez pas :)

Pyth - 19 13 12 11 octets

Merci à @isaacg de m'avoir parlé de n

Utilise une approche de force brute avec .cune fonction de combinaisons.

csnMK.cz2lK

Essayez-le ici en ligne .

Suite de tests .

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

SQL (PostgreSQL), 182 octets

En fonction des postgres.

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

Explication

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

Utilisation et test

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

J, 26 octets

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

la partie cool

J'ai trouvé les comptes de chaque caractère en saisissant </.la chaîne contre elle-même ( ~pour réflexive) puis en comptant les lettres de chaque case.

Python 3, 66 58 octets

Cela utilise la formule de comptage simple fournie dans la question, rien de trop compliqué. C'est une fonction lambda anonyme, donc pour l'utiliser, vous devez lui donner un nom.

8 octets enregistrés (!) Grâce à Sp3000.

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

Usage:

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

ou

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

APL, 39 36 octets

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

Cela crée une monade sans nom.

{
  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))
}

Vous pouvez l' essayer en ligne !

Pyth, 13 octets

csnM*zz*lztlz

Une traduction littérale de la solution de @ feersum.

CJam, 25 octets

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

Essayez-le en ligne

Mise en œuvre assez directe de la formule de la question.

Explication:

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.

J, 37 octets

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

mais je crois qu'il peut encore être raccourci.

Exemple

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

Ceci est juste une version tacite de la fonction suivante:

   fun =: 3 : 0
a1=.+/"1 (~.y)=/y
N=.(+/a1)*(<:+/a1)
n=.a1*a1-1
1-(+/n)%N
)

C, 89

Le score concerne funiquement la fonction et exclut les espaces inutiles, qui ne sont inclus que pour plus de clarté. la mainfonction est uniquement destinée aux tests.

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]));
}

Il compare simplement chaque caractère avec tous les autres caractères, puis divise par le nombre total de comparaisons.

Python 3, 56

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

Compte les paires d'éléments inégaux, puis divise par le nombre de ces paires.

Haskell, 83 octets

Je sais que je suis en retard, j'ai trouvé ça, j'avais oublié de poster. Un peu inélégant avec Haskell m'obligeant à convertir des entiers en nombres que vous pouvez diviser les uns par les autres.

s z=(l(filter id p)-l z)/(l p-l z) where p=[c==d|c<-z,d<-z]
l=fromIntegral.length

CJam, 23 octets

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

Au niveau des octets, il s'agit d'une amélioration très mineure par rapport à la réponse de @ RetoKoradi , mais elle utilise une astuce intéressante :

La somme des n premiers entiers non négatifs est égale à n (n - 1) / 2 , que nous pouvons utiliser pour calculer le numérateur et le dénominateur, tous deux divisés par 2 , de la fraction dans la formule de la question.

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

 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.

APL, 26 octets

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

Explication:

• ≢⍵: obtenir la longueur de la première dimension de ⍵. Étant donné que ⍵c'est censé être une chaîne, cela signifie la longueur de la chaîne.
• {⍴⍵}⌸⍵: pour chaque élément unique dans ⍵, obtenez les longueurs de chaque dimension de la liste des occurrences. Cela donne le nombre de fois qu'un élément se produit pour chaque élément, sous forme de 1×≢⍵matrice.
• ,: concatène les deux le long de l'axe horizontal. Étant donné que ≢⍵est un scalaire et que l'autre valeur est une colonne, nous obtenons une 2×≢⍵matrice dans laquelle la première colonne a le nombre de fois qu'un élément se produit pour chaque élément, et la deuxième colonne a le nombre total d'éléments.
• {⍵×⍵-1}: pour chaque cellule de la matrice, calculez N(N-1).
• ÷/: réduire les lignes par division. Cela divise la valeur de chaque article par la valeur du total.
• +/: additionne le résultat pour chaque ligne.
• 1-: soustraire de 1