टेलीफोन कीपैड का अनुकूलन

Question

ऐसा लगता है कि लोगों में इसको लेकर दीवानगी बढ़ रही है, जो ड्वोरक या नियो जैसे नए कीबोर्ड लेआउट सीख रहे हैं क्योंकि यह माना जाता है कि यह उन्हें अधिक उत्पादक बनाता है। मेरा तर्क है कि कीबोर्ड लेआउट को बदलना एक बुरा विचार है, क्योंकि इसे गति प्राप्त करने में आपको महीनों लग सकते हैं, और जब आप बाकी की तुलना में 5% अधिक तेज होते हैं, तो आपको एक कंप्यूटर पर टाइप करने की आवश्यकता होती है, जो कि isn है 'अपना नहीं।

इसके अलावा, ये सभी लोग भूल जाते हैं कि आधुनिक संचार में असली अड़चन कहाँ है - टेलीफोन कीपैड।

इस तरह आपका औसत टेलीफोन कीपैड दिखता है:

पत्र 'आर ’बटन 7 पर तीसरा अक्षर है; इसलिए यदि आप मोबाइल फोन पर 'r' अक्षर टाइप करते हैं, तो आप 7 बार बटन दबाएंगे, 's' के लिए आप इसे 4 बार दबाएंगे, और 'a' के लिए आप बटन एक बार दबाएंगे।

इसे ध्यान में रखते हुए, 'डी' के बाद 'ई' डालना शायद एक बुरा निर्णय था - अंग्रेजी वर्णमाला में 'ई' सबसे अधिक इस्तेमाल किया जाने वाला पत्र है, इसलिए, यदि आप "डीईएफ" के बजाय बटन 3 "ईडीएफ" को लेबल करते हैं, तो आप काफी कीस्ट्रोक्स को बचाएगा।

इसके अलावा, आप शायद खुद को अनुभव करते हैं कि एक ही बटन को साझा करने वाले 2 अक्षर टाइप करना एक उपद्रव है - यदि आप "टीयू" लिखना चाहते हैं, तो आप सिर्फ 8 तीन बार नहीं मार सकते, क्योंकि इससे 'वी' का परिणाम होगा। इसलिए आमतौर पर आप 'टी' लिखेंगे, फिर स्पेस मारा जाएगा, फिर बैकस्पेस मारा जाएगा, और फिर 'यू' लिखा जाएगा, जो 3 के बजाय 5 बटन प्रेस के बराबर है।

---

टी एल; डॉ

इन दो नियमों को देखते हुए:

• एक अक्षर n बार बटन दबाकर टाइप किया जाता है, जहां n बटन की लेबल पर अक्षर की स्थिति कहां है
• एक ही बटन का उपयोग करके टाइप किए गए दो अक्षरों को लिखने के लिए अतिरिक्त 2 बटन प्रेस की आवश्यकता होती है

टेलीफोन कीबोर्ड लेआउट क्या है जिसे एक विशिष्ट पाठ के लिए कम से कम बटन प्रेस की आवश्यकता होती है? आपको केवल बटन का उपयोग करना चाहिए 2-9, 1 और 0 विशेष प्रतीकों के लिए आरक्षित हैं।

इनपुट

जिस पाठ के लिए आपको इष्टतम लेआउट ढूंढना चाहिए वह स्टड के माध्यम से दिया गया है। आपको लोअरकेस वर्णमाला के अलावा कुछ भी संभालने की आवश्यकता नहीं है और यह मान सकते हैं कि इनपुट में केवल वही शामिल है। आप यह भी मान सकते हैं कि इनपुट टेक्स्ट यथोचित रूप से बड़ा है और प्रत्येक अक्षर कम से कम एक बार, यदि वह मदद करता है, तो वहाँ है।

उत्पादन

मैं आउटपुट पर बहुत सारी अड़चनें नहीं डालना चाहता, क्योंकि कभी-कभी कुछ भाषाओं को दूसरों पर लाभ मिलता है; हालाँकि, आपकी भाषा से पता चलता है कि सरणियाँ ठीक हैं, वैकल्पिक रूप से आप प्रत्येक लेबल को एक नई पंक्ति के साथ अलग कर सकते हैं।

कई संभावित इष्टतम लेआउट हो सकते हैं, आप उनमें से किसी एक को प्रिंट कर सकते हैं। यहाँ एक सरल उदाहरण दिया गया है:

>> echo "jackdawslovemybigsphinxofquartz" | foo.sh
ojpt
avhz
cen
skm
dyf
wbq
ixu
lgr

बोनस अंक

-35 यदि आपका एल्गोरिथ्म सभी संभावित लेआउट के लिए बाध्य नहीं कर रहा है (मैं यहां हास्केल के `क्रमपरिवर्तन 'को देख रहा हूं)

-3 यदि आपका कोड एक टेक्स्ट संदेश (140 वर्ण) के अंदर फिट बैठता है और आप अपना एक कोड अपने दोस्त को भेजते हैं, तो आप उसका एक चित्र पोस्ट करते हैं।

यह StackExchange पर मेरी पहली चुनौती है। मुझे यह सुनकर खुशी होगी कि आपको यह पसंद है, या इसके बारे में कोई अन्य प्रतिक्रिया है!

Comments

CodeGolf.SE पर आपका स्वागत है! मुझे आपके प्रश्न में कोई समस्या नहीं दिख रही है, लेकिन आम तौर पर सैंडबॉक्स में अपनी चुनौती को पोस्ट करने के लिए सबसे अच्छा विचार है कि कुछ प्रतिक्रिया प्राप्त करें और मुख्य साइट पर पोस्ट करने से पहले अस्पष्टता को हटा दें।

— मार्टिन एंडर

आह, यह अच्छा है, मैं निश्चित रूप से भविष्य में करूंगा।

— फ्लोंक

मेरा टेलीफोन एक एकल 60-वर्ण एसएमएस भेज सकता है, लेकिन सही ढंग से कोष्ठक का समर्थन नहीं करता है, क्या मैं बोनस से बाहर हूं?

— ----

अच्छा प्रश्न! मुझे नहीं लगता कि -35 बोनस से कोई भी बच पाएगा । यहां तक ​​कि अगर हम खुद को दो में से चार अक्षरों वाले लेआउट्स तक सीमित रखते हैं और शेष सभी 6 में से 4 पर, 26! / (2! * 6!) = 280,063,514,671,253,913,600,000 > 2^77अद्वितीय क्रमपरिवर्तन हैं, तो केवल एक बार कुंजी की सरल व्यवस्थाओं को गिनना।

— डेनिस

इसके अलावा, मैं पूछता हूं कि क्या आप लोग आपके समाधान के बटन दबाने की संख्या को प्रिंट कर सकते हैं। तो हम देखेंगे कि किसने सबसे अच्छा पाया!

— एंटोनियो रागागिनिन

Answer 1

पर्ल, 333

$_=<>;$c{$&}++while/./g;@c=sort{$c{$b}<=>$c{$a}}keys%c;$d{$&.$1}++while/.(?=(.))/g;sub f{my$x=shift;if(my$c=pop@$x){for(grep!$_[$_],0..7){my@y = @_;$y[$_]=$c;f([@$x],@y)}}else{for(0..7){$z=$_[$_];$c+=$d{$z.$_}+$d{$_.$z}for@{$a[$_]}}$c<$m?($m=$c,@n=@_):1}}while(@c){$m= ~0;f[splice@c,0,8];push@{$a[$_]},$n[$_]for 0..7}print@$_,$/for@a

यहां नियम # 2 के लिए अनुकूलन करने का प्रयास किया गया है। मेरी टिप्पणी के बाद, ऊपर, और उस नियम को ध्यान में रखते हुए उत्तर देने के बदले (cf. उच्च प्रश्न की रेटिंग), मैंने सोचा कि मैं यहाँ कुछ प्रयास देने वाला हूँ ...

नियम # 2 के लिए अनुकूलन करने वाले समाधान इष्टतम से बहुत दूर उत्पादन का उत्पादन कर सकते हैं। मैंने लंबे प्राकृतिक अंग्रेजी पाठ ("एलिस इन वंडरलैंड"), वास्तव में), पूर्व-संसाधित (केवल कम अक्षर पत्र) की जांच की, और उदाहरण के लिए ओजेडब्ल्यू के उत्तर से पर्ल स्क्रिप्ट, परिणाम

2: ermx
3: tdfz
4: alp
5: oub
6: ick
7: nwv
8: hgj
9: syq

er अकेले इसे बर्बाद कर देता है, साथ ही कुछ अन्य जोड़े को एक ही कुंजी पर समाप्त नहीं होना चाहिए ...

Btw, zxqjvkbpfmygwculdrshnioateउस पाठ से क्रमबद्ध, आवृत्ति आरोही हैं।

अगर हम इसे आसान तरीके से हल करने की कोशिश करते हैं (-35 बोनस के लिए, हो सकता है) और अक्षरों को एक-एक करके रखें, न्यूनतम जोड़ी-वार गिनती द्वारा उपलब्ध कुंजी का चयन करते हुए, हम उदाहरण के साथ समाप्त कर सकते हैं:

slbx
hdmz
nrf
iuj
ogv
awk
tcp
eyq

मैं इस (गलत) समाधान के लिए कोड यहाँ पोस्ट नहीं करता। जैसे, ध्यान दें, पहले cसे अधिक लगातार है wऔर पहले रखा गया है। tc( ct) जोड़े स्पष्ट रूप से लगातार कम हैं ac( ca) - ४३ + २३५ के खिलाफ २०२ + ३५५। लेकिन फिर wसमाप्त होता है a- 598 + 88। हम जोड़े awऔर tc(964 कुल) के साथ समाप्त होते हैं , हालांकि यह बेहतर होगा acऔर tw(635 कुल)। आदि..

इसलिए, अगला एल्गोरिथम प्रत्येक 8 शेष (या 2, यदि अंतिम) की जाँच करता है, तो कीपैड पर पहले से मौजूद अक्षरों के खिलाफ सबसे अधिक अक्षर, और उन्हें रखने के लिए ताकि जोड़ी-वार गिनती न्यूनतम हो।

$_=<>;                          # Read STDIN.
$c{$&}++while/./g;              # Count letters (%c hash).
@c=sort{$c{$b}<=>$c{$a}}keys%c; # Sort them by frequency, ascending
$d{$&.$1}++while/.(?=(.))/g;    # (@c array), and count pairs (%d hash).

                                # Next is recursive sub that does the job.
                                # Some CPAN module for permutations
                                # would probably do better...
                                # Arguments are reference to array of what's 
                                # left un-placed of current 8-pack of letters,
sub f{                          # and 8 element list of placed letters
    my$x=shift;                 # (or undefs).
    if(my$c=pop@$x){            # Pop a letter from 8-pack (if anything left),
        for(grep!$_[$_],0..7){  # try placing it on each available key, and 
            my@y = @_;          # call sub again passing updated arguments.
            $y[$_]=$c;
            f([@$x],@y)
        }
    }else{                      # If, OTOH, 8-pack is exhausted, find sum of
        for(0..7){              # pairs count of current permutation (@_) and 
            $z=$_[$_];          # letters placed in previous rounds (8-packs).
                                # @a is "array of arrays" - note, we didn't 
                                # have to initialize it. First "8-pack" will
                                # be placed on empty keypad "automatically".
                                # We re-use undefined (i.e. 0) $c.

            $c+=$d{$z.$_}+$d{$_.$z}for@{$a[$_]}
        }
        $c<$m                   # Is sum for current placement minimal?
            ?($m=$c,@n=@_)      # Then remember this minimum and placement.
            :1
    }
}

while(@c){
    $m= ~0;                         # Initialize "minimum" with large enough 
    f[splice@c,0,8];                # number, then call sub with each 8-pack
                                    # (and empty list of placed letters 
                                    # from current round). On return,
                                    # @n will have optimal arrangement.
    push@{$a[$_]},$n[$_]for 0..7    # Then place it permanently on keypad.
}
print@$_,$/for@a                    # Show us what you've done.

परिणाम है:

sdfz
hlmx
nrv
iyp
ogk
acq
twb
euj

मुझे यह acजोड़ी पसंद नहीं है (कैट सभी के बाद एक पात्र है), लेकिन, फिर भी यह अंग्रेजी के लिए इष्टतम अक्षर प्लेसमेंट है, अगर मेरा कोड गलत नहीं है। बिल्कुल 'गोल्फिंग' प्रयास नहीं, बस कुछ काम कर रहे समाधान, बदसूरत या नहीं।

Answer 2

पायथन 3, यह मोंटेकार्लो टाइम है!

इस समस्या को हल करने के लिए, मैं सबसे पहले आपको डिफ़ॉल्ट कीबोर्ड के साथ कितने "क्लिक" की जरूरत है (पूर्णतः:) abc,def,ghi,jkl,mno,pqrs,tuv,wxyz। फिर मैं इस कीबोर्ड को संशोधित करता हूं और देखता हूं कि क्या यह सस्ता है (पाठ कम क्लिक में लिखा गया है)। यदि यह कीबोर्ड सस्ता है, तो यह डिफ़ॉल्ट एक हो जाता है। मैं इस प्रक्रिया को पुनरावृत्त करता हूं 1M।

कीबोर्ड को बदलने के लिए मैं सबसे पहले यह तय करता हूं कि कितने बदलाव करने हैं (कीबोर्ड की अधिकतम संख्या अक्षरों की कुल संख्या n है)। फिर, हर स्विच के लिए, मैं दो बटन और दो पदों का चयन करता हूं और मैं एक चरित्र को पहली स्थिति से दूसरे एक में स्थानांतरित करता हूं।

समय के अनुसार स्विच की अधिकतम संख्या कीबोर्ड में अक्षरों की संख्या है। यह दो पूर्ण भिन्न कीबोर्ड से स्विच करने के लिए आवश्यक परिवर्तनों की न्यूनतम संख्या है। (मैं चाहता हूं कि एक कीबोर्ड से किसी दूसरे पर स्विच करना हमेशा संभव हो)

का आउटपुट echo "jackdawslovemybigsphinxofquartz" | python .\myscript.pyहै:

61 ['anb', 'sef', 'hjc', 'iykl', 'odm', 'qgr', 'tuxv', 'wpz']

61दिए गए संदेश को लिखने के लिए बटन की संख्या को कहां दबाया गया है।

वर्ण (कोई रिक्त स्थान और कोई टिप्पणी नहीं): 577

मुझे इसकी लंबी अवधि का पता है लेकिन मैं वास्तव में इस सामान के लिए नया हूं।

from random import *
S=['abc','def','ghi','jkl','mno','pqrs','tuv','wxyz']
def P(L): # perform a switch of the keys of the keyboard:to switch from a given keyboard to another, the maximum number of exchanges is the number of the keys.
    R=randint
    N = len(''.join(L))
    W = randint(1,N)   # decide how many switches to perform
    EL = list(L)
    for i in range(0,W):
        B1=R(0,len(EL)-1)   # decide what buttons are considered in the switch
        B2=R(0,len(EL)-1)
        if len(EL[B1])==0: continue   
        P1=R(0,len(EL[B1])-1)       # decide what letter to switch and where
        if len(EL[B2])==0: P2=0
        else:   P2=R(0,len(EL[B2])-1)
        C1 = EL[B1][P1]     
        EL[B1]=EL[B1].replace(C1,'')
        EL[B2]=EL[B2][:P2]+C1+EL[B2][P2:]
    return EL
def U(L,X): # count how many clicks you need to compose the text X
    S=0
    Z=' '
    for A in X:
        for T in L:
            if A in T and Z not in T: S+=1+T.index(A)
            if A in T and Z in T: S+=3+T.index(A) # if the last character was in the same button..here the penality!
        Z=A
    return S
X=input()
n_iter=10**6
L = list(S)
cc=U(L,X)
print(cc,L)
for i in range(0,n_iter): #do some montecarlo stuff
    cc=U(L,X)
    pl=P(L)
    pc=U(pl,X)
    if(cc>pc):
        L=pl 
        print(pc,L)

---

मुझे यह बहुत मज़ेदार लगा कि मैंने इस एल्गोरिथम को LO HOBBIT के साथ आज़माने का फैसला किया (मेरे पास घर पर एक मूल प्रति है)!)। इसमें 383964अक्षर हैं और ये दो क्लिक बनाम कीपैड हैं जो मुझे मिल रहे हैं:

909007 ['abc', 'def', 'ghi', 'jkl', 'mno', 'pqrs', 'tuv', 'wxyz']
879344 ['abkc', 'def', 'gqhi', 'jl', 'mno', 'rs', 'tupv', 'wxyz']
861867 ['abg', 'def', 'qhyi', 'jcl', 'mno', 'r', 'tupxv', 'swkz']
851364 ['abg', 'e', 'qchi', 'jyl', 'mn', 'dr', 'tupxv', 'sowkfz']
829451 ['ag', 'ef', 'qchi', 'jyl', 'mn', 'dbr', 'tupxv', 'sowkz']
815213 ['amg', 'ef', 'qch', 'ojyl', 'i', 'dbnr', 'tupxv', 'swkz']
805521 ['amg', 'ef', 'ch', 'ojyl', 'qi', 'dbnr', 'tupxv', 'swkz']
773046 ['amg', 'ef', 'ch', 'ojyl', 'qi', 'bnr', 'tupxv', 'dswkz']
759208 ['amg', 'eqf', 'ch', 'ojyl', 'i', 'bnr', 'tupxv', 'dswkz']
746711 ['ag', 'ekq', 'clh', 'sojy', 'bi', 'nmfr', 'tupxv', 'dwz']
743541 ['ag', 'ekq', 'clh', 'sojy', 'bi', 'nmfr', 'tpxv', 'dwuz']
743389 ['ag', 'ekq', 'clh', 'sojy', 'i', 'nmfr', 'tpxbv', 'dwuz']
734431 ['ag', 'ekq', 'lh', 'sjy', 'ci', 'nrf', 'tpxbv', 'dowumz']
705730 ['ag', 'oekq', 'lh', 'sjy', 'ci', 'nrf', 'tpxbv', 'dwumz']
691669 ['ag', 'oekq', 'lh', 'nsjy', 'ic', 'rf', 'tpxbv', 'dwumz']
665866 ['ag', 'hokq', 'el', 'nsjy', 'ic', 'rbf', 'tpxv', 'dwumz']
661610 ['agm', 'hokq', 'e', 'nsj', 'ilc', 'rbf', 'tpyxv', 'dwuz']

इसलिए मेरा दावा है कि यह अंतिम सबसे व्यावहारिक कीपैड में से एक है (क्लिक के संदर्भ में)।

Comments

आपको कैसे पता चलेगा कि यह इष्टतम है?

— PyRulez

मोंटेकार्लो इस तरह से काम नहीं करता है। यह केवल आपको इष्टतम समाधान के करीब और निकटता देता है। लेकिन कहते हैं, अगर 1 मिलियन में कोशिश करता है कि आपका समाधान नहीं बदलता है..तो आप शायद इष्टतम का उपयोग कर रहे हैं। (या आप इस "स्थानीय न्यूनतम" से बहुत आगे नहीं बढ़ रहे हैं)

— एंटोनियो रागैगिन

इसलिए चुनौतियों के लिए, हमें केवल तब काम करने की जरूरत है?

— PyRulez

@PyRulez मैंने महसूस किया कि यह एक इष्टतम समाधान खोजने के लिए एक आसान समस्या नहीं होगी (इसके अलावा यदि आप सभी संभव समाधानों की कोशिश करते हैं, जिसे मैं -35 बोनस के साथ रोकने की उम्मीद कर रहा था), तो मैं वास्तव में इस दृष्टिकोण को खोदता हूं।

— फ्लोंक

दिलचस्प विधि, लेकिन शायद यह कार्य इसके डोमेन के बिल्कुल नहीं है। मैंने जाँच की, और, 'ऐलिस' के लिए, डिफ़ॉल्ट कीबोर्ड के लिए 291613 क्लिक की आवश्यकता है। मेरे कार्यक्रम के साथ अनुकूलित - 195597. 'मोंटे कार्लो' दृष्टिकोण के साथ, मुझे 5 मिलियन से अधिक पुनरावृत्तियों में 207000 से कम क्लिक नहीं मिले। और, अक्षरों को स्वैप करना बेहतर है, यानी 2x4 + 6x3 लेआउट शेष है।

— user2846289

Answer 3

ठीक है अगर आप बस सबसे लोकप्रिय पात्रों को 2-9 के लिए सौंपा चाहते हैं, तो पर्ल 127 वर्णों में ऐसा कर सकता है ...

foreach(split /\s*/,<>){$x{$_}++}
foreach(sort{$x{$b}<=>$x{$a}}keys %x){$o{$n++%8}.=$_}
for(0..7){printf "%d: %s\n",$_+2,$o{$_}}

कुछ दे रहा है जैसे:

echo "jackdawslovemybigsphinxofquartz" | perl ./keypad.pl
2: ajeb
3: iynz
4: suv
5: ohm
6: wkl
7: rgp
8: xfc
9: dtq

या 12 वर्णों को हटाते हुए, इसे एक पंक्ति में प्रिंट करें:

foreach(split /\s*/,<>){$x{$_}++}
foreach(sort{$x{$b}<=>$x{$a}}keys %x){$o[$n++%8].=$_}
print join",",values@o,"\n";

Comments

आप इसे आसानी से 100 वर्णों तक ट्रिम कर सकते हैं:$x{$_}++for split/\s*/,<>;map$o{$n++%8}.=$_,sort{$x{$b}<=>$x{$a}}keys%x;print map"$_:".$o{$_-2},2..9

— ardnew

Answer 4

हास्केल, 160 - 35 = 125

import Data.List
import GHC.Exts
main=interact f where f s=show$transpose$map($sortWith(\x->length$filter(/=x)s)['a'..'z'])[t,t.d,t.d.d,d.d.d];t=take 8;d=drop 8

उदाहरण:

$ runhaskell % <<< "jackdaws loves my big sphinx of quartz"
["afpy","sgqz","ihr","ojt","bku","clv","dmw","enx"]
$ </usr/share/dict/propernames tr A-Z a-z | runhaskell % 
["atjx","edgq","rhb","nmp","iyv","lcf","ouw","skz"]

कोई यह तर्क दे सकता है कि यह नियम 2 के लिए अनुकूलन नहीं करता है, लेकिन यह विभिन्न कुंजियों पर सबसे अधिक बार पत्र डालता है ।

Answer 5

जावास्क्रिप्ट, 192 - 35 = 157

सिर्फ दोहराए जाने वाले वर्णों पर ध्यान दिया जाता है; यह ध्यान में नहीं लेता है। लेकिन @ मनिनीप ने अपने जवाब में कहा:

कोई यह तर्क दे सकता है कि यह नियम 2 के लिए अनुकूलन नहीं करता है, लेकिन यह विभिन्न कुंजियों पर सबसे अधिक बार पत्र डालता है ।

o={}
a=[]
b=['','','','','','','','']
i=-1
s.split('').forEach(function(x){o[x]=o[x]?o[x]+1:1})
for(x in o)a.push([o[x],x])
a.sort().reverse().forEach(function(x){b[i=(i+1)%8]+=x[1]})
alert(b)

यह शायद रूबी में होता, लेकिन मैं घर पर नहीं हूं और मुझे इंटरनेट एक्सप्लोरर (eww) का उपयोग करने के लिए मजबूर किया जा रहा है। लेकिन हे, यह कभी-कभी गोल्फ के लिए गोल्फ में भयानक भाषाओं का उपयोग करके मज़ेदार होता है! ;)

नमूना आउटपुट (आपके इनपुट के लिए):

avlc,sukb,otj,irh,zqg,ypf,xne,wmd

चूंकि JS के पास कोई STDIN नहीं है, इसलिए प्रोग्राम मानता है कि इनपुट वेरिएबल में संग्रहित है s।

Comments

क्या आप इसे ध्यान में रखते हुए अनुकूलन कर रहे हैं: "एक ही बटन का उपयोग करके टाइप किए गए दो अक्षर लिखने के लिए अतिरिक्त 2 बटन प्रेस की आवश्यकता होती है"

— डिजिटल ट्रामा

अंतिम संपादित करें मुझे लगता है कि इसके लिए आउटपुट 'abcdefghia'बिल्कुल इष्टतम नहीं है।

— user2846289

@VadimR "तुम भी मान सकते हैं कि इनपुट पाठ यथोचित बड़ी है और हर पत्र है में कम से कम एक बार"

— दरवाज़े

मुझे पता है। 'azbcdefghizjklmnopqzrstuvwxyz'

— user2846289

आप b=['','','','','','','','']टू b=[x='',x,x,x,x,x,x,x], s.split('')टू s.split(x)और o[x]=o[x]?o[x]+1:1टू को ऑप्टिमाइज़ कर सकते हैं o[x]=-~o[x]।

— टूथब्रश

Answer 6

पायथन (119-35 = 84):

मान लें कि स्ट्रिंग एक चर है, और केवल लोअरकेस अक्षर हैं:

for h in range(8): print h+2,zip(*sorted([(__import__("collections").Counter(a)[d],d) for d in set(a)])[::-1])[1][h::8]

ungolfed:

import collections

#a="jackdawslovemybigsphinxofquartz"
a=__import__("string").lowercase

b=collections.Counter(a)

c=set(a)

d=[(b[d],d) for d in c]

e=sorted(d)

f=e[::-1]

g=zip(*f)[1]

for h in range(8): print h+2,g[h::8]

PYG (76-35 = 41):

आआहह, हम बहुत से आयात को छोड़ सकते हैं। फिर, यह मान लिया गया है कि स्ट्राइप्ड स्ट्रिंग एक में है।

for h in R(8): print h+2,Z(*S([(CC(a)[d],d) for d in Se(a)])[::-1])[1][h::8]