Saisie de clavier de téléphone portable

17

Saisie de clavier de téléphone portable

Cette question a été posée il y a quelque temps, mais a été fermée en raison de mauvaises spécifications. Donc, je le refais, avec de meilleures spécifications. Cette question est liée, mais va dans le sens opposé.

Avant la création de T9, pour saisir un caractère dans un message texte, vous deviez appuyer plusieurs fois sur l'une des touches numériques pour obtenir le caractère souhaité. Pour référence, voici le mappage standard:

+-------+-------+-------+
|   1   |   2   |   3   |
|  .?!1 |  ABC2 |  DEF3 |
+-------+-------+-------+
|   4   |   5   |   6   |
|  GHI4 |  JKL5 |  MNO6 |
+-------+-------+-------+
|   7   |   8   |   9   |
| PQRS7 |  TUV8 | WXYZ9 |
+-------+-------+-------+
|   *   |   0   |   #   |
|   ←   |SPACE 0|   →   |
+-------+-------+-------+

*est le retour arrière, 0est un espace ( ' ') ou le nombre 0, et #confirme le caractère actuel. Par souci de simplicité, tous les caractères sont en majuscules.

Lorsque vous appuyez sur une fois sur la touche plusieurs, les cycles de caractères sélectionnés par les caractères possibles pour cette clé: 2 -> A, 22 -> B, 222 -> C, 2222 -> 2, 22222 -> A, et ainsi de suite. Notez que, comme il *n'y a qu'une seule option, une pression répétée sur celle-ci entraîne la saisie de plusieurs espaces arrière. Appuyer #plusieurs fois de suite n'a aucun effet. Un suivi #n'est pas nécessaire.

De plus, si une touche différente est enfoncée immédiatement après avoir appuyé sur une touche, la pression de touche précédente est automatiquement confirmée. Ainsi, 223est fonctionnellement identique à 22#3.

Votre défi consiste à traduire une série de touches sur la chaîne correspondante qu'un téléphone portable afficherait.

Exemples

8#99999#055#33#999#22#666#2#777#3#1 -> T9 KEYBOARD
4433555#55566609666666677755533*3111 -> HELLO WORLD!
7##222#222**7#222#4 -> PPCG
00#0#00 -> 0 0

Règles

  • C'est le code-golf , donc la solution correcte la plus courte (en octets) l'emporte
  • La réponse gagnante sera choisie dans une semaine
  • Les failles standard sont interdites
  • Votre réponse peut prendre la forme d'un programme complet, d'une fonction nommée ou d'une fonction anonyme, prenant des entrées et produisant des sorties selon l'une des méthodes standard

Classement

L'extrait de pile au bas de cet article génère le classement à partir des réponses a) comme une liste des solutions les plus courtes par langue et b) comme un classement général.

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

## Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

Afficher l'extrait de code

code-golf string keyboard Mego
la source
1
Comment produit-on des nombres? Vous avez le numéro '9' dans un exemple, mais votre spécification ( 2 -> A, 22 -> B..., 2222 -> A....) ne permet pas de produire des nombres.
C. Quilley
1
@ C.Quilley C'est ce que j'obtiens en copiant aveuglément ce diagramme, corrigé maintenant.
Mego
Étroitement apparenté, dupe possible .
Alex A.
1
@AlexA. Pas dupe, c'est une entrée de clavier numérique standard, pas une recherche de dictionnaire T9.
Mego

Réponses:

3

K5, 112 octets

{(20#'((" ";".?!"),((3*!6),19 22)_`c$65+!26),'$!10)[.*x]20!#1_x}'(){$[42=*y;(-#y)_x;35=*y;x;x,,y]}/{(&~0=':x)_x}

Celui-ci est vraiment un gâchis, mais je pense qu'il y a assez de place pour le jouer.

Nous devons d'abord construire une table de recherche pour le clavier. Il y a des clés avec 2, 4 et 5 caractères qui leur sont mappés, donc le remplissage de chaque entrée sur 20 simplifie le processus d'indexation cyclique de ce tableau plus tard:

  (20#'((" ";".?!"),((3*!6),19 22)_`c$65+!26),'$!10)
(" 0 0 0 0 0 0 0 0 0 0"
 ".?!1.?!1.?!1.?!1.?!1"
 "ABC2ABC2ABC2ABC2ABC2"
 "DEF3DEF3DEF3DEF3DEF3"
 "GHI4GHI4GHI4GHI4GHI4"
 "JKL5JKL5JKL5JKL5JKL5"
 "MNO6MNO6MNO6MNO6MNO6"
 "PQRS7PQRS7PQRS7PQRS7"
 "TUV8TUV8TUV8TUV8TUV8"
 "WXYZ9WXYZ9WXYZ9WXYZ9")

Ensuite, je divise l'entrée en séries:

 {(&~0=':x)_x}"8#99999#055#33#999"
(,"8"
 ,"#"
 "99999"
 ,"#"
 ,"0"
 "55"
 ,"#"
 "33"
 ,"#"
 "999")

Supprimez tous les # runs et supprimez les runs de fin à chaque fois que je rencontre un *:

  (){$[42=*y;(-#y)_x;35=*y;x;x,,y]}/{(&~0=':x)_x}"8#99999#055#33#999"
(,"8"
 "99999"
 ,"0"
 "55"
 "33"
 "999")

Et puis je suis prêt à simplement indexer dans cette table de recherche en fonction de la longueur et du premier élément de chaque exécution.

Tous ensemble:

  {(20#'((" ";".?!"),((3*!6),19 22)_`c$65+!26),'$!10)[.*x]20!#1_x}'(){$[42=*y;(-#y)_x;35=*y;x;x,,y]}/{(&~0=':x)_x}"4433555#55566609666666677755533*3111"
"HELLO WORLD!"

Éditer:

Économisez 5 octets:

0 3 6 9 12 15 19 22
((3*!6),19 22)
JohnE
la source
Vous pouvez raccourcir (20#'((" ";".?!"),0 3 6 9 12 15 19 22_`c$65+!26),'$!10)à (20#'((" ";".?!"),((3*!6),19 22)_`c$65+!26),'$!10).
kirbyfan64sos
Oui, je viens juste de le découvrir il y a quelques minutes.
JohnE
3

Python 2, 230 206 octets

import re
f=lambda a,b=dict(zip("0123456789*#"," 0~.?!1~ABC2~DEF3~GHI4~JKL5~MNO6~PQRS7~TUV8~WXYZ9~\b~".split("~"))):"".join([j and b[j][(len(i)-1)%len(b[j])]or b[i]for i,j in re.findall(r"((\d)\2*|.)",a)])

Celui-ci crée une fonction f qui prend comme argument une chaîne de touches et renvoie la chaîne correspondante qu'un téléphone portable afficherait. Il arrive également de prendre un deuxième argument facultatif comme clé de mappage de dictionnaire à leurs caractères correspondants, par exemple {"0": "0", "1": ".?! 1", ...} .

Tout d'abord, la chaîne de touches est regroupée en répétant des caractères, par exemple ["8", "#", "99999", "#", ...] . Ensuite, le premier caractère de chaque groupe est mappé dans le dictionnaire passé comme deuxième argument, par exemple 9 correspond à WXYZ9 . Enfin, la longueur du groupe est utilisée comme décalage dans la valeur du dictionnaire.

Notez que l'offset doit utiliser modulo sur la longueur du groupe de caractères répétitifs car les pressions sur les touches peuvent tourner. Notez également que le caractère # est mappé sur \ 0 et supprimé uniquement à la fin car 99 # 99 n'est pas le même que 9999 .

Voici la sortie de la fonction pour chacun des exemples de la question:

>>> print f("8#99999#055#33#999#22#666#2#777#3#1")
T9 KEYBOARD.
>>> print f("4433555#55566609666666677755533*3111")
HELLO WORLD!
>>> print f("7##222#222**7#222#4")
PPCG
>>> print f("00#0#00")
0 0
cr3
la source
3

JavaScript, 214 184 168 162 octets

x=>(x.match(/(.)\1*/g,f='').map(a=>f=(l=a.length,v=' 0#.?!1#ABC2#DEF3#GHI4#JKL5#MNO6#PQRS7#TUV8#WXYZ9'.split`#`[a[0]])?f+v[--l%v.length]:a<'*'?f:f.slice(0,-l)),f)

Cela peut probablement être un peu plus petit, mais je suis assez content du résultat. Fractionne les caractères en groupes répétés d'un ou plusieurs, puis parcourt le tableau, mappant chaque caractère à sa valeur dans le hachage et l'ajoutant à la chaîne finale. S'il rencontre un nombre quelconque de «#», il l'ignore. S'il rencontre un '*', il en supprime le nombre à la fin de la chaîne finale.

Mwr247
la source
0

Python 2, 237 octets

Utilisation du dictionnaire de cr3, mais sans re.

def f(i):
 d=dict(zip("0123456789"," 0|.?!1|ABC2|DEF3|GHI4|JKL5|MNO6|PQRS7|TUV8|WXYZ9".split("|")))
 s,x,j='',i[0],0
 for c in i[1:]+'#':
  if c==x:j+=1
  else:
   if x>'/':s+=d[x][j%len(d[x])]
   j=0
  if c=='*':s=s[:-1]
  x=c
 return s
TFeld
la source
-1

Python 2, 265 octets

C'est beaucoup trop long. IO: stdin, stdout.

a=reduce(lambda q,w:q+" "+[w,""][w=="#"]if q[-1]!=w else q+w,raw_input()).split()
while "*" in a:del a[a.index("*")-1:a.index("*")+1]
print"".join([(lambda a:a[len(q)%len(a)-1])(" 0:.?!1:ABC2:DEF3:GHI4:JKL5:MNO6:PQRS7:TUV8:WXYZ9".split(":")[int(q[0])])for q in a])
Hannes Karppila
la source
Le troisième exemple, 7 ## 222 # 222 ** 7 # 222 # 4 , fera que votre script lèvera un ValueError : littéral invalide pour int () avec la base 10: '*'.
cr3