Escreva uma função ou programa que determine o custo de uma determinada string, em que

• o custo de cada caractere é igual ao número de vezes que o caractere ocorreu até esse ponto na sequência e
• o custo da string é a soma dos custos de seus caracteres.

Exemplo

Para uma entrada de abaacab, o custo é calculado da seguinte forma:

a b a a c a b
1   2 3   4    occurrence of a
  1         2  occurrence of b
        1      occurrence of c
1+1+2+3+1+4+2 = 14

Assim, o custo da cadeia abaacabé 14.

Regras

• A pontuação do seu envio é o custo do seu código, conforme definido acima , ou seja, seu envio é executado em seu próprio código-fonte, com uma pontuação menor sendo melhor.
• Seu envio deve funcionar com seqüências contendo caracteres ASCII imprimíveis, além de todos os caracteres usados ​​no envio.
• Os personagens são case-sensitive, isto é ae Asão personagens diferentes.

Casos de teste

input -> output
"abaacab" -> 14
"Programming Puzzles & Code Golf" -> 47
"" -> 0
"       " -> 28
"abcdefg" -> 7
"aA" -> 2

Entre os melhores

var QUESTION_ID=127261,OVERRIDE_USER=56433;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px} /* font fix */ body {font-family: Arial,"Helvetica Neue",Helvetica,sans-serif;} /* #language-list x-pos fix */ #answer-list {margin-right: 200px;}

<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><td>Language</td><td>Score</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

MATL , pontuação 4

&=Rz

Experimente online!

Explicação

Considere a entrada 'ABBA'como um exemplo.

&=   % Implicit input. Matrix of all equality comparisons
     % STACK: [1 0 0 1;
               0 1 1 0;
               0 1 1 0;
               1 0 0 1]
R    % Upper triangular part
     % STACK: [1 0 0 1;
               0 1 1 0;
               0 0 1 0;
               0 0 0 1]
z    % Number of nonzeros. Implicitly display
     % STACK: 6

Python , pontuação 49

lambda S:sum(1+S.count(C)for[C]in	S)/2

Experimente online!

Há uma guia depois in.

Classificação da pontuação:

• +27 por 27 caracteres únicos
• +16 por 8 caracteres duplos: ()Camnou
• +6 por 1 caractere triplo: S

T-SQL, pontuação 775 579! 580

declaRe @ char(876),@x int,@v int=0Select @=q+CHAR(9)from z X:seleCT @x=len(@),@=REPLACE(@,LEFT(@,1),''),@v+=(@x-LEN(@))*(@x-LEN(@)+1)/2IF LEN(@)>0GOTO X prINT @v-1

EDIT : Soltou algumas variáveis, compactou um pouco. Até 16 @símbolos em vez de 22, isso por si só reduz minha pontuação em 117 pontos!

Bom concurso, eu gosto do requisito de otimizar algo além da contagem total de caracteres.

A entrada é via campo varchar q na tabela z pré-existente , de acordo com nossas regras de IO . O banco de dados que contém esta tabela de entrada deve ser definido como um agrupamento que diferencia maiúsculas de minúsculas .

Formatado:

declaRe @ char(876), @x int, @v int=0
Select @=q+CHAR(9)from z
X:
    seleCT @x=len(@)
          ,@=REPLACE(@,LEFT(@,1),'')
          ,@v+=(@x-LEN(@))*(@x-LEN(@)+1)/2
IF LEN(@)>0 GOTO X
prINT @v-1

As palavras-chave SQL não diferenciam maiúsculas de minúsculas, por isso usei maiúsculas e minúsculas para minimizar a contagem de letras duplicadas ( aaAA gera uma pontuação melhor / menor que aaaa ).

O loop principal compara o comprimento antes e depois de remover todas as instâncias do primeiro caractere. Essa diferença n * (n + 1) / 2 é adicionada ao total em execução.

A LEN()função SQL irrita irritantemente os espaços à direita, então tive que acrescentar um caractere de controle e subtrair 1 no final.

EDIT : Corrigido um erro de cálculo da minha própria pontuação em 2 pontos (problema com as aspas), reduzido em 1 ao alterar a caixa de um R. Também trabalhando em uma estratégia completamente diferente, postarei isso como sua própria resposta.

C (gcc) , pontuação:  113  103 100   96  91

Obrigado a @ugoren, @CalculatorFeline, @gastropner, @ l4m2 e @ JS1 pelas dicas.

g(char*s){int y[238]={};while(*s)*y-=--y[*s++];*y/=1;}

Inicializa uma matriz de zeros e, em seguida, usa os valores ASCII dos caracteres na sequência como índices para essa matriz para acompanhar o número de instâncias de cada caractere na sequência.

Experimente online!

JavaScript (ES6), pontuação 81 78

Guardado 3 pontos graças a @Arnauld

s=>s.replace(d=/./g,z=>q+=d[z]=-~d[z],q=0)&&q

Minha solução recursiva original score-81:

f=([c,...s],d={})=>c?(d[c]=-~d[c])+f(s,d):0

Haskell , pontuação 42

f l=sum[1|c<-l,d<-c:l,d==c]/2

Experimente online!

Anonimizar \l->dá a mesma pontuação.

Geléia , pontuação 6

;\ċ"⁸S

Experimente online!

Retina , pontuação 34

s(O`.
M&!`^|(?<=(.))\1*
.

Experimente online!

Explicação

s(O`.

Começamos classificando todos os caracteres na entrada para que caracteres idênticos sejam agrupados em uma única execução. A s(ativa o modo Singleline para todas as fases (ou seja, faz .linefeeds jogo).

M&!s`^|(?<=(.))\1*

O objetivo é transformar uma corrida de n caracteres em T _n caracteres (o n º número triangular) porque essa é a pontuação das ocorrências desta natureza. Para fazer isso, encontramos correspondências sobrepostas. Em particular, para cada i em [1, n] , vamos incluir caracteres i-1 na partida. Recebemos todas essas correspondências devido à bandeira sobreposta &. Isso nos dá n * (n-1) / 2 = T _n-1 = T _n - n caracteres apenas das correspondências. Mas a fase de partida juntará esses itens aos feeds de linha, que são n feeds de linha para nfósforos. Só tem um problema. Não haverá avanço de linha após a última correspondência, portanto, o número total de caracteres na saída é um a menos do que precisamos. Corrigimos isso combinando também o início da entrada, o que nos fornece um único avanço de linha principal se houver pelo menos uma outra correspondência.

.

Finalmente, contamos apenas quantos caracteres existem na string.

Haskell, pontuação 52 51

f(a:b)=1+sum[1|c<-b,c==a]+f b;f _=0

Há uma guia entre fe _.

Experimente online!

O valor da cadeia vazia é 0. O valor da cadeia s, onde aé o primeiro caractere e bo restante da cadeia é 1 mais as ocorrências de ain bmais uma chamada recursiva com b.

J , pontuação 16

1#.,@(*+/\"1)&=

Experimente online!

Explicação

1#.,@(*+/\"1)&=
              =  Self-classify: bit matrix of equality between input
                 and its unique elements.
     (      )&   Apply verb in parentheses to it:
       +/\         running sums
          "1       of each row
      *            multiplied with original matrix.
                 This causes the i'th 1 on each row to be replaced by i.
   ,@            Flatten the resulting matrix
1#.              and interpret as a base-1 number, computing its sum.

Usar em 1#.vez de +/@para a soma economizou alguns pontos e &poderia ser usado em vez de @em um contexto monádico para salvar mais um. O repetido 1me custa um ponto extra, mas não consegui me livrar dele.

R , pontuação: 67 83 95 128

-61 graças às principais dicas de Giuseppe

function(x,y=table(utf8ToInt(x)))y%*%{y+1}/2

Experimente online!

A cadeia é dividida usando utf8ToInte cada valor ascii é contado table. O resultado é calculado usando uma multiplicação de matrizes %*%sobre isso em si + 1 e, finalmente, metade.

05AB1E , pontuação 6

{γ€gLO

Experimente online!

Pyth , pontuação 6

1 byte graças a isaacg.

+F/V._

Suíte de teste.

Como funciona

+F/V._
+F/V._QQ  implicit input
  /V      vectorize count: for each element in the first argument,
                           count the number of occurrences of the
                           second argument:
    ._Q       all prefixes of input
       Q      input
+F        fold (reduce) on +, base case 0.

J , pontuação: 14 12 11

$+/@,2!1#.=

Experimente online!

Geléia , pontuação 7

ċЀQRFS

Explicação:

   Q    get unique letters
ċЀ     count the occurences of each letter in the original string
    R   [1..n] for n in list of frequencies
     F  flatten list
      S sum
        (implicit output)

Experimente online!

C, 60 bytes, pontuação 108 95

g(char*s){int y[256]={},z=0;while(*s)z-=--y[*s++];return z;}

Experimente online!

Normalmente, os operadores de pré e pós-incremento são ótimos para o golfe de código, mas realmente prejudicam esse desafio!

Edição: subtraindo contagens negativas em vez de adicionar positivas, salvei um monte de pontuação. Substituindo for()por while()eliminou um ponto-e-vírgula também.

Perl 6 , pontuação  61 56 53 46  44

(1 X..*.comb.Bag.values).flat.sum

Tente

{sum flat 1 X.. .comb.Bag.values}

Tente

{sum flat 1 X.. values(.comb.Bag)}

Tente

{[+] flat	1	X.. values(.comb.Bag)}

Tente

{[+] flat	1	X.. values(bag
.comb)}

Tente

C # (.NET Core) , pontuação ∞ (quero dizer, 209)

b=>b.Distinct().Select(z=>{var w=b.Count(p=>p==z);return w*(w+1)/2;}).Sum()

Experimente online!

A pontuação inclui o seguinte:

using System.Linq;

Geléia , pontuação 5

ĠJ€ẎS

Experimente online!

Obrigado a Leaky Nun por -2 (anteriormente em sua resposta )

PowerShell, pontuação 64

$z=@{}
$ARGS|% getE*|%{$u+=($Z.$_+=1)};$U

(A pontuação é baseada em uma nova linha de alimentação de linha única, que não é padrão do Windows, mas funciona no PS).

PS C:\> D:\unique-is-cheap.ps1 (gc D:\unique-is-cheap.ps1 -raw)
64

• Contador Hashtable @{}
• Iterar através das letras; $argsé uma matriz de parâmetros - nesse caso, a string de entrada a torna uma única matriz de itens; |%faz um loop foreach sobre os itens e usa o getE*atalho para corresponder ao GetEnumerator()método string e chame-o para transformar a string em um fluxo de caracteres.
• |%faça um loop sobre os caracteres e aumente sua entrada de hashtable, adicione-a ao total em execução. O ($x+=1)formulário com parens modifica a variável e gera o novo valor para uso.
• Saída do total em execução.

(Quando o escrevi pela primeira vez, era $c=@{};$t=0;[char[]]"$args"|%{$c[$_]++;$t+=$c[$_]};$tcom uma pontuação de 128 e parecia que não iria diminuir muito. Reduzir para 64 é bastante agradável).

Julia 0.6 , 45 bytes, Pontuação: 77

Inspirado na solução MATL:

f(w)=sum(UpperTriangular([z==j for z=w,j=w]))

Experimente online!

Uma solução menos bonita, usando contagens:

Julia 0.6 , pontuação: 82

F(w)=sum(l->[l+1]l/2,count(x->x==i,w)for i=Set(w))

Experimente online!

Agradecemos a Guiseppe por apontar a pontuação e obter dicas. Esses comentários me ajudaram muito.

Java 10, score: 149 138 137 134 133 130 103 102 101 100

( Bytes: 72 73 74 75 64 62 61 ) Os bytes aumentam, mas a pontuação diminui. : D

x->{int j=0,q[]=new int[256];for(var    C:x)j+=++q[C];return
j;}

Pontuação de -28 (e -11 bytes) graças a @Nevay .
-1 pontos (e -2 bytes) graças a @ OlivierGrégoire .
-1 pontuação (e -1 byte) convertendo o Java 8 em Java 10.

Explicação:

Experimente aqui.

x->{                     // Method with character-array parameter and integer return-type
  int j=0,               //  Result-integer, starting at 0
      q[]=new int[256];  //  Integer-array with 256 times 0
  for(var   C:x)         //  Loop over the characters of the input array
    j+=++q[C];           //   Raise the value in the array by 1,
                         //   and then add it to the result-integer
  return                 //  Return 
  j;}                    //         the result

F #, pontuação 120 118

let j z=Seq.countBy id z|>Seq.sumBy(fun x->List.sum[0..snd x])

-2 graças a Kevin Cruijssen !

Experimente online!

Tira a stringcomo entrada. Seq.countByemparelha cada caractere distinto com sua contagem ( idé a função de identidade) para que você termine com uma coleção como 'a' = 4, 'b' = 2etc.

Ele Seq.sumBypega a contagem para cada letra e soma todos os números da 0contagem para essa letra. Portanto, se 'a' = 4a coleção seria o 0, 1, 2, 3, 4que é somado em conjunto 10. Em seguida, Seq.sumBysoma todos esses totais.

APL (Dyalog) , pontuação 15

+/1 1⍉+\∘.=⍨⍞

Experimente online!

⍞ obter entrada de texto

∘.=⍨ tabela de igualdade com auto

+\ soma acumulada entre

1 1⍉ diagonal (lit. recolher duas dimensões na dimensão um)

+/ soma

Retina , pontuação 68 45 43

s`(.)(?<=((\1)|.)+)
$#3$*
1

Experimente online! O link mostra a pontuação. Editar: obrigado a @MartinEnder que salvou 20 bytes usando correspondências sobrepostas em vez de lookaheads e mais três bytes agrupando os estágios para que o ssinalizador precise ser aplicado apenas uma vez. Economizou mais dois bytes calculando o número triangular de maneira diferente, evitando a necessidade de uma classificação.

PHP , 45 bytes, Pontuação 78

WHILE($x=ORD($argn[$v++]))$y+=$$x-=-1;echo$y;

Experimente online!

PHP , 46 bytes, Pontuação: 79 bytes

WHILE(~$xy=$argn[$vz++])$su-=-$$xy+=1;echo$su;

Experimente online!

PHP , 56 bytes, Pontuação 92

FOREAch(COUNT_CHARS($argn)as$z)WHILE($z)$y+=$z--;echo$y;

Experimente online!

Perl 5 pontos 91 83

Usa a -pbandeira que adiciona 2 por causa de p na divisão.

$x=$_;$b+=++$a{$_}for(split//,$x);$_=$b

Oitava , 39 bytes, Pontuação 69

@(a)sum((b=hist(a,unique(1*a))).^2+b)/2

Experimente online!

Embora exista outra resposta do Oitava, essa é totalmente minha e tem uma abordagem diferente, além de ter uma pontuação menor :).

A abordagem se resume a encontrar primeiro a contagem (b) de cada caractere único, que é alcançado usando a função de histograma. Então, para cada elemento, calculamos a soma de 1 a b, que é feita usando a fórmula (b*(b+1))/2. Em seguida, as somas individuais são todas somadas na pontuação final.

Nos testes, parece que os colchetes são realmente caros na pontuação, porque muitos são necessários. Otimizei a partir de uma pontuação inicial de cerca de 88, reorganizando as perguntas para minimizar o número de colchetes de abrir / fechar - portanto, agora fazemos o / 2 no total final em vez de individualmente, e também modifiquei a fórmula para (b^2+b)/2pois isso requer menos colchetes.

Lisp comum, pontuação 286 232 222

(loop with w =(fill(make-list 128)0)as z across(read)sum(incf(elt w(char-code z))))

Pontuação de alto valor devido à sintaxe prolífica dos operadores internos do Common Lisp.

Experimente online!

O código não destruído:

(loop with w = (fill (make-list 128) 0)  ; create a list to count characters
   as z across (read)                   ; for each character of input
   sum (incf (elt w (char-code z))))     ; increase count in list and sum

Mathematica, pontuação 54

Total[#(#+1)/2&@Counts@Characters@#]&

entrada

["ABCDEFG"]

graças a hftf