Zagadka:

Rozważ grę konsolową / ręczną z padem kierunkowym, w której musisz podać nazwę. Pojawiało się to w wielu starszych grach, zanim użycie QWERTY zostało spopularyzowane w konsolach (np. Wierzę, że Wii używa układu klawiatury QWERTY do wprowadzania danych). Zazwyczaj klawiatura ekranowa wygląda na *:

Domyślna:

0 1 2 3 4 5 6 7 8 9
A B C D E F G H I J
K L M N O P Q R S T
U V W X Y Z _ + ^ =

Po zmianie obudowy:

0 1 2 3 4 5 6 7 8 9
a b c d e f g h i j
k l m n o p q r s t
u v w x y z - + ^ =

Oznacza to, że wszystkie klawisze alfanumeryczne i następujące:

_: Pojedyncza spacja
-: Łącznik
+:
^Zmień wielkość liter tylko na następną literę : Przełącz blokadę wielkich liter (to znaczy, zmieniaj wielkość liter wszystkich liter)
=: Wprowadź, zakończ

* Oczywiście klucze takie jak „BKSP” i „ENTER” zastąpiłem krótszymi wersjami

A następnie sprzęt obejmowałyby D-pad (lub jakąś formę kontroli, gdzie można pójść up, down, lefti right)

Ekran zazwyczaj pozwala także na przechodzenie z jednej strony bezpośrednio na drugą. Oznacza to, że jeśli skupiłeś się na liście J, naciśnięcie rightumożliwi przejście do litery A.

Ilekroć wpisałem swoje imię, zawsze starałem się znaleźć najszybszy sposób, aby to zrobić.

Cel:

Twój program pobierze ciąg znaków, który może zawierać dowolny znak alfanumeryczny, w tym spację i łącznik, a Twoim celem jest wygenerowanie jak najmniejszej liczby naciśnięć klawiszy na klawiaturze kierunkowej, aby uzyskać wymagany ciąg znaków.

Uwagi:

Nie trzeba dołączać klawisza do naciśnięcia rzeczywistego znaku.
Fokus zawsze zaczyna się na A
Enter, =należy nacisnąć na końcu

Przykład:

input: Code Golf
output: 43

Wyjaśnienie:
A -> C= 2
C-> ^= 6 (przejście w lewo)
^-> o= 5
o-> d= 2
d-> e= 1
e-> += 5
+-> _= 1
_-> += 1
+-> G= 3
G-> o= 3
o-> l= 3
l-> f= 5
f-> == 6

Zauważ, że szybciej jest trafić +dwa razy dla a _i Gniż trafić ^raz, a następnie zamienić z powrotem.

Zwycięskie zgłoszenie (pozwolę co najmniej 1 w) będzie najkrótszym rozwiązaniem (w bajtach). Ponieważ jest to moje pierwsze pytanie, mam nadzieję, że jest to jasne i niezbyt trudne.

Rubinowy (369 bajtów)

Pobiera dane z wiersza poleceń.

K="0123456789"+('A'..'Z').to_a.join+" +^="
Q=K.downcase.sub' ','-'
def d x,y
t,s=(x/10-y/10).abs,(x%10-y%10).abs
[t,4-t].min+[s,10-s].min
end
def v s,i,l,a
return l if s.empty?
c,r=s[0],s[1..-1]
j=K.index(c.upcase)||36
return v(r,j,l+d(i,j),a)if a.include?c
s,p=d(i,37)+d(37,j),d(i,38)+d(38,j)
[v(r,j,l+s,a),v(r,j,l+p,a==K ? Q : K)].min
end
puts v("#{ARGV[0]}=",10,0,K)

Zaoszczędziłem sporo bajtów dzięki @Charlie :)

Swift 1.2, 812 588 670 bajtów

Edycja: Usunięto 224 bajty, zastępując duże tablice liczb zakresem i przekształcając je w tablicę.

Edycja2: Dodano pętlę w pionie

typealias S=String
typealias I=Int
var A:(I)->S={S(UnicodeScalar($0))},B:(I)->(I,I)={a in(a%10,a/10)},a=Array(48...57).map{A($0)},b=[a+(Array(65...90)+[32,43,94,61]).map{A($0)},a+(Array(97...122)+[45,43,94,61]).map{A($0)}],z=Process.arguments
z.removeAtIndex(0)
func C(e:I,f:I)->I{let(a,b)=B(e),(c,d)=B(f)
return min(abs(d-b), abs(4-(d-b)))+min(abs(c-a),abs(10-(c-a)))}
func D(c:S,_ e:I=10,_ f:Bool=false,_ g:Bool=false)->I{if count(c)==0{return C(e,39)}
let h=c.startIndex,i=c.endIndex,j=S(c[h])
if let k=find(b[f ?1:0],j){return C(e,k)+D(c[advance(h,1)..<i],k,(g ?(!f):f),false)}else{return min(C(e,37)+D(c,37,!f,true),C(e,38)+D(c,38,!f,false))}}
print(D(" ".join(z)))

Aby uruchomić, umieść kod w .swiftpliku i uruchom go za pomocąswift <filename> <your name>

Wykorzystuje to proste podejście, w którym dwie „klawiatury” są przechowywane jako tablice.

B:(I)->(I,I)={a in(a%10,a/10)} Konwertuje indeks z tablicy na pozycję x, y na wirtualnej klawiaturze.

func C(e:I,f:I)->I{let(a,b)=B(e),(c,d)=B(f) return abs(d-b)+min(abs(c-a),abs(10-(c-a)))} Pobiera indeks początkowy / końcowy i zwraca minimalną liczbę ruchów do przejścia od jednego do drugiego (uwzględniając zawijanie w poziomie)

func D(c:S,_ e:I=10,_ f:Bool=false,_ g:Bool=false)->IJest główną funkcją rekurencyjną, która wykonuje większość obliczeń. To oblicza odległość od aktualnej pozycji do charakteru docelowego, chyba że sprawa powinna się zmienić, a następnie oblicza zarówno na zmianę i to caps lock metod i zajmuje najmniejszy.

Uruchamianie swift codegolf.swift Code Golfwydruków43

Python 679 661 619 602 589 576 539 520 496 482 Bajtów

Uruchom to, a poprosi o wprowadzenie danych (bez tekstu zachęty). Dla wejścia Code Golfdrukuje się 43.

a=input()+'=';b=0;c="0123456789abcdefghijklmnopqrstuvwxyz-+^=";d=0;e=[0,1];f='+';g='^';h=[i.isupper()or i==' 'for i in a];i=abs;p=lambda z:all([i==b for i in z]);q=0
def l(z):global s;k=c.index(z.lower().replace(' ','-'));s=[k%10,int(k/10)];m,n=s;return sum([min(i(m-e[0]),i(10-(m-e[0]))),min(i(n-e[1]),i(4-(n-e[1])))])
def o(z):global d,e;d+=l(z);e=s
for r in a:
 if p(h[q:q+3]):o(g);b^=1
 if p(h[q:q+2]):
  if l(f)<l(g):o(f)
  else:o(g);b^=1
 if p([h[q]]):o(f)
 o(r);q+=1
print(d)

Pełny program:

input = input() + '='
capsOn = False

keys = "0123456789abcdefghijklmnopqrstuvwxyz-+^="
totalKeys = 0
caret = [0, 1]

shiftKey = '+'
capsKey = '^'

cases = [char.isupper() or char == ' ' for char in input]

def locate(char):
    """
        Find the location of the char on the keyboard
        regardless of case
    """
    location = keys.find(char.replace(' ', '-').lower())
    return [location % 10, int(location / 10)]


def dist(key):
    """
        Calculate the min dist to a char
    """
    nx, ny = locate(key)
    return sum([min(abs(nx - caret[0]), abs(10 - (nx - caret[0]))), min(abs(ny - caret[1]), abs(4 - (ny - caret[1])))])


def moveTo(char):
    """
        Move the caret to the char, ignoring case and
        adds the dist to the tally
    """
    global totalKeys, caret
    totalKeys = totalKeys + dist(char)

    print(keys[caret[0] + caret[1] * 10], '->', char, '=', dist(char))

    caret = locate(char)

diffCase = lambda case: all([i == capsOn for i in case])

for ind, ch in enumerate(input):
    if diffCase(cases[ind:ind + 3]): # use caps
        moveTo(capsKey)
        capsOn ^= 1
    elif diffCase(cases[ind:ind + 2]): # use closest
        if dist(shiftKey) < dist(capsKey):
            moveTo(shiftKey)
        else:
            moveTo(capsKey)
            capsOn ^= 1
    elif diffCase([cases[ind]]): # use shift
        moveTo(shiftKey)

    moveTo(ch) # apply the move

print('Total:', totalKeys)

Rozszerzone wyjście z pełnego programu:

Code Golf
a -> C = 2
c -> ^ = 6
^ -> o = 5
o -> d = 2
d -> e = 1
e -> + = 5
+ -> _ = 1
- -> + = 1
+ -> G = 3
g -> o = 3
o -> l = 3
l -> f = 5
f -> = = 6
Total: 43

Zapisano bajt dzięki @justin https://codegolf.stackexchange.com/a/18983/42736
4 @xnor https://codegolf.stackexchange.com/a/40791/42736 19 dzięki @Alex

C 675 bajtów

Pobiera dane wejściowe z argumentu wiersza poleceń. Używa rekurencyjnej głównej:

#define Y(_) (!isdigit(_)?!isalpha(_)?3:1+(toupper(_)-65)/10:0)
#define X(_) (!isdigit(_)?!isalpha(_)?_-32&&_-45?_-43?9-(_==94):7:6:(toupper(_)-5)%10:_-48)
x,y,z;char*s;main(a,_,p,q,r){a<2?s[_]?!isdigit(s[_])&&((s[_]-32&&!isupper(s[_]))||!a)&&((s[_]-45&&!islower(s[_]))||a)?q=x,r=y,main(3,43),p=z,x=X(43),y=Y(43),main(3,s[_]),p+=z,x=X(s[_]),y=Y(s[_]),main(a,_+1),p+=z,x=q,y=r,main(3,94),q=z,x=X(94),y=Y(94),main(3,s[_]),q+=z,x=X(s[_]),y=Y(s[_]),main(!a,_+1),q+=z,z=(q<p?q:p):(main(3,s[_]),q=z,x=X(s[_]),y=Y(s[_]),main(a,_+1),z+=q):(main(3,61)):(a<3?s=((char**)_)[1],x=0,y=1,main(1,0),printf("%d",z):(x=X(_)-x,y=Y(_)-y,x+=10*(x<0),y+=4*(y<0),z=(x>5?10-x:x)+(y>2?4-y:y)));}