सेल फोन कीबोर्ड टाइपिंग

17

सेल फोन कीबोर्ड टाइपिंग

यह सवाल कुछ समय पहले पूछा गया था, लेकिन खराब ऐनक के कारण बंद कर दिया गया था। इसलिए, मैं इसे बेहतर स्पेक्स के साथ फिर से तैयार कर रहा हूं। यह प्रश्न संबंधित है, लेकिन विपरीत दिशा में जाता है।

T9 के आसपास आने से पहले, एक टेक्स्ट मैसेज में एक कैरेक्टर टाइप करने के लिए, आपको उस कैरेक्टर को पाने के लिए कई बार एक नंबर की प्रेस करनी होती थी, जो आप चाहते थे। संदर्भ के लिए, यहां मानक मानचित्रण है:

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

*बैकस्पेस है, 0एक स्पेस ( ' ') या संख्या है 0, और #वर्तमान चरित्र की पुष्टि करता है। सादगी के लिए, सभी वर्ण अपरकेस हैं।

आपको लगता है कि कुंजी के लिए संभव पात्रों के माध्यम से एक प्रमुख कई बार, चयनित चरित्र चक्र दबाया जब: 2 -> A,22 -> B , 222 -> C, 2222 -> 2, 22222 -> A, और इतने पर। ध्यान दें, चूंकि *केवल एक ही विकल्प है, इसे बार-बार दबाने से कई बैकस्पेस में प्रवेश किया जा सकता है। #एक पंक्ति में कई बार दबाने से कोई प्रभाव नहीं पड़ता है। एक अनुगामी #अनावश्यक है।

इसके अतिरिक्त, यदि किसी कुंजी को दबाने के तुरंत बाद एक अलग कुंजी दबाया जाता है, तो पिछला कुंजी स्वचालित रूप से पुष्टि की जाती है। इस प्रकार, 223कार्यात्मक रूप से समान है 22#3।

एक सेल फोन प्रदर्शित करेगा इसी तार में keypresses की एक श्रृंखला का अनुवाद करने के लिए अपनी चुनौती है।

उदाहरण

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

नियम

  • यह कोड-गोल्फ है , इसलिए सबसे छोटा सही समाधान (बाइट्स में) जीतता है
  • जीतने वाला जवाब एक सप्ताह में चुना जाएगा
  • मानक खामियों को मना किया जाता है
  • आपका जवाब एक पूर्ण कार्यक्रम, एक नामित फ़ंक्शन, या एक अनाम फ़ंक्शन के रूप में हो सकता है, मानक तरीकों में से एक में इनपुट और उत्पादन आउटपुट लेना

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) a) प्रति भाषा सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

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

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

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

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

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

कोड स्निपेट दिखाएं

code-golf  string  keyboard 
— मै जाऊं
स्रोत
1
आप संख्याओं का उत्पादन कैसे करते हैं? आपके पास एक उदाहरण में संख्या '9' है, लेकिन आपका विनिर्देश ( 2 -> A, 22 -> B..., 2222 -> A....) किसी भी संख्या को उत्पन्न करने की अनुमति नहीं देता है।
— सी। कुली
1
@ C.Quilley मैं अब उस आरेख को आँख बंद करके कॉपी करने के लिए प्राप्त करता हूं, जो अब तय किया गया है।
— Mego
— एलेक्स ए।
1
@AlexA। डुप्लिकेट नहीं, यह मानक फोन नंबरपैड इनपुट है, न कि टी 9 डिक्शनरी लुकअप।
— मेगो

जवाबों:

3

K5, 112 बाइट्स

{(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}

यह वास्तव में एक गड़बड़ है, लेकिन मुझे लगता है कि इसमें नीचे जाने के लिए उचित मात्रा में कमरे हैं।

पहले हमें कीमैप के लिए लुकअप टेबल बनाने की जरूरत है। उनके लिए मैप किए गए 2, 4 और 5 अक्षरों के साथ चाबियाँ हैं, इसलिए 20 तक हर प्रविष्टि को पैडिंग करना इस तालिका में बाद में साइक्लिक रूप से अनुक्रमण की प्रक्रिया को सरल करता है:

  (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")

फिर मैंने इनपुट को रन में विभाजित किया:

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

किसी भी # रन और स्ट्रिप ट्रेलिंग ड्रॉप हर बार मैं एक * मुठभेड़:

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

और फिर मैं प्रत्येक रन की लंबाई और पहले तत्व के आधार पर उस लुकअप टेबल में बस इंडेक्स करने के लिए तैयार हूं।

सभी एक साथ:

  {(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!"

संपादित करें:

5 बाइट्स सहेजें:

0 3 6 9 12 15 19 22
((3*!6),19 22)
— JohnE
स्रोत
आप छोटा कर सकते हैं (20#'((" ";".?!"),0 3 6 9 12 15 19 22_`c$65+!26),'$!10)करने के लिए (20#'((" ";".?!"),((3*!6),19 22)_`c$65+!26),'$!10)।
— kirbyfan64sos
हाँ, मैंने वास्तव में कुछ मिनट पहले ही पाया था।
— जॉन
3

पायथन 2, 230 206 बाइट्स

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)])

यह एक फ़ंक्शन f बनाता है जो तर्क के रूप में keypresses की एक स्ट्रिंग लेता है और उसी स्ट्रिंग को वापस करता है जो एक सेल फोन प्रदर्शित करेगा। यह एक वैकल्पिक दूसरा तर्क लेने के लिए भी होता है जैसे कि उनके संबंधित वर्णों के लिए शब्दकोश मैपिंग कुंजी, उदाहरण के लिए {"0": "0", "1": "?! 1!" ...}। ।

सबसे पहले, keypresses की स्ट्रिंग को वर्णों को दोहराकर वर्गीकृत किया जाता है, उदाहरण के लिए ["8", "#", "99999", "#", ...] । फिर, प्रत्येक समूह के पहले चरित्र को दूसरे तर्क के रूप में पारित शब्दकोश में मैप किया जाता है, उदाहरण के लिए WXYZ9 में 9 मानचित्र । अंत में, समूह की लंबाई का उपयोग शब्दकोष से मूल्य में ऑफसेट के रूप में किया जाता है।

ध्यान दें कि ऑफसेट को दोहराए जाने वाले वर्णों के समूह की लंबाई पर मोडुलो का उपयोग करना चाहिए क्योंकि कीप्स चक्र हो सकते हैं। यह भी ध्यान दें कि # वर्ण को 0 पर मैप किया गया है और केवल अंत में हटा दिया गया है क्योंकि 99 # 99 9999 के समान नहीं है ।

यहाँ प्रश्न में प्रत्येक उदाहरण के लिए फ़ंक्शन का आउटपुट दिया गया है:

>>> 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
स्रोत
3

जावास्क्रिप्ट, 214 184 168 162 बाइट्स

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)

यह शायद थोड़ा छोटा किया जा सकता है, लेकिन मैं परिणाम से बहुत खुश हूं। वर्णों को एक या अधिक के दोहराए गए समूहों में विभाजित करता है, फिर सरणी के माध्यम से कदम उठाता है, प्रत्येक वर्ण को हैश में मान देता है और इसे अंतिम स्ट्रिंग पर जोड़ता है। यदि यह '#' किसी भी संख्या में आता है, तो इसे अनदेखा कर देता है। यदि यह किसी '*' पर आता है, तो यह अंतिम स्ट्रिंग के अंत से उनमें से उस संख्या को हटा देता है।

— Mwr247
स्रोत
0

पायथन 2, 237 बाइट्स

Cr3 के शब्दकोश का उपयोग करना, लेकिन फिर से बिना।

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
स्रोत
-1

पायथन 2, 265 बाइट्स

यह बहुत लंबा रास्ता है। IO: स्टडिन, स्टडआउट।

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])
— हनीस करपिला
स्रोत
तीसरा उदाहरण, third ## २२२ # २२२ ** 2 # २२२ # ४ , आपकी स्क्रिप्ट का कारण होगा एक ValueRrror : int के लिए अमान्य शाब्दिक (१० आधार के साथ) '* ’।
— cr3
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.