시리얼 투표 감지


51

Stack Exchange는 자동으로 직렬 투표를 감지하여 (한 사용자가 다른 사용자의 많은 게시물을 공감하거나 공감할 때) 투표 합니다. 이 과제에서는 매우 간단한 "직렬 투표"검출기를 구현하게됩니다.

입력

입력은 투표 목록을 나타내는 문자열입니다. 두 문자로 구성된 모든 그룹은 투표를 나타냅니다. 첫 번째는 유권자이고 두 번째는 투표중인 사용자입니다. 예를 들어, 다음 입력

ababbccd

로 분석 할 수있다 ab ab bc cd,와 나타냅니다 a에 투표 b, 두 번 b에 투표 c한 번, 그리고 c에 투표 d한 번.

입력은 소문자로만 구성되며 항상 짝수> 0이됩니다. 또한 자신에게 투표 할 수 없습니다 (아니오 aa또는 hh).

산출

이 도전의 목적으로, 직렬 투표 는 다른 사용자에게 3 회 이상 주어진 특정 사용자 투표로 정의됩니다.

결과는 각 사용자에 대해 몇 개의 투표를 취소해야하는지 (즉, 각 사용자 대해 투표 한 횟수가 아니라 몇 명의 투표 가 취소되었는지) 형식으로 표시됩니다 [user][votes][user2][votes2].... 예를 들면, 입력 abababab( a표결 b네 번)를 출력한다 b4(표는 네에서 반전되고 ab).

출력은 원하는 순서대로 수행 할 수 있지만 입력 및 출력은 모두 위에서 설명한대로 단일 문자열이어야합니다.

테스트 사례

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

16
nanananananananabatman테스트 케이스의 경우 +1
9

답변:


6

Pyth, 22 바이트

pM_srSsfttTtMM.gkcz2 8

온라인으로 사용해보십시오 : 데모 또는 테스트 스위트

설명:

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

예:

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

읽을 수 없음 , 1830 1796 1791 1771 1762 1745 1736 1727 1626 1606 1577 바이트

출력은 알파벳 역순 ( z~ a)이지만 허용되는 규칙에 따릅니다.

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

설명

첫째, Unread가 할 수있는 일에 대한 인상을 얻으려면 기본 작업이 있습니다.

  • 임의 크기의 정수 셀의 무한 테이프가 있습니다.
  • Brainfuck과 같은 메모리 포인터 가 없습니다 . 대신 테이프에서 셀의 위치를 ​​기준으로 셀을 역 참조합니다. 이는 "값 4 번 읽기"또는 "값 # (읽기 값 # 4)"(이중 역 참조)를 읽을 수 있음을 의미합니다.
  • 메모리 셀만 읽거나 쓸 수 있습니다 (Brainfuck에서와 같이 직접 증가 / 감소하지는 않음).
  • 식 내에서 값을 늘리거나 줄일 수 있습니다. 따라서 메모리 셀을 증가 시키 려면 read , incremental , write 또는 다르게 넣어야 write(x, inc(read(x)))합니다.
  • 0과 0이 아닌 것을 확인할 수있는 while 루프와 3 진 조건이 있습니다.

이 프로그램은 다음과 같이 테이프를 사용합니다. 변수 이름은 나중에 의사 코드에서 사용됩니다. 또한 이것은 첫 번째 버전 (1830 바이트)을 기록합니다. 이후 변경된 사항은 하단의 수정 사항을 참조하십시오.

  • 셀 0 : 변수q
  • 셀 1 : 변수 a, p,ch
  • 셀 2 : 변수 hash,v
  • 셀 3 : 변수 b,r
  • 셀 4 : 변수 aa,l
  • 셀 5 : 10 진수 문자열의 "끝"을 표시하기 위해 0으로 유지
  • 셀 6–95 : 10 진수 문자열을 거꾸로 저장
  • 셀 96–121 : 사용자 a(96)에서 z(121) (문자의 ASCII 코드에서 1을 뺀 것) 에서 공제 될 투표 수를 저장합니다 .
  • Cells 4657–7380 : 몇 번의 유권자 / 부자 조합이 발생했는지 기억하십시오. 이 셀에는 4 가지 가능한 값만 있습니다. 0= 아직 표시되지 않음, -1= 한 번 표시, -2= 두 번 표시, -3= 2보다 큰 횟수

알고리즘은 기본적으로 다음과 같이 진행됩니다.

  • 문자의 쌍 계속 읽기 ab. (a-2)*(a-1)+b-1문자 a–z의 모든 조합에 대해 고유 한 해시 값을 계산하십시오 .
  • 해당 해시 값 ( *hash) 에서 메모리 셀을 확인하십시오 . 의 경우 -3사용자는 이미 투표 제거 자격이 있으므로 증가 *(b-1)합니다. 그렇지 않으면을 줄이십시오 *hash. 가 있다면 지금 -3 , 사용자는 단지했다 세 발생 후 투표 제거를위한 자격, 이렇게 증가 *(b-1)에 의해 3.
  • 그런 다음 문자를 역순으로 진행하여 ( z~ a) 투표가 필요한 항목을 출력합니다. 숫자를 10 진수로 변환하려면 수동 정수를 10으로 나누어야합니다.

모든 것이 명확 해지면, 이것은 프로그램이 의사 코드처럼 보이는 것입니다.

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

편집 1, 1830 → 1796 : while 루프의 반환 값을 한 곳에서 재사용 할 수 있다는 것을 깨달았습니다.

편집 2, 1796 → 1791 : 6–95 셀을 사용하는 대신 10 진수를 음수 셀 (-1 이상)에 저장하면 프로그램이 약간 작습니다. 추가 보너스로, 프로그램은 더 이상 10⁹⁰ 투표로 제한되지 않습니다!

편집 3, 1791 → 1771 : 에 결과를 할당하는 대신 결과를 *(ch = l + 95)v할당 q한 다음 v = q코드를 1777 바이트로 가져 와서 while 조건으로 이동합니다 . 다음의 위치를 교환 q하고 v있기 때문에 테이프에 q이제 1보다 더 일반적이다 v.

4, 1771 → 1762 편집 : Duh. hash0 대신 1로 초기화 하면 9 바이트가 짧습니다. 해시 코드는 이제 1 개 이상으로 중요하지 않습니다.

편집 5, 1745 → 1762 : 내가 초기화하는 경우 qr1 대신 0으로, 좀 뿌려해야 할 -1바로 그것을 만들 장소에서들, 그리고 모든 상쇄 할 것 - 것을 제외하고 while v { --v; [...] }루프가 이제 한 적은 반복을 실행해야, while --v { [...] }26 자 더 짧은 이라고 말하면 됩니다.

6, 1745 → 1736 편집 : 대신을 { r = 1; ++q }쓸 수 있습니다 q = *((r = 1)+1)+1. 이것은 q가변 슬롯 # 2에 있다는 사실에 의존합니다 . 슬롯 # 1에 있으면 더 짧아 지지만 전체 프로그램은 더 길어집니다.

편집 7, 1745 → 1727 : 편집 6을 되돌리고 대신 가장 안쪽 while 루프를 숫자 ASCII 코드를 계산하는 표현식에 인라인하여 1736 바이트로 끝나지만 감소 명령 (9 바이트)을 저장함으로써 절약을 달성했습니다. ) 변화시킴으로써 ((++r) - 11) ? r :(r - 10) ? ++r :.

편집 8, 1727 → 1626 : 해시 계산을 재 작업했습니다. 이제 하나의 적은 while 루프를 사용합니다. 셀 위치는 이제 실제 ASCII 코드에 있습니다 (더 이상 1이 아닌). 변수가 다른 빈도로 발생하므로 테이프의 다른 위치로 변수를 다시 섞습니다.

편집 9, 1626 → 1606 : 더 미친 인라인. 첫 번째 while 루프의 본문은 이제 다음과 같습니다.

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

변수 할당이 거의 완전히 변경되었습니다.

10 → 1577 (1606) 편집 : 나는 그것을 관찰 a하고 a2내가 쌍을 수 있다면, 그래서 모두 루프 동안 0으로 감소되어 p그 중 하나로,하지만, 하지ch, 나는 초기화 할 필요가 없습니다 것 p0(29 바이트의 요금으로한다). 나는 교환하여 해당 작업을 수행 할 수 있습니다 밝혀 pr. 최신 변수 어설 션 (및 코드에서 발생 빈도)은 다음과 같습니다.

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
노하우로 보는 novemvigintillion의 투표는 2 * 10 ^ 90 바이트의 문자열 및 요구 10 ^ 24 바이트의 현재 가능한 가장 작은 볼륨에서 대략 기자의 대 피라미드의 크기 1/3 , 나는 당신이 생각하지 않는다 걱정할 것. ;)
ETHproductions

1
@ETHproductions : 그럼에도 불구하고, 프로그램을 골프를 타면서 나는 그 한계를 고치기 위해 일어났다 :)
Timwi

22

CJam, 23 바이트

길이 파티!

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

또는

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

모든 테스트 사례를 실행

설명

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.

아니라 a) 각 문자열의 첫 번째 문자를 선택 : 다른 버전이 다른 2 바이트를 저장하는 쌍을 역전시킴으로써 시작 :c대신 Wf=제를 선택. b) 우리는 두 번째 RLE 이전에 다시 정렬 할 필요가 없습니다. 왜냐하면 쌍은 이미 나머지 캐릭터에 의해 이미 정렬 되었기 때문입니다.


FWIW는 Q두 번째 대답해야 q비 테스트 래퍼 목적.
피터 테일러

@PeterTaylor 나는 그렇게 항상 -.-
Martin Ender

나는 그것이 사소한 세부 사항이라는 것을 알고 있지만 3비교를 위해 목록으로 변환하는 것은 좋은 요령입니다. 나는 내 자신의 오락을 위해 그것을 해결하고 내가 사용했기 때문에 바이트를 잃어 버렸습니다 0=2>. 그렇지 않으면 마지막 단계 ::\ 대신 사용 하는 것을 제외하고 첫 번째 솔루션과 거의 동일하게 끝났습니다 Wf%.
Reto Koradi

10

배쉬, 95 94 85 81 바이트

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

우아하고 오래되었지만 첫 번째 솔루션은 ...

감사합니다 User112638726 와 바이트 저장하기위한 sed9 저장을위한 DigitalTrauma을, fold그리고 라이너 P. 4 개를 저장할 awksubstr!

작동 방식을 확인하려면 input을 가져갑니다 abababcbcbcbcbbababa.

  • fold -2(라인을 너비 2로 줄인 후 )

    ab
    ab
    cb
    cb
    cb
    cb
    ba
    ba
    ba
    
  • 이후 sort | uniq -c( 각 라인이 입력에 나타나는 횟수를 출력 -c하는 매우 멋진 플래그 uniq입니다)

          3 ab
          3 ba
          4 cb
    
  • 이제 마지막 awk명령을 살펴 봅시다 :

    • $1>2: 레코드 1 (일명 동일한 투표 수)이 2보다 큰 경우 (즉, 3 이상) 만 출력합니다. 다시 말해, 숫자 ≤ 2로 시작하는 행은 무시하십시오.

    • {c[substr($2,2)]+=$1}: 숫자가 2보다 큰 경우 c레코드 2의 두 번째 문자 (일명 투표자)를 키로 사용하여 해당 숫자를 해시 테이블에 추가하십시오 . (우리는 모든 것을 0으로 초기화 할 필요가 없습니다 awk. 우리를 위해 그렇게합니다.)

    • END{...}: "전체 파일을 처리 한 후 다음에 수행 할 작업"입니다.

    • for(x in c)printf x c[x]: 상당히 자명하다. 모든 키와 해당 값을 인쇄하십시오.


&에 equivelant되어 \0나오지에
User112638726

@ User112638726는 감사를 알고하지 않았나요
손잡이

조금 sed -r 's/.(.)/\1\n/g'|awk '{a[$1]++}END{for(i in a)printf (a[i]>2)?i a[i]:y}
줄였습니다

bacada예를 들어 @ User112638726 입력에 실패합니다 .
Doorknob

그래 내 나쁜!
112638726

8

자바 스크립트, 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]');

테스트 사례 :

높은 수준에서이 코드는 투표 수신자를 투표 수에 매핑 { b:7, a:3 }한 다음 for루프 의 문자열로 결합하는 키-값 쌍으로 객체를 채 웁니다 . 코드는 및에 바이트를 소비하지 않고 화살표 함수 내 eval에서 사용할 수 있도록 하는 표현식 입니다.for{ };return r

( 3 바이트 저장 을 위해 user81655 로 진행합니다!)

eval코드 설명 :

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

하스켈, 103 바이트

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)

사용 예 : f "jkkjjkkjjkkjljljljmlmlnmnmnm"->"k3j6m3"

작동 방식 :

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

자바 스크립트 (ES6) 195 174 169 167 158 바이트

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

테스트


1
PPCG에 오신 것을 환영합니다 : 우리는 JS에서 골프에 대한 몇 가지 팁이 여기여기를 . 나는 정말로 나 자신을 도울만큼 충분히 JS를 모르지만, 행복한 골프 :)
FryAmTheEggman

1
우선, vars를 제거 할 수 있습니다 . 코드 골프에서 세계적인 범위를 오염시키는 데 누가 관심이 있습니까? ;)
Doorknob

또한, /(\w{2})/g단지 수 있습니다 /../g우리는 이미 입력이 문자 만 알고, 하나 (또는 2) 문자를 반복하는 것은보다 짧은 - {2}. 관심이 있으시면이 과제에 대한 JavaScript 답변을 살펴보고 질문에 답변 할 수 있습니다. PGCC에 오신 것을 환영합니다!
apillers

4

매쓰, 110 (100) 99 바이트

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

3

펄, 86 84 83 바이트

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

-p명령 행 인수 의 경우 82 바이트 + 1입니다 .

$ 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
  • 84 업데이트 위한 grep을 인라인으로 저장 2 바이트를
  • 83${$'} 대신 글로벌 임시 변수 를 사용하여 1 바이트를 저장하십시오 $g{$'}. 불행히도 $$'작동하지 않습니다.

3

순수한 배쉬, 151

내가 기대했던 것보다 길지만 여기 있습니다.

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

연관 배열 인덱싱을 사용하여 필요한 계산을 수행합니다. bash 버전 4.0 이상이 필요합니다.


1

PHP 247 자

(아야)

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

설명

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

다른 답변을 엿 보지 않고 이것을 했습니까? 이것은 내가 아직 다루었던 가장 어려운 코드 골프입니다. 모든 최적화를 환영합니다.


0

R, 221 바이트

암호

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

언 골프

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

여기에는 개선의 여지가 많이 있습니다.

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.