introduction

Dernièrement, je m'habitue à taper avec Swype .

J'ai remarqué que certains mots peuvent être produits en traçant une ligne droite de votre lettre de départ à votre lettre de fin, ou en sautant les lettres qui se répètent.

Par exemple, je peux taper le mot balloonpar Swyping dans les lettres suivantes:

b> a> l> o> n.

Défi

Définissons le chemin Swype le plus court , ou SSP, comme le nombre minimum de segments de ligne reconnaissables nécessaires pour taper une chaîne. Un segment de ligne est une ligne droite continue entre deux lettres ou plus. Tout changement de direction démarre un nouveau segment de ligne - bien que certains mots puissent être balayés en ne dessinant qu'une seule ligne droite.

Utilisez cette disposition de clavier 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

Dans l'exemple ci - dessus, le mot balloonaura un SSPde 4tel que décrit dans la séquence ci - dessous:

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 chaîne qwertya SSP= 1 car aucun changement de direction n'est requis lors du Swyping de ce mot.

Contribution

Une chaîne de mot unique contenant tout a-zvia STDIN, argument de fonction ou ligne de commande.

Production

Imprimez via STDOUT, return ou l'alternative la plus proche de votre langue, le nombre nreprésentant la chaîne SSP.

Un saut de ligne en option en sortie. Failles standard interdites. La soumission la plus courte en octets gagne.

Remarques

• Un changement de direction démarre un nouveau segment de ligne.
• Les lettres qui se répètent ne sont comptées qu'une seule fois (par exemple: bookkeeperdoivent être traitées comme bokeper).
• Normalement, Swpye corrige les lettres manquées en regardant les lettres voisines et en remplissant sa meilleure estimation. Pour ce défi, supposez qu'il n'y a pas d'augmentation du langage naturel, de texte prédictif ou de correction d'erreur.
• Les A-Zentrées en majuscules sont traitées comme leurs homologues en minuscules.
• Ignorez les nombres 0-9dans l'entrée.
• Chemins en diagonale sont autorisés - qui est, une ligne droite qui couvre les lettres o, k, npar exemple, comptent comme 1segment. Cette règle s'applique à toute pente diagonale (par exemple: lettres c, h, isont en ligne).

Exemples

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 octets

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

Notez que le code contient des caractères non imprimables.

Emprunter l'idée intelligente de @ isaacg d'utiliser RLE pour compter les chemins enregistrés 6 octets.

Essayez-le en ligne dans l' interpréteur CJam . Si le lien ne fonctionne pas, copiez le code de cette pâte .

Comment ça fonctionne

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 octets

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

Format de compression du clavier grâce à @Dennis.

Cette réponse contient des caractères non imprimables. Voir les liens ci-dessous pour le code correct.

Démonstration . Harnais de test.

Explication:

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.