Introducción

Últimamente, me he estado acostumbrando a escribir con Swype .

He notado que ciertas palabras se pueden producir dibujando una línea recta desde la letra inicial hasta la letra final, o saltando las letras que se repiten.

Por ejemplo, puedo escribir la palabra balloondeslizando las siguientes letras:

b> a> l> o> n.

Desafío

Definamos la ruta Swype más corta o SSP, como el número mínimo de segmentos de línea distinguibles necesarios para escribir una cadena. Un segmento de línea es una línea recta continua entre dos o más letras. Cualquier cambio en la dirección comienza un nuevo segmento de línea, aunque algunas palabras se pueden Swyping dibujando solo una línea recta.

Utilice este diseño de teclado QWERTY simple :

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

En el ejemplo anterior, la palabra balloontendrá un SSPde 4como se detalla en la secuencia a continuación:

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 cadena qwertytiene SSP= 1, ya que no se requiere ningún cambio de dirección al Swyping esta palabra.

Entrada

Una cadena de una sola palabra que contiene cualquier a-zvía STDIN, argumento de función o línea de comando.

Salida

Imprima a través de STDOUT, return o la alternativa más cercana a su idioma, el número que nrepresenta la cadena SSP.

Una nueva línea final opcional en salida. Lagunas estándar no permitidas. La presentación más corta en bytes gana.

Notas

• Un cambio de dirección inicia un nuevo segmento de línea.
• Las letras que se repiten solo se cuentan una vez (por ejemplo: bookkeeperdeben tratarse como bokeper).
• Normalmente, Swpye corrige las letras perdidas mirando las letras vecinas y completando su mejor conjetura. Para este desafío, suponga que no hay aumentos de lenguaje natural, texto predictivo o corrección de errores.
• Las A-Zentradas en mayúsculas se tratan como sus equivalentes en minúsculas.
• Ignora cualquier número 0-9en la entrada.
• Caminos diagonales se les permite - es decir, una línea recta que cubre letras o, k, n, por ejemplo, cuentan como 1segmento. Esta regla se aplica a cualquier pendiente diagonal (por ejemplo c, las letras h, iestán en línea).

Ejemplos

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`,

Tenga en cuenta que el código contiene caracteres no imprimibles.

Tomar prestada la inteligente idea de @ isaacg de usar RLE para contar las rutas guardadas 6 bytes.

Pruébelo en línea en el intérprete de CJam . Si el enlace no funciona, copie el código de esta pasta .

Cómo 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.

Pyth, 53 50 49 bytes

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

Formato de compresión del teclado gracias a @Dennis.

Esta respuesta contiene algunos caracteres no imprimibles. Consulte los enlaces a continuación para obtener el código correcto.

Demostración . Arnés de prueba.

Explicación:

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.