Stack Exchange secara otomatis mendeteksi pemungutan suara serial (ketika satu pengguna menaikkan atau menurunkan banyak pos pengguna lain) dan membalikkannya. Dalam tantangan ini, Anda akan menerapkan detektor "suara serial" yang sangat, sangat sederhana.

Memasukkan

Input adalah string yang mewakili daftar suara. Setiap kelompok yang terdiri dari dua karakter mewakili suara — yang pertama adalah pemilih, dan yang kedua adalah pengguna yang dipilih. Misalnya input berikut

ababbccd

dapat diuraikan sebagai ab ab bc cd, dan mewakili asuara bdua kali, bsuara csatu kali, dan csuara dsatu kali.

Input hanya akan terdiri dari huruf kecil, dan itu akan selalu panjang> 0. Anda juga tidak dapat memilih diri sendiri (jadi tidak ada aaatau hh).

Keluaran

Untuk keperluan tantangan ini, pemungutan suara seri didefinisikan sebagai setiap pemungutan suara yang diberikan pada pemakai lain sebanyak tiga kali atau lebih.

Outputnya adalah berapa banyak suara yang harus dibalik untuk setiap pengguna (yaitu, berapa banyak suara pada setiap pengguna dibalik, bukan berapa banyak suara yang telah mereka berikan dibalik), dalam format [user][votes][user2][votes2].... Misalnya, input abababab( apemungutan suara bempat kali) harus menampilkan b4(empat suara telah terbalik dari ake b).

Output mungkin dalam urutan apa pun yang Anda inginkan, tetapi input dan output harus berupa string tunggal seperti yang dijelaskan di atas.

Uji kasus

In                            Out
---------------------------------------------------------------------------
abababcbcbcbcbbababa          b7a3
edfdgdhdfgfgfgih              g3
jkkjjkkjjkkjljljljmlmlnmnmnm  j6k3m3
opqrstuv                      <none>
vwvwwvwv                      <none>
xyxyxyxyxyxyxyzyzyzyxzxzxz    y10z3
nanananananananabatman        a8
banana                        <none>

Pyth, 22 byte

pM_srSsfttTtMM.gkcz2 8

Cobalah online: Demonstrasi atau Test Suite

Penjelasan:

pM_srSsfttTtMM.gkcz2 8
                 cz2     chop the input into pairs
              .gk        group these pairs by their value
           tMM           discard the first char in each pair in each group
       fttT              discard all groups, that contain less than three pairs
      s                  concatenate all groups to get a list of chars
     S                   sort all chars
    r                8   run-length-encoding
   s                     concatenate all (count,char) pairs 
  _                      reverse the order
pM                       print each element without separator

Contoh:

input:   ededgdhdfgfgfgihed
chop:    ['ed', 'ed', 'gd', 'hd', 'fg', 'fg', 'fg', 'ih', 'ed']
group:   [['ed', 'ed', 'ed'], ['fg', 'fg', 'fg'], ['gd'], ['hd'], ['ih']]
discard: [['d', 'd', 'd'], ['g', 'g', 'g'], ['d'], ['d'], ['h']]
discard: [['d', 'd', 'd'], ['g', 'g', 'g']]
concat.: ['d', 'd', 'd', 'g', 'g', 'g']
sort:    ['d', 'd', 'd', 'g', 'g', 'g']
rle:     [[3, 'd'], [3, 'g']]
concat.: [3, 'd', 3, 'g']
reverse: ['g', 3, 'd', 3]
print:   g3d3

Tidak dapat dibaca , 1830 1796 1791 1771 1762 1745 1736 1727 1626 1606 1577 byte

Output dalam urutan abjad terbalik ( zke a) tetapi sesuai dengan aturan Anda yang tampaknya diizinkan.

'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """" '"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""'"" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" " "'" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" """ "" "" "" "" "" "" "" "" "" "" "" "" "" "" "

Penjelasan

Pertama, untuk mendapatkan kesan tentang apa yang dapat dilakukan Unreadable, berikut ini adalah operasi dasarnya:

• Anda memiliki sel tak terbatas sel bilangan bulat ukuran tak terbatas
• Anda tidak memiliki penunjuk memori seperti di Brainfuck; alih-alih, Anda menentukan sel dengan lokasi mereka pada rekaman itu. Ini berarti Anda dapat "membaca nilai # 4" atau "membaca nilai # (nilai baca # 4)" (double-dereference).
• Anda hanya bisa membaca atau menulis sel-sel memori (tidak secara langsung kenaikan / penurunan seperti di Brainfuck).
• Anda bisa menambah / mengurangi nilai dalam ekspresi. Dengan demikian, untuk kenaikan sel memori Anda harus membaca , kenaikan , menulis , atau berbeda menempatkan: write(x, inc(read(x))).
• Ada sementara loop dan kondisional ternary yang hanya dapat memeriksa nol vs non-nol.

Program ini menggunakan rekaman itu sebagai berikut. Nama-nama variabel akan digunakan dalam pseudocode nanti di bawah ini. Juga, ini mendokumentasikan versi pertama (yang 1830 byte); lihat pengeditan di bagian bawah untuk apa yang berubah sejak itu.

• Sel 0: variabelq
• Sel 1: variabel a, p,ch
• Sel 2: variabel hash,v
• Sel 3: variabel b,r
• Sel 4: variabel aa,l
• Sel 5: tetap 0 untuk menandai "akhir" dari string angka desimal
• Sel 6–95: menyimpan string angka desimal ke belakang
• Sel 96–121: menyimpan jumlah suara yang akan dikurangkan dari pengguna a(96) hingga z(121) (kode ASCII surat itu dikurangi satu).
• Sel 4657–7380: ingat kombinasi pemilih / pemilih yang telah dijumpai berapa kali. Sel-sel ini hanya memiliki 4 nilai yang mungkin: 0= belum terlihat, -1= terlihat sekali, -2= terlihat dua kali, -3= terlihat beberapa kali lebih dari 2.

Algoritma pada dasarnya melanjutkan sebagai berikut:

• Terus membaca pasangan karakter adan b. Hitung nilai hash (a-2)*(a-1)+b-1, yang unik untuk setiap kombinasi huruf a – z.
• Periksa sel memori pada nilai hash ( *hash). Jika itu -3, pengguna sudah memenuhi syarat untuk penghapusan suara, jadi tambahlah *(b-1). Kalau tidak, pengurangan *hash. Jika itu sekarang -3 , pengguna baru saja menjadi layak untuk penghapusan suara setelah tiga kejadian, sehingga kenaikan *(b-1)oleh 3.
• Setelah ini, telusuri karakter dengan urutan terbalik ( zke a) dan keluarkan karakter yang perlu dikurangi suara. Ini membutuhkan pembagian integer manual sebesar 10 untuk menerjemahkan angka menjadi angka desimal.

Dengan semua yang diklarifikasi, inilah yang tampak seperti program sebagai pseudocode:

// Read pairs of characters
while (a = read) + 1 {
    b = read

    // Calculate hash = (a-1)*(a-2)/2 + b-1
    // This also sets a = b-1
    hash = 0
    while --a {
        aa = a
        while --aa {
            ++hash
        }
    }
    while --b {
        ++a
        ++hash
    }

    // If this combination has just been seen for the third time,
    // increment *a by 3; if more than third time, increment *a by 1
    *a = (*hash + 3) ? ((--*hash) + 3 ? *a : (*a+3)) : (*a+1)
}

// Loop through the characters z to a
l = 27
while --l {                     // l loops from 26 to 1 (not 0)
    (v = *(ch = l + 95)) ? {    // 'a' is ASCII 97, but cell 96
        print (ch+1)            // print the votee

        // Now we need to turn the number v into decimal.
        // p points to where we are storing decimal digits.
        p = 5

        while v {
            // Integer division by 10 (q=quotient, r=remainder)
            r = (q = 0)
            while v {
                --v
                (++r - 10) ? 1 : {
                    r = 0
                    ++q
                }
            }
            // Store digit ASCII character
            *(++p) = r + 48     // 48 = '0'
            v = q
        }

        // Now output all the digit ASCII characters in reverse order
        while *p {
            print *(--p + 1)
        }

    } : 1
}

Sunting 1, 1830 → 1796: Menyadari bahwa saya dapat menggunakan kembali nilai loop sementara di satu tempat.

Sunting 2, 1796 → 1791: Menghidupkan program sedikit lebih kecil jika, daripada menggunakan sel 6–95, saya menyimpan angka desimal dalam sel bernomor negatif (–1 dan seterusnya). Sebagai bonus tambahan, program ini tidak lagi terbatas pada 10⁹⁰ suara!

Sunting 3, 1791 → 1771: Alih-alih menetapkan hasil *(ch = l + 95)untuk v, sekarang saya menugaskan ke qdan kemudian memindahkan tugas v = qke dalam kondisi sementara, mengambil kode ke 1777 byte. Kemudian tukar lokasi qdan vpada kaset karena qsekarang 1 lebih umum daripada v.

Sunting 4, 1771 → 1762: Duh. Menginisialisasi hashke 1 bukannya 0 adalah 9 byte lebih pendek. Kode hash sekarang 1 lagi, yang tidak masalah.

Sunting 5, 1762 → 1745: Jika saya menginisialisasi qdan rke 1 alih-alih 0, saya harus memercikkan beberapa -1di beberapa tempat untuk memperbaikinya, dan semuanya sepertinya dibatalkan - kecuali bahwa while v { --v; [...] }loop sekarang perlu menjalankan satu iterasi yang lebih sedikit, yang bisa saya lakukan dengan mengatakan while --v { [...] }, yaitu 26 karakter lebih pendek.

Sunting 6, 1745 → 1736: Alih-alih { r = 1; ++q }, kita dapat menulis q = *((r = 1)+1)+1. Ini bergantung pada fakta yang qada di slot variabel # 2. Jika ada di slot # 1 ini akan lebih pendek, tetapi keseluruhan program akan lebih lama secara keseluruhan.

Sunting 7, 1745 → 1727: Kembalikan Sunting 6 dan alih-alih mencapai penghematan dengan menggariskan bagian terdalam sementara loop ke dalam ekspresi yang menghitung kode ASCII digit, yang juga berakhir pada 1736 byte ... tetapi kemudian menyimpan instruksi penurunan (9 byte) ) dengan mengubah ((++r) - 11) ? r :ke (r - 10) ? ++r :.

Sunting 8, 1727 → 1626: Mengolah kembali perhitungan hash. Sekarang menggunakan satu loop sementara lebih sedikit. Lokasi sel sekarang pada kode ASCII mereka yang sebenarnya (tidak mati oleh 1 lagi). Variabel yang diacak ulang ke lokasi yang berbeda pada kaset karena sekarang terjadi dengan frekuensi yang berbeda.

Sunting 9, 1626 → 1606: Inlining lebih gila. Tubuh loop sementara pertama sekarang terlihat seperti ini:

// b = next char
*(b = (hash = read)) = {

    // hash = b + (a-1)*(a-2)/2
    while (a2 = --a) {
        while --a2 {
            ++hash
        }
    }

    // If this combination has just been seen for the third time,
    // increment *b by 3; if more than third time, increment *b by 1
    (*hash + 3) ? ((--*hash) + 3 ? *b : (*b+3)) : (*b+1)
}

dan tugas variabel sekarang hampir sepenuhnya berubah.

Mengedit 10, 1606 → 1577: Saya mengamati bahwa adan a2keduanya dikurangi menjadi 0 sementara loop, jadi jika saya bisa memasangkan pdengan salah satu dari mereka, tetapi tidak dengan ch, saya tidak perlu menginisialisasi pke 0(yang biaya 29 bytes). Ternyata saya bisa melakukannya dengan menukar pdan r. Variabel assigment terbaru (dan frekuensi kemunculannya dalam kode) sekarang adalah:

0 = v (3)                    (total  3)
1 = hash (6), r (5), ch (2)  (total 13)
2 = b (4), q (5)             (total  9)
3 = a (3), p (5)             (total  8)
4 = a2 (3), l (4)            (total  7)

CJam, 23 byte

Pesta lari panjang!

q2/$e`{3a>},e~Wf=$e`Wf%

atau

qW%2/$e`{3a>},e~:ce`Wf%

Jalankan semua test case

Penjelasan

q2/   e# Read input and split into pairs.
$e`   e# Sort and run-length encode - this tallies the pairs.
{     e# Filter the tallies...
  3a> e#   Keep only those which start with a 3 or greater.
},    e# Now we need to group the remaining pairs.
e~    e# Run-length decode the remaining pairs.
Wf=   e# Select the second character from each pair (the one being voted on).
$e`   e# Tally the characters by sorting and RLE'ing again.
Wf%   e# Reverse each pair, because CJam's RLE has the number first and the character last.

Versi lain dimulai dengan membalikkan pasangan, yang menyimpan dua byte di tempat lain: a) memilih karakter pertama di setiap string hanya :cbukan Wf=untuk memilih yang kedua. b) Kita tidak perlu menyortir lagi sebelum RLE kedua, karena pasangan sudah diurutkan berdasarkan karakter yang tersisa.

Bash, 95 94 85 81 byte

fold -2|sort|uniq -c|awk '$1>2{c[substr($2,2)]+=$1}END{for(x in c)printf x c[x]}'

Solusi pertama yang elegan tapi panjang untuk memulai ...

Terima kasih kepada User112638726 untuk menyimpan byte dengan sed, DigitalTrauma untuk menghemat 9 dengan fold, dan Rainer P. untuk menyimpan 4 lebih banyak dengan awk's substr!

Untuk melihat cara kerjanya, mari kita masukan abababcbcbcbcbbababa.

• Setelah fold -2(bungkus garis dengan lebar 2), kita miliki

  ab
  ab
  cb
  cb
  cb
  cb
  ba
  ba
  ba
  

• Setelah sort | uniq -c( -cadalah tanda yang sangat bagus untuk uniqmenampilkan hitungan berapa kali setiap baris muncul di input), kita mendapatkan

        3 ab
        3 ba
        4 cb
  

• Sekarang mari kita periksa awkperintah terakhir :

  • $1>2: Hanya menampilkan barang jika catatan 1 (alias jumlah suara yang identik) lebih besar dari 2 (yaitu, ≥ 3). Dengan kata lain, abaikan baris yang dimulai dengan angka ≤ 2.

  • {c[substr($2,2)]+=$1}: Jika angka lebih besar dari 2, tambahkan nomor itu ke ctabel hash, menggunakan karakter kedua dari catatan 2 (alias suara-ee) sebagai kuncinya. (Kita tidak perlu menginisialisasi semuanya menjadi nol; awklakukan itu untuk kita.)

  • END{...}: Ini hanya berarti "setelah memproses seluruh file, inilah yang harus dilakukan selanjutnya."

  • for(x in c)printf x c[x]: Cukup jelas. Cetak setiap kunci dan nilainya yang sesuai.

JavaScript, 114 113 110

f=s=>eval('o={},s.replace(/../g,m=>s.search(`^((..)*${m}){3}`)?0:o[c=m[1]]=~~o[c]+1);r="";for(v in o)r+=v+o[v]');

Kasus uji:

f=s=>eval('o={},s.replace(/../g,m=>s.search(`^((..)*${m}){3}`)?0:o[c=m[1]]=~~o[c]+1);r="";for(v in o)r+=v+o[v]');
document.body.innerHTML = [["abababcbcbcbcbbababa","b7a3"],
["edfdgdhdfgfgfgih","g3"],
["jkkjjkkjjkkjljljljmlmlnmnmnm","j6k3m3"],
["opqrstuv",""],
["vwvwwvwv",""],
["xyxyxyxyxyxyxyxyzyzyzyxzxzxz","y11z3"],
["nanananananananabatman","a8"],
["banana",""]].every(v=>(f(v[0])=="" && v[1]=="") || [...new Set(f(v[0]).match(/../g))].every(p=>new Set(v[1].match(/../g)).has(p)))

Pada tingkat tinggi, kode ini mengisi objek dengan pasangan kunci-nilai yang memetakan penerima suara ke jumlah suara, seperti { b:7, a:3 }dan kemudian menggabungkannya ke dalam sebuah string dalam satu forlingkaran. Kode dalam evalekspresi untuk memungkinkan penggunaan fordalam fungsi panah tanpa perlu menghabiskan byte { }dan ;return r.

(Props untuk pengguna81655 untuk menghemat tiga byte!)

Penjelasan evalkode:

o={},                             // object to hold name/vote mapping
s.replace(/../g,                  // for each pair of chars in input
  m=>s.search(`^((..)*${m}){3}`)  // see if pair appears 3 times
                                  //   (0 if true, -1 if not)
     ?0                           // if not, do nothing
     :o[c=m[1]]=~~o[c]+1          // if yes, increment the property named after
                                  //   the second character in the pair
);
r="";                       // return string
for(v in o)r+=v+o[v]        // populate string with characters and vote totals

Haskell, 103 byte

import Data.Lists
f s|c<-chunksOf 2 s,b<-[e!!1|e<-c,countElem e c>2]=nub b>>= \q->q:show(countElem q b)

Contoh penggunaan: f "jkkjjkkjjkkjljljljmlmlnmnmnm"->"k3j6m3"

Bagaimana itu bekerja:

c<-chunksOf 2 s                      -- split the input into lists of 2 elements
b<-[e!!1|e<-c,countElem e c>2]       -- for every element e of that list take the 2nd
                                     -- char if there are more than 2 copies of e
nub b>>= \q->q:show(countElem q b)   -- take every uniq element thereof and append
                                     -- the number how often it appears 

JavaScript (ES6), 195 174 169 167 158 byte

s=v=>eval("a={},b={},e='';(v.match(/../g)).forEach(c=>{a[c]=(a[c]||0)+1});for(var k in a){d=k[1];a[k]>2&&(b[d]=(b[d]||0)+a[k])};for(var k in b){e+=k+b[k]};e")

Uji

s=v=>eval("a={},b={},e='';(v.match(/../g)).forEach(c=>{a[c]=(a[c]||0)+1});for(var k in a){d=k[1];a[k]>2&&(b[d]=(b[d]||0)+a[k])};for(var k in b){e+=k+b[k]};e")

<input type="text" id="input" value="abababcbcbcbcbbababa" />
<button onclick="result.textContent=s(input.value)">Go</button>
<pre id="result"></pre>

Mathematica, 110 100 99 byte

g=Cases[Tr@#,#2,All]&;""<>g[g[BlockMap[$,Characters@#,2],i_*_/;i>2]/.$->Last,i_*x_:>x<>ToString@i]&

Perl, 86 84 83 byte

s/../$h{$&}++/eg;@l=%l=map{/./;$h{$_}>2?($',${$'}+=$h{$_}):()}keys%h;$"="";$_="@l"

Itu 82 byte plus 1 untuk -pargumen commandline:

$ echo xyxyxyxyxyxyxyxyzyzyzyxzxzxz | perl -p 86.pl
y11z3

s/../$h{$&}++/eg;     # construct hash %h with pair counts

@l = %l = map         # assign to array via hash to filter dupes
{                     
  /./;                # match the first character

  $h{$_}>2?           # filter on 3 or more identical votes
  (                   # return a 2 element list (k/v pair for %l):
    $',               # $POSTMATCH: the 2nd character (votee)
    ${$'} += $h{$_}   # increment votee total votes, value is new total
  )
  :()
}
keys %h;              # iterate the unique pairs

$" = "";              # set $LIST_SEPARATOR to empty string
$_ = "@l"             # implicit join using $";  $_ gets printed with -p

• perbarui 84 Hemat 2 byte dengan menguraikan grep
• perbarui 83 Hemat 1 byte dengan menggunakan vars sementara global ${$'}bukan $g{$'}. Sayangnya, $$'tidak berhasil.

Pure Bash, 151

Lebih lama dari yang saya harapkan, tapi ini dia.

declare -A a n
for((;v<${#1};v+=2));{((a[${1:v:2}]++));}
for u in ${!a[@]};{((a[$u]>2))&&((n[${u:1}]+=a[$u]));}
for u in ${!n[@]};{ printf $u${n[$u]};}

Menggunakan pengindeksan array asosiatif untuk melakukan penghitungan yang diperlukan. Membutuhkan bash versi 4.0 atau lebih tinggi.

PHP 247 Karakter

(Aduh)

$f='';for($i=0;$i<strlen($s);$i=$i+2){$a[]=$s[$i].$s[$i+1];}$r=[];for($i=0;$i<count($a);$i++){$t=array_count_values($a);$c=$t[$a[$i]];if($c>=3){$r[$a[$i][1]][$a[$i][0]]=$c;}}for($i=0;$i<count($r);$i++){$f.=key($r).array_sum(current($r));next($r);}

Dijelaskan

// Test Case
$s = 'nanananananananabatman';

// Final result here
$f = '';

// Seperate strings into array in 2 character chunks
for ($i = 0; $i < strlen($s); $i = $i + 2)
{
    $a[] = $s[$i] . $s[$i + 1];
}

// Make an array of data
// The first level of array has voted on user as key
// Inside of that array is a dictionary with the voter user as the key, and the number of votes as the value
$r = [];
for ($i = 0; $i < count($a); $i++)
{
    $t = array_count_values($a);
    $c = $t[$a[$i]];
    if ($c >= 3)
    {
        $r[$a[$i][1]][$a[$i][0]] = $c;
    }
}

// Combine votes from different users to the same user into the final result string
for ($i = 0; $i < count($r); $i++)
{
    $f .= key($r) . array_sum(current($r));
    next($r);
}

echo $f;

Apakah ini tanpa mengintip jawaban lain. Ini adalah kode golf paling sulit yang pernah saya tangani. Saya menyambut semua optimasi.

R, 221 byte

kode

f=function(s){t=strsplit(gsub("(.{2})","\\1 ", s)," ")[[1]];z=table(t)[table(t)>2];n=substr(names(z),2,2);x=data.frame(y=z,t=n);a=aggregate(x$y,by=list(x$t),sum);for(i in nrow(a):1)cat(as.character(a[i,1]),a[i,2],sep="")}

ungolfed

f <- function(s){
  l <- gsub("(.{2})", "\\1 ", s)
  t <- strsplit(l," ")[[1]]
  z <- table(t)[table(t)>2]
  n <- substr(names(z),2,2)
  x <- data.frame(y=z,t=n)
  a <- aggregate(x$y, by=list(x$t),sum)
  for(i in nrow(a):1){
    cat(as.character(a[i,1]),a[i,2],sep="")
  }
}

Ada banyak ruang untuk perbaikan di sini.