introduzione

Ultimamente mi sono abituato a scrivere con Swype .

Ho notato che alcune parole possono essere prodotte tracciando una linea retta dalla tua lettera iniziale alla lettera finale o saltando le lettere che si ripetono.

Ad esempio, posso digitare la parola balloonSwyping tra le seguenti lettere:

b> a> l> o> n.

Sfida

Definiamo il percorso swype più breve o SSP, come il numero minimo di segmenti di linea distinguibili necessari per digitare una stringa. Un segmento di linea è una linea retta continua tra due o più lettere. Qualsiasi cambio di direzione avvia un nuovo segmento di linea, sebbene alcune parole possano essere scambiate disegnando una sola linea retta.

Usa questo semplice layout di tastiera QWERTY :

q w e r t y u i o p
a s d f g h j k l
  z x c v b n m

Nell'esempio sopra, la parola balloonavrà un SSPof 4come dettagliato nella sequenza seguente:

1) Start at `b` (line segments = 0)
2) slide to `a` (line segments = 1)
3) slide to `l` (line segments = 2)
4) slide to `o` (line segments = 3)
5) slide to `n` (line segments = 4)

La stringa qwertyha SSP= 1 poiché non è richiesto alcun cambio di direzione quando si scambia questa parola.

Ingresso

Una stringa di singola parola contenente qualsiasi a-ztramite STDIN, argomento della funzione o riga di comando.

Produzione

Stampa tramite STDOUT, return o l'alternativa più vicina alla tua lingua, il numero che nrappresenta la stringa SSP.

Una nuova riga finale facoltativa in uscita. Scappatoie standard non consentite. Vince l'invio più breve in byte.

Appunti

• Un cambio di direzione avvia un nuovo segmento di linea.
• Le lettere che si ripetono vengono contate una sola volta (ad esempio: bookkeeperdevono essere trattate come bokeper).
• Normalmente, Swpye corregge le lettere perse osservando le lettere vicine e compilando la sua ipotesi migliore. Per questa sfida, supponiamo che non ci siano aumenti del linguaggio naturale, testo predittivo o correzione degli errori.
• Gli A-Zinput maiuscoli sono trattati come le loro controparti minuscole.
• Ignora qualsiasi numero 0-9nell'input.
• Percorsi diagonali sono consentiti - che è, una linea retta che copre le lettere o, k, n, per esempio, contano come 1segmento. Questa regola vale per qualsiasi pendenza diagonale (es: lettere c, h, isono in linea).

Esempi

Input          Output
---------------------
a                0
aa               0
aaaaaa           0
aaaaaabc         2
in               1
int              2
java             3
qwerty           1
chicago          5
balloon          4
BALLOON          4
typewriter       5
bookkeeper       6
stackexchange    11
2hello7          3
2HELLO7          3

CJam, 78 76 73 68 62 byte

relA,s-:_2ew{:-},{{i"x8LÑejPG ÀÏi"225b28b=A+Ab}/.-:ma}%e`,

Si noti che il codice contiene caratteri non stampabili.

Prendendo in prestito l'idea intelligente di @ isaacg di usare RLE per contare i percorsi salvati 6 byte.

Provalo online nell'interprete CJam . Se il collegamento non funziona, copia il codice da questo incolla .

Come funziona

rel      e# Read a token from STDIN and cast it to lowercase.
A,s-     e# Remove all digits.
:_       e# Duplicate each element of the argument (string/array).
2ew      e# Push all overlapping slices of length 2.
{:-},    e# Filter out slices where both elements are equal.
{        e# For each slice:
  {      e#   For each character of the slice:
    i    e#     Push its code point.

    "x8LÑejPG ÀÏi"225b28b

         e#     Convert the string from base 225 to base 28, pushing the array
         e#     [15 7 16 17 18 27 26 8 9 0 3 11 4 6 24 1 22 5 21 10 25 23 12 2 13 14].
         e#     These are the positions on the QWERTY keyboard, starting from the
         e#     upper left corner and going right.

    =    e#     Select the element that corresponds to the code point.

         e#     Arrays wrap around in CJam. Since 'a' has code point 97, the array has
         e#     length 26 and 97 % 26 == 19, 'a' corresponds to the 20th element.

    A+Ab e#     Add 10 and convert to base 10. Example: 8 -> [1 8]
  }/     e#
  .-     e#     Vectorized subtraction. [a b] [c d] -> [a-c b-d]
  :ma    e#     atan2. Pushes the angle of the direction. [y x] -> arctan(y/x)
}%       e#
e`       e# Apply run-length encoding.
,        e# Count the runs.

Pyth, 53 50 49 byte

lrPMfT-VJm.jF.D@jC"XÖ;¿ìÇ×;¤ð$  _"28CdT@GrzZtJ8

Formato di compressione della tastiera grazie a @Dennis.

Questa risposta contiene alcuni caratteri non stampabili. Vedi i link sottostanti per il codice corretto.

Dimostrazione . Collaudare l'imbragatura.

Spiegazione:

lrPMfT-VJm.jF.D@jC"..."28CdT@GrzZtJ8
                              rzZ      Convert input to lowercase.
                            @G         Take the intersection with G.
                                       This removes the numbers.
         m                             Map over the characters
                 C"..."                Treat the string as a base 256 number.
                j      28              Convert this number to base 28, giving:
                                       [15, 7, 16, 17, 18, 27, 26,  ... ]
                                       which is the character positions 
                                       from top left, rotated by 97 places.
               @         Cd            Index this list by ord(character)
             .D            T           divmod by 10, giving the x-y position.
          .jF                          Convert this to a complex number.
        J                              Save the result to J.
      -VJ                        tJ    Vectorize - over J and J[1:]. This gives
                                       pairwise diffeences between J's elements.
    fT                                 Filter the differences on being truthy.
                                       This removes letter pairs with no movement.
  PM                                   Map the remaining complex numbers to their
                                       phases, which indicates their directions.
 r                                 8   Run-length encode the result.
l                                      Print out the number of separate RLE groups.