Seri oylama tespiti


51

Yığın Değişimi seri oylamayı otomatik olarak algılar (bir kullanıcı, başka bir kullanıcının yayınlarının çoğunu düşürdüğünde veya düşürdüğünde) ve tersine çevirir. Bu zorlukla, çok, çok basit bir "seri oylama" dedektörü uygulayacaksınız.

Giriş

Giriş, oy listesini gösteren bir dizedir. İki karakterden oluşan her grup bir oyu temsil eder; ilki oy veren, ikincisi ise oylanan kullanıcıdır. Örneğin, aşağıdaki giriş

ababbccd

olarak çözümlenebilir ab ab bc cdve temsil aoylayan biki kez boylayan ckez ve coylayan dkez.

Girdi yalnızca küçük harflerden oluşacak ve her zaman> 0 eşit olacaktır. Ayrıca, kendinize oy veremezsiniz (yani hayır aaveya hh).

Çıktı

Bu zorluğun amaçları doğrultusunda, seri oylama , diğer herhangi bir kullanıcıya üç veya daha fazla kez oy veren herhangi bir kullanıcı olarak tanımlanır.

Çıkışı (yani, birçok oy nasıl her kullanıcı için geri alınmalıdır kaç oy olduğu üzerinde formatında, her kullanıcı tersine dönmüş, değil ne kadar oy onlar verdikleri tersine döndü) [user][votes][user2][votes2].... Örneğin, abababab( dört defa aoylama) girdisi bçıkmalıdır b4(dört oydan geriye adoğru b).

Çıkış istediğiniz herhangi bir sırada olabilir, ancak hem giriş hem de çıkış yukarıda açıklandığı gibi tek dizeler olmalıdır.

Test durumları

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

16
nanananananananabatmanTest durumu için +1 .
Dokuz

Yanıtlar:


6

Pyth, 22 bayt

pM_srSsfttTtMM.gkcz2 8

Çevrimiçi deneyin: Gösteri veya Test Paketi

Açıklama:

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

Örnek:

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

34

Okunamayan , 1830 1796 1791 1771 1762 1745 1736 1727 1626 1606 1577 bayt

Çıkış ters alfabetik (içindedir ziçin a) ancak kurallara göre izin verilen görünüyor söyledi.

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

açıklama

İlk olarak, Okunamayan'ın neler yapabileceği hakkında bir fikir edinmek için, temel işlem şudur:

  • İsteğe bağlı tamsayı hücrelerin sonsuz bir kaseti var
  • Sen do not brainfuck gibi bir bellek işaretçisi var; bunun yerine, hücreleri banttaki konumlarına göre ayırırsınız. Bu, “4 numaralı değeri okuyabilir” veya “5 numaralı değeri okuyabilir (4 numaralı değeri okuyabilir”) (çift değişkenli).
  • Sadece bellek hücrelerini okuyabilir veya yazabilirsiniz (Brainfuck'ta olduğu gibi doğrudan artan / azalan değil).
  • Bir ifade içindeki değerleri artırabilir / azaltabilirsiniz. Böylece, gerek bir hafıza hücresini artırmak için okumak , artım , yazma koymak farklı ya: write(x, inc(read(x))).
  • Sadece sıfıra karşı sıfır olmayanı kontrol edebilen döngüler ve üçlü koşullamalar vardır.

Bu program aşağıdaki gibi bandı kullanır. Değişken isimleri, daha sonra sözde kodda kullanılacaktır. Ayrıca, bu ilk sürümü (1830 bayt idi); o zamandan beri neyin değiştiği ile ilgili düzenlemeleri inceleyin.

  • Hücre 0: değişkenq
  • Celi 1: değişkenler a, p,ch
  • Celi 2: değişkenler hash,v
  • Celi 3: değişkenler b,r
  • Celi 4: değişkenler aa,l
  • Hücre 5: ondalık basamak dizesinin “sonunu” işaretlemek için 0 kalır
  • Hücreler 6-95: ondalık basamak dizesini geriye doğru saklar
  • Hücreler 96-121: kullanıcılardan a(96) ila z(121) arası kesilecek oy sayısını saklar (mektubun ASCII kodu eksi bir).
  • Hücreler 4657-7380: hangi seçmen / seçmen kombinasyonlarına kaç kez rastlandığını hatırlayın. Bu hücrelerin yalnızca 4 olası değeri vardır: 0= henüz görülmedi, -1= bir kez görüldü, -2= iki kez görüldü, -3= 2'den fazla sayıda görüldü.

Algoritma esasen aşağıdaki şekilde ilerler:

  • Karakter çiftlerini okumaya devam edin ave b. (a-2)*(a-1)+b-1A-z harflerinin her birleşimi için benzersiz olan hash değerini hesaplayın .
  • Bellek hücresini bu değerde ( *hash) kontrol edin. Eğer öyleyse -3, kullanıcı oyların kaldırılması için zaten elverişlidir, bu nedenle artış *(b-1). Aksi takdirde, azaltma *hash. E? Er geç -3 , kullanıcı sadece gelmiştir haline üç tekrardan sonra oy kaldırılması uygun, yani artırır *(b-1)tarafından 3.
  • Bundan sonra, ters sırada (karakterler geçmesi ziçin a) ve çıkış mahsup oya ihtiyacımız var olanlar. Bu, sayının ondalık basamağa çevrilmesi için manuel tamsayı 10'a bölünmesini gerektirir.

Tüm açıklığa kavuşturulmuş halde programın sahte kod olarak göründüğü gibi:

// 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
}

Düzenleme 1, 1830 → 1796: Bir süre döngüsünün dönüş değerini bir yerde yeniden kullanabileceğimi farkettim.

Düzenleme 2, 1796 → 1791: 6–95 hücrelerini kullanmak yerine, ondalık basamakları negatif numaralı hücrelerde (-1'den sonra) saklarsam programın biraz daha küçük olduğu ortaya çıkar. Ek bir avantaj olarak, program artık 10⁹⁰ oyla sınırlı değil!

Düzenleme 3, 1771 → 1791: Yerine sonucunu atama *(ch = l + 95)için v, şimdi atamak qve sonra atamayı taşımak v = q1777 bayt kod alarak iken koşulu içine. Ardından kasetin yerini qve vbandını değiştirin çünkü qşimdi 1'den daha yaygın v.

Düzenleme 4, 1771 → 1762: Duh. hash0 yerine 1 değerine başlatma , 9 bayt daha kısa. Karma kodu artık 1 tane daha, hangisi önemli değil.

Düzenleme 5, 1762 → 1745: Sıfırlarsam qve r0 yerine 1 yaparsam, -1doğru yapmak için bazı yerlere serpmek zorundayım ve hepsi iptal edilmiş gibi görünüyor - bunun dışında while v { --v; [...] }döngünün şimdi daha az bir yineleme yapması gerekiyor, söyleyerek yapabileceğim while --v { [...] }, hangisi 26 karakter daha kısa.

Düzenleme 6, 1745 → 1736: Bunun yerine { r = 1; ++q }yazabiliriz q = *((r = 1)+1)+1. Bu q, değişken 2 numaralı slotta olduğu gerçeğine dayanmaktadır . 1. yuvada olsaydı, bu daha da kısa olurdu, ama o zaman tüm program daha uzun olurdu.

Düzenleme 7, 1745 → 1727: Düzenleme 6 Döndürüldü ve bunun yerine en içteki çevrimi içine sararak kaydetti; bu, 1736 baytta biten ASCII kodunu hesaplayan ifadeye dönüştürdü, ancak daha sonra bir azalma talimatı kaydetti (9 bayt ) değiştirerek ((++r) - 11) ? r :için (r - 10) ? ++r :.

Düzenle 8, 1727 → 1626: Karma hesaplamayı elden geçirdi. Şimdi döngü sırasında bir tane daha az kullanır. Hücre konumları şimdi gerçek ASCII kodlarındadır (artık 1 ile kapalı değildir). Değişkenler, bant üzerinde farklı yerlere yerleştirilmişlerdir, çünkü bunlar şimdi farklı frekansta meydana gelmektedir.

Düzenleme 9, 1626 → 1606: Daha fazla çılgın inlining. İlk döngü sırasında ilk vücut şimdi şuna benziyor:

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

ve değişken ataması şimdi neredeyse tamamen değişti.

10 → 1577 1606 düzenleyin: Ben görülmektedir ave a2ben eşleştirmek böylelikle eğer hem while döngüleri 0 olarak azaltılmakta polanlar biriyle, ama değil birlikte ch, ben başlatmak için gerek olmazdı piçin 0(29 bayt maliyeti). Anlaşılan pve bunu değiştirerek yapabilirim r. En yeni değişken atamaları (ve koddaki oluşum sıklıkları) şimdi:

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)

1
Bir Novemvigintillion oylarının 2 * 10 ^ 90 baytlık bir dizge gerektirdiğini ve şu anki en küçük 10 ^ 24 bayt hacminin kabaca Giza Büyük Piramidinin 1 / 3'ü olduğunu düşünüyorum. endişelenecek bir şey var. ;)
ETHproductions

1
@ETHproductions: Yine de, programı golf oynarken bu sınırlamayı düzeltmeye başladım :)
Timwi

22

CJam, 23 bayt

Uzun boylu parti!

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

veya

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

Tüm test durumlarını çalıştır

açıklama

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.

Diğer sürüm, başka bir yerde iki byte kazandıran çiftleri tersine çevirerek başlar: a) her dizideki ilk karakteri seçmek, yalnızca :cikinciyi Wf=seçmek içindir. b) İkinci RLE'den önce tekrar sıralama yapmamıza gerek yok, çünkü çiftler zaten kalan karaktere göre sıralandı.


FWIW, Qikinci cevabınızdaki qtest sarıcı olmayan amaçlar için olmalıdır.
Peter Taylor

@PeterTaylor Bunu her zaman yaparım -.-
Martin Ender

Küçük bir detay olduğunu biliyorum, ama 3karşılaştırma için listeye dönüştürmek hoş bir numara. Bunu sadece kendi eğlencem için çözdüm ve kullandığım için orada bir bayt kaybettim 0=2>. Aksi halde, ilk adımınızla neredeyse aynı şekilde bitirdim , son adım ::\ yerine kullanmak dışında Wf%.
Reto Koradi

10

Bash, 95 94 85 81 bayt

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

Zarif-ish ama uzun ilk başlamak için çözüm ...

Teşekkür etmek User112638726 bir byte kaydetmek için sedbirlikte 9 kaydetmek için DigitalTrauma, foldve Rainer P. ile 4 daha fazlasını kaydetmek için awk's substr!

Nasıl çalıştığını görmek için, girişi ele alalım abababcbcbcbcbbababa.

  • Sonra fold -2(çizgiyi 2 genişliğe sarın)

    ab
    ab
    cb
    cb
    cb
    cb
    ba
    ba
    ba
    
  • Sonra sort | uniq -c( girişte her satırın kaç kez göründüğünü gösteren sayıyı gösteren -cçok şık bir bayrak uniq)

          3 ab
          3 ba
          4 cb
    
  • Şimdi son awkkomutu inceleyelim :

    • $1>2: Sadece 1 numaralı kayıt (yani aynı oy sayısı) 2'den büyükse (yani, ≥ 3) çıktılar. Başka bir deyişle, ≤ 2 ile başlayan herhangi bir satırı yok sayın.

    • {c[substr($2,2)]+=$1}: Sayı 2'den büyükse, bu numarayı canahtar 2 olarak ikinci kayıt karakterini (oylama-ee) kullanarak karma tablosuna ekleyin . (Her şeyi sıfıra başlatmak zorunda değiliz; awkbunu bizim için yapar.)

    • END{...}: Bu sadece "tüm dosyayı işledikten sonra, sonra ne yapacağınızı" demek.

    • for(x in c)printf x c[x]: Oldukça açıklayıcı. Her anahtarı ve buna karşılık gelen değeri yazdırın.


&için eşdeğerdir \0sed içinde
User112638726

@ User112638726 Bunu bilmiyordum, teşekkürler
Doorknob

Biraz sed -r 's/.(.)/\1\n/g'|awk '{a[$1]++}END{for(i in a)printf (a[i]>2)?i a[i]:y}
azaltıldı

@ User112638726 bacadaÖrneğin , giriş için başarısız .
Doorknob

Ah evet benim kötüm!
15:15

8

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

Test durumları:

Yüksek düzeyde, bu kod, oy alıcılarını oy sayısına benzeyen { b:7, a:3 }ve daha sonra bunları bir fordöngü içindeki bir dizeye bağlayan anahtar / değer çiftleri olan bir nesneyi doldurur . Kod, bir ok işlevinde ve üzerinde bayt harcamasına gerek olmadan evalkullanımına izin veren forbir ifadededir .{ };return r

( Üç bayttan tasarruf etmek için user81655'den itibaren işlem !

evalKod açıklaması :

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

6

Haskell, 103 bayt

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)

Kullanım örneği: f "jkkjjkkjjkkjljljljmlmlnmnmnm"->"k3j6m3"

Nasıl çalışır:

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 

6

JavaScript (ES6), 195 174 169 167 158 bayt

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")

Ölçek


1
PPCG'ye Hoşgeldiniz :) Burada ve burada JS'de golf oynamak için bazı önerilerimiz var .
JS'yi

1
Birincisi, vars kaldırabilirsiniz . Kod kapsamındaki küresel alanı kirleten kimin umurunda? ;)
Doorknob

Ayrıca, /(\w{2})/gsadece olabilir /../g- girişin yalnızca harfler olduğunu zaten biliyoruz ve bir (veya iki) karakterin tekrarlanması daha kısa {2}. Eğer ilgileniyorsanız, bu soruna JavaScript cevabını inceleyebilir (ve soruları yorumlayabilirsiniz). PGCC'ye Hoşgeldiniz!
apsiller

4

Mathematica, 110 100 99 bayt

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

3

Perl, 86 84 83 bayt

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

Bu -pkomut satırı argümanı için 82 bayt artı 1'dir :

$ echo xyxyxyxyxyxyxyxyzyzyzyxzxzxz | perl -p 86.pl
y11z3


Biraz unungolfed:

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
  • güncelleme 84 grep'i çizerek 2 bayt kazanın
  • güncelleme 83${$'} Bunun yerine genel geçici değişkenleri kullanarak 1 baytı kaydedin $g{$'}. Ne yazık ki, $$'çalışmıyor.

3

Saf Bash, 151

Umduğumdan daha uzun, ama işte burada.

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

Gerekli sayımı yapmak için ilişkisel dizi indeksleme kullanır. Bash 4.0 veya daha üst sürümü gerektirir.


1

PHP 247 Karakterler

(AH)

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

Açıklaması

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

Bunu diğer cevaplara bakmaksızın yaptınız. Bu, henüz uğraştığım en zor kodlu golf. Tüm optimizasyonları memnuniyetle karşılıyorum.


0

R, 221 bayt

kod

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="")
  }
}

Burada iyileştirme için çok yer var.

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.