Introdução

Ultimamente, estou me acostumando a digitar com o Swype .

Notei que certas palavras podem ser produzidas desenhando uma linha reta da sua letra inicial até a letra final ou pulando as letras que se repetem.

Por exemplo, eu posso digitar a palavra balloonpassando rapidamente pelas seguintes letras:

b> a> l> o> n.

Desafio

Vamos definir o caminho mais curto do Swype ou SSP, como o número mínimo de segmentos de linha distinguíveis necessários para digitar uma sequência. Um segmento de linha é uma linha reta contínua entre duas ou mais letras. Qualquer mudança de direção inicia um novo segmento de linha - embora algumas palavras possam ser Swyped desenhando apenas uma única linha reta.

Use este layout de teclado QWERTY simples :

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

No exemplo acima, a palavra balloonterá um SSPdos 4detalhes na sequência abaixo:

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)

A cadeia qwertytem SSP= 1, pois nenhuma mudança de direção é necessária ao digitar esta palavra.

Entrada

Uma cadeia de palavras única contendo qualquer a-zvia STDIN, argumento de função ou linha de comando.

Resultado

Imprima por STDOUT, retorne ou pelo seu idioma a alternativa mais próxima, o número que nrepresenta a string SSP.

Uma nova linha à direita opcional no outut. Lacunas padrão não permitidas. O menor envio em bytes vence.

Notas

• Uma mudança de direção inicia um novo segmento de linha.
• As cartas que se repetem são contadas apenas uma vez (por exemplo: bookkeeperdevem ser tratadas como bokeper).
• Normalmente, o Swpye corrige as letras perdidas observando as letras vizinhas e preenchendo sua melhor estimativa. Para esse desafio, suponha que não haja aprimoramentos de linguagem natural, texto preditivo ou correção de erros.
• As A-Zentradas em maiúsculas são tratadas como suas contrapartes em minúsculas.
• Ignore quaisquer números 0-9na entrada.
• Caminhos diagonais são permitidos - isto é, uma linha recta que cobre letras o, k, n, por exemplo, contam como 1segmento. Esta regra aplica-se a qualquer inclinação diagonal (por exemplo: cartas c, h, iestão em linha).

Exemplos

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 bytes

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

Observe que o código contém caracteres não imprimíveis.

Emprestando a idéia inteligente de @ isaacg de usar o RLE para contar os caminhos salvos em 6 bytes.

Experimente on-line no intérprete CJam . Se o link não funcionar, copie o código desta pasta .

Como funciona

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.

Pitão, 53 50 49 bytes

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

Formato de compactação do teclado graças a @Dennis.

Esta resposta contém alguns caracteres não imprimíveis. Veja os links abaixo para o código correto.

Demonstração . Equipamento de teste.

Explicação:

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.