ดูเหมือนว่าจะมีความนิยมอย่างต่อเนื่องเกี่ยวกับผู้คนที่เรียนรู้รูปแบบแป้นพิมพ์ใหม่ ๆ อย่าง Dvorak หรือ Neo เพราะมันน่าจะทำให้พวกเขามีประสิทธิผลมากขึ้น ฉันยืนยันว่าการสลับรูปแบบแป้นพิมพ์เป็นความคิดที่ไม่ดีเพราะอาจใช้เวลาเป็นเดือนที่คุณจะได้รับความเร็วและเมื่อคุณมีความเร็วมากกว่าส่วนที่เหลืออีก 5% คุณจะเมาถ้าคุณจำเป็นต้องพิมพ์บนคอมพิวเตอร์ที่ไม่ใช่ เป็นของคุณเอง

นอกจากนี้ทุกคนยังลืมที่คอขวดที่แท้จริงในการสื่อสารที่ทันสมัยอยู่ - ปุ่มกดโทรศัพท์

นี่คือลักษณะของปุ่มกดโทรศัพท์โดยเฉลี่ยของคุณ:

ตัวอักษร 'r' เป็นตัวอักษรตัวที่สามบนปุ่ม 7; ดังนั้นหากคุณต้องการพิมพ์ตัวอักษร 'r' บนโทรศัพท์มือถือคุณจะต้องกดปุ่ม 7 สามครั้งสำหรับ 's' คุณจะต้องกด 4 ครั้งและสำหรับ 'a' คุณจะต้องกดปุ่ม 2 ครั้งเดียว

เมื่อพิจารณาถึงสิ่งนี้การวาง 'e' หลังจาก 'd' อาจเป็นการตัดสินใจที่ไม่ดี - 'e' เป็นตัวอักษรที่ใช้บ่อยที่สุดในตัวอักษรภาษาอังกฤษดังนั้นถ้าคุณติดป้ายกำกับปุ่ม 3 "EDF" แทน "DEF" คุณ จะประหยัดการกดแป้นได้ค่อนข้างมาก

ยิ่งไปกว่านั้นคุณอาจพบว่าการพิมพ์ตัวอักษร 2 ตัวที่ใช้ปุ่มเดียวกันนั้นเป็นเรื่องน่ารำคาญ - หากคุณต้องการเขียน "TU" คุณจะไม่สามารถกด 8 ครั้งสามครั้งได้เพราะจะส่งผลให้ 'V' ดังนั้นโดยปกติคุณจะเขียน 'T' จากนั้นกด Space แล้วกด Backspace แล้วเขียน 'U' ซึ่งเท่ากับ 5 กดปุ่มแทน 3

TL; DR

รับกฎทั้งสองนี้:

• พิมพ์ตัวอักษรด้วยการกดปุ่ม n ครั้งโดยที่ n คือตำแหน่งที่ตัวอักษรอยู่บนป้ายของปุ่ม
• การเขียนตัวอักษรสองตัวที่พิมพ์โดยใช้ปุ่มเดียวกันต้องกดปุ่มเพิ่มอีก 2 ปุ่ม

รูปแบบแป้นพิมพ์โทรศัพท์ที่ต้องใช้จำนวนปุ่มน้อยที่สุดคืออะไรคือข้อความที่ระบุ? คุณควรใช้ปุ่ม 2-9, 1 และ 0 เท่านั้นที่สงวนไว้สำหรับสัญลักษณ์พิเศษ

อินพุต

ข้อความที่คุณควรหารูปแบบที่ดีที่สุดสำหรับการจัดหาผ่าน stdin คุณไม่จำเป็นต้องจัดการกับสิ่งอื่นใดนอกจากตัวอักษรตัวเล็กและสามารถสันนิษฐานได้ว่าอินพุตนั้นประกอบด้วยสิ่งนั้นเท่านั้น คุณสามารถสันนิษฐานได้ว่าข้อความที่ป้อนมีขนาดใหญ่พอสมควรและตัวอักษรทุกตัวอยู่ในนั้นอย่างน้อยหนึ่งครั้งถ้ามี

เอาท์พุต

ฉันไม่ต้องการใส่ข้อ จำกัด มากเกินไปในผลลัพธ์เนื่องจากบางครั้งก็ให้ประโยชน์กับภาษาอื่นมากกว่า ดังนั้นภาษาของคุณแสดงอาร์เรย์ได้ดีหรือคุณสามารถแยกแต่ละป้ายกำกับด้วยการขึ้นบรรทัดใหม่

อาจมีเลย์เอาต์ที่เหมาะสมที่สุดหลายรูปแบบคุณสามารถพิมพ์รูปแบบใดรูปแบบหนึ่ง นี่คือตัวอย่างง่ายๆ:

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

คะแนนโบนัส

-35ถ้าอัลกอริทึมของคุณไม่ดุร้ายบังคับเลย์เอาต์ที่เป็นไปได้ทั้งหมด (ฉันกำลังดูที่ 'permutations' ของ Haskell ที่นี่)

-3หากรหัสของคุณพอดีกับข้อความ (140 ตัวอักษร) และคุณโพสต์รูปของคุณส่งรหัสของคุณให้เพื่อน

นี่เป็นความท้าทายครั้งแรกของฉันใน StackExchange ฉันยินดีที่จะได้ยินว่าคุณชอบหรือมีข้อเสนอแนะอื่น ๆ เกี่ยวกับมัน!

Perl, 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 หลังจากความคิดเห็นของฉันข้างต้นและแทนที่คำตอบที่คำนึงถึงกฎนั้น (เช่นการจัดอันดับคำถามที่สูง) ฉันคิดว่าฉันติดค้างที่นี่ ...

โซลูชันที่ไม่ปรับให้เหมาะสมสำหรับกฎ # 2 สามารถสร้างผลผลิตได้ไกลจากจุดที่เหมาะสมที่สุด ฉันตรวจสอบข้อความภาษาอังกฤษแบบยาวตามธรรมชาติ ("Alice in Wonderland" จริง ๆ ) ดำเนินการล่วงหน้า (ตัวอักษรตัวพิมพ์เล็กเท่านั้น) และเช่นสคริปต์ Perl จากคำตอบของ OJW ผลลัพธ์คือ

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) - 43 + 235 ต่อ 202 + 355 แต่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คู่ (The Cat เป็นหนึ่งในตัวละครหลังจากทั้งหมด) แต่ยังคงเป็นตัวอักษรที่เหมาะสมที่สุดสำหรับภาษาอังกฤษหากรหัสของฉันไม่ผิด ไม่ใช่ความพยายามในการ 'ตีกอล์ฟ' เพียงแค่วิธีการทำงานที่น่าเกลียดหรือไม่

Python3 ถึงเวลา Montecarlo!

เพื่อแก้ปัญหานี้ฉันต้องนับจำนวน "คลิก" ที่คุณต้องการด้วยแป้นพิมพ์เริ่มต้น ( abc,def,ghi,jkl,mno,pqrs,tuv,wxyzอย่างตั้งใจ:) จากนั้นฉันจะแก้ไขแป้นพิมพ์นี้และดูว่ามีราคาถูกกว่าหรือไม่ (ข้อความเขียนด้วยการคลิกน้อยกว่า) หากแป้นพิมพ์นี้ราคาถูกกว่าก็จะกลายเป็นค่าเริ่มต้น ฉันทำซ้ำขั้นตอน1Mนี้

ในการเปลี่ยนคีย์บอร์ดฉันต้องตัดสินใจก่อนว่าจะต้องทำการเปลี่ยนแปลงกี่ครั้ง (จำนวนการเปลี่ยนแปลงสูงสุดคือจำนวนตัวอักษรทั้งหมดและคีย์บอร์ด) จากนั้นสำหรับทุกสวิตช์ฉันเลือกปุ่มสองปุ่มและสองตำแหน่งและฉันถ่ายโอนอักขระจากตำแหน่งแรกไปยังตำแหน่งที่สอง

จำนวนสวิตช์สูงสุดต่อครั้งคือจำนวนตัวอักษรในแป้นพิมพ์เพราะมันเป็นจำนวนการเปลี่ยนแปลงขั้นต่ำที่คุณต้องเปลี่ยนจากแป้นพิมพ์ที่แตกต่างกันสองตัว (ฉันต้องการให้เป็นไปได้เสมอที่จะเปลี่ยนจากคีย์บอร์ดหนึ่งไปเป็นคีย์บอร์ดอื่น)

ผลลัพธ์ของ 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']

ดังนั้นฉันจึงอ้างว่าอันสุดท้ายนี้เป็นหนึ่งในปุ่มกดที่ใช้งานได้จริงที่สุด (ในแง่ของการคลิก)

ถ้าคุณต้องการตัวละครที่ได้รับความนิยมมากที่สุดที่กำหนดให้กับถังขยะ 2-9, Perl สามารถทำได้ใน 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";

Haskell, 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 แต่ใส่ตัวอักษรที่ใช้บ่อยที่สุดบนคีย์ที่แตกต่างกัน

JavaScript, 192 - 35 = 157

เพิ่งสังเกตเห็นกฎตัวละครซ้ำ; สิ่งนี้ไม่ได้คำนึงถึงสิ่งนั้น แต่อย่างที่ @mniip สังเกตเห็นในคำตอบของเขา:

บางคนอาจโต้แย้งว่าสิ่งนี้ไม่เหมาะสำหรับกฎ 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)

นี่น่าจะเป็นทับทิม แต่ฉันไม่ได้อยู่ที่บ้านและถูกบังคับให้ใช้ Internet Explorer (eww) แต่เฮ้บางครั้งมันก็สนุกกับการใช้ภาษาในการตีกอล์ฟกับกอล์ฟ ;)

ตัวอย่างผลลัพธ์ (สำหรับอินพุตของคุณ):

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

ตั้งแต่ JS ไม่มี STDIN sโปรแกรมอนุมานว่าการป้อนข้อมูลจะถูกเก็บไว้ในตัวแปร

Python (119-35 = 84):

สมมติว่าสตริงเป็นตัวแปร a และมีตัวอักษรตัวพิมพ์เล็กเท่านั้น:

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

ใช่เราสามารถดรอปนำเข้า enourmous ได้ สิ่งนี้จะถือว่าสตริงที่ปล้นอยู่ใน

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