यह सवाल एक टी 9 शब्दकोश मिलान कार्यक्षमता के लिए पूछता है जो एक बहुत ही दिलचस्प समस्या है। लेकिन T9 में टाइपिंग का एक और तरीका है और वह है चरित्र-दर-अक्षर टाइप करना। इस कीबोर्ड को लागू करने के लिए आपको शब्दकोश की आवश्यकता नहीं होगी।

यदि आप भूल गए हैं तो एक T9 कीबोर्ड का की-मैप है:

+-------+-------+-------+
|   1   |   2   |   3   |
|  .?!  |  ABC  |  DEF  |
+-------+-------+-------+
|   4   |   5   |   6   |
|  GHI  |  JKL  |  MNO  |
+-------+-------+-------+
|   7   |   8   |   9   |
| PQRS  |  TUV  |  WXYZ |
+-------+-------+-------+
|   *   |   0   |   #   |
|   ←   | SPACE |   →   |
+-------+-------+-------+

T9 कैसे काम करता है

टी 9 के साथ एक चरित्र टाइप करने के लिए, आपको उस चरित्र nसमय का प्रतिनिधित्व करने वाली नंबर कुंजी को दबाने की आवश्यकता है । nउस कुंजी पर लिखे गए उस वर्ण का क्रम है। संख्याएं अंतिम वर्ण हैं जिन्हें आप प्रत्येक कुंजी के लिए टाइप कर सकते हैं। उदाहरण के लिए, टाइप करने के लिए Bमैं 2दो बार प्रेस करता हूं , या टाइप करने के लिए 5मैं 5चार बार दबाता हूं । इस चरित्र को टाइप करने के लिए मैं प्रेस करता हूं #। *बस बैकस्पेस है। कीबोर्ड के हमारे संस्करण में कोई पूंजीकरण नहीं है।

इनपुट और आउटपुट उदाहरण:

8#99999#055#33#999#22#666#2#777#3# → T9 KEYBOARD

स्पष्टीकरण:

8चुनता है Tऔर #अगले चरित्र में ले जाता है
99999का अंतिम वर्ण का चयन 9महत्वपूर्ण है जो 9और #अगले चरित्र पर ले जाता है
0 एक स्थान सम्मिलित करता है
33के दूसरे चरित्र का चयन करता है 3कुंजी है जो Kऔर #अगले वर्ण पर ले जाता है
और इसी तरह...

नियम

आपके कार्य या कार्यक्रम को T9 कीप्स का प्रतिनिधित्व करने वाले स्ट्रिंग को स्वीकार करना चाहिए। आउटपुट उन कीप्स से परिणामी टेक्स्ट है, जैसा कि ऊपर उल्लिखित है।

यह बुनियादी कोड गोल्फ है, इसलिए विजेता बाइट्स में सबसे छोटा है, और मानक नियम / कमियां लागू होती हैं।

code-golf keyboard

— मोहसिन
स्रोत

बोनस का स्कोर पर कोई प्रभाव नहीं पड़ता है? मैं इसके लिए क्यों जाऊंगा?

— ऑप्टिमाइज़र

2

साथ ही, आपका उदाहरण T9 KEYBOARDपूरी तरह से गलत है। वह एक पढ़ता हैT9 JEYBARD

— ऑप्टिमाइज़र

1

@ आमतौर पर, कोड गोल्फ में बोनस स्कोर से एक निश्चित राशि घटाएगा। आपको यह पता लगाना होगा कि कितना उचित है। पहले बोनस के लिए शायद 10 या 20 बाइट्स से अधिक नहीं। दूसरा बोनस, मुझे समझ में भी नहीं आ रहा है। यदि मैं फ़ंक्शन के लिए एक स्ट्रिंग के रूप में keypresses का अनुक्रम देता हूं, तो keypresses के बीच किसी प्रकार का समय कैसे होगा? मुझे लगता है #कि लगातार बटन अलग होने पर भी एक अधिक उचित बोनस को छोड़ने की अनुमति होगी । यह कहा जा रहा है: उस बोनस के बिना यदि #छोड़ दिया जाए तो क्या होना चाहिए ?

— मार्टिन एंडर

1

आपको इन बोनस के लिए एक संभावित बाइट गिनती लाभ जोड़ना होगा। बोनस वैकल्पिक हैं, लेकिन आप बोनस को लागू करने के लिए हर उत्तर के लिए पूछते हैं जैसे कि वे अनिवार्य हैं। कृपया स्वर साफ करें, यदि वे अनिवार्य हैं, तो उन्हें नियमों में स्थानांतरित करें, यदि वे नहीं हैं, तो बोनस को लागू करने के लिए हर उत्तर न पूछें। मैं अस्पष्ट के रूप में मतदान करने से पहले आपके उत्तर के लिए कुछ घंटों तक प्रतीक्षा करूंगा।

— ऑप्टिमाइज़र

2

18 घंटे बाद भी कोई जवाब नहीं। अस्पष्ट के रूप में बंद करने के लिए मतदान।

— ऑप्टिमाइज़र

5

CJam, 109 94 बाइट्स (2 ^{एन डी} बोनस)

एक बहुत ही भोला और लंबा समाधान

q'#/);{__'*-:A-,_g{){;}*A_}*;'0/{_,g{)~".?~1"a'[,65>292994 5b{/(X):X+\s}%+1:Xm>=\,=}*}%S*1/~}%

यह एक पूर्ण कार्यक्रम है, हालांकि एक फ़ंक्शन समान लंबाई का होगा।

इनपुट STDIN में चला जाता है

उदाहरण:

8#99999#055#33#999#***22#666#2#777#3#

आउटपुट:

T9 BOARD

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

क्या आप इसे पहले बोनस के लिए काम कर सकते हैं?

— मोहसिन

3

@Mohsen तब तक नहीं जब तक बोनस के लिए जाने का वास्तविक लाभ न हो! कहते हैं, अंतिम स्कोर में 25% कोड की लंबाई में कमी।

— ऑप्टिमाइज़र

2

जावास्क्रिप्ट ईएस 6 , 220-10 = 210 178 बाइट्स

हेल्का के सीएमसी के एक भाग के रूप में , मैंने अपनी पहली चुनौती को पछाड़ दिया है।

n=>(g=n=>n==(k=n.replace(/.\*/,""))?n:g(k))(n.match(/(\d)\1*|\*/g).map(e=>e<"0"?e:(a=" |.?!|ABC|DEF|GHI|JKL|MNO|PQRS|TUV|WXYZ".split`|`[+e[0]]+e[0])[~-e.length%a.length]).join``)

नमूना आउटपुट:

> f=n=>(g=n=>n==(k=n.replace(/.\*/,""))?n:g(k))(n.match(/(\d)\1*|\*/g).map(e=>e<"0"?e:(a=" |.?!|ABC|DEF|GHI|JKL|MNO|PQRS|TUV|WXYZ".split`|`[+e[0]]+e[0])[~-e.length%a.length]).join``)
[Function]
> f("8#99999#055#33#999#***22#666#2#777#3#")
'T9 BOARD'
> f("8#44#33#0#999#*77#88#444#222#55#0#22#777#666#9#66#0#333#666#99#0#5#88#6#7#7777#0#666#888#33#777#0#8#44#33#0#555#2#99#*9999#999#0#3#666#4#111#")
'THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG!'
> f("8#99999#055#33#999#***22#666#2#777#3#")
'T9 BOARD'

व्याख्या

(g=n=>n==(k=n.replace(/.\*/,""))?n:g(k))

यह पुनरावर्ती प्रतिस्थापन को लागू करता है, उसके बाद सभी वर्णों को प्रतिस्थापित करता है *जब तक कि कोई *शेष न हो।

n.match(/(\d)\1*|\*/g)

यह लगातार अंकों या *एस के सभी रन से मेल खाता है ।

a=" |.?!|ABC|DEF|GHI|JKL|MNO|PQRS|TUV|WXYZ".split`|`[+e[0]]+e[0]

यह वांछित शब्दकोश बनाता है, बड़े स्ट्रिंग से एन्कोडेड भाग प्राप्त करता है, फिर वांछित अंक को जोड़ रहा है।

a[~-e.length%a.length]

इस चरित्र, modulo aकी लंबाई हो जाता है ।

.join``

यह प्रसंस्करण और एस को हटाने के लिए स्ट्रिंग तैयार करता है *।

— कोनोर ओ ब्रायन
स्रोत

1

क्या आप इसे पहले बोनस के साथ काम कर सकते हैं?

— मोहसिन

@Mohsen हाँ, और यह वास्तविक मदद कर सकता है। मैं आज और कल के माध्यम से इस पर काम करूंगा।

— कॉनर ओ'ब्रायन

कृपया कम से कम किसी ऐसे स्कोर का विज्ञापन न करें जो गलत हो क्योंकि उत्तर भी कल्पना तक नहीं है।

— ऑप्टिमाइज़र

@Mohsen यह अब पहले बोनस के साथ काम कर रहा है।

— कॉनर ओ'ब्रायन

t("2#2");के Bबदले देता है AA। #उन्हें हटाने के बजाय किसी भी मिलान करने का प्रयास करें।

— टाइटस

1

पायथन, 167 157 151 बाइट्स

('*' का समर्थन नहीं करता)

कुछ खास नहीं। मैं इनपुट को सूची में बदलने के लिए रेगेक्स का उपयोग करता हूं, फिर मैं प्रविष्टियों को लूप करता हूं। मैं लुकअप सूची में इसे खोजने के लिए प्रत्येक प्रविष्टि के पहले वर्ण और लंबाई का उपयोग करता हूं:

def f(i):
  import re
  t9 = [" 0",".?!1","ABC2","DEF3","GHI4","JKL5","MNO6","PQRS7","TUV9","WXYZ9"]
  i = re.findall(r'[1-9]+|0+',i)
  answer = []
  for j in i:
    answer = answer + [t9[int(j[0])][len(j)-1]]
  return ''.join(answer)

कुछ गोल्फ के बाद ऐसा दिखता है:

import re;m=lambda i:"".join([" 0,.?!1,ABC2,DEF3,GHI4,JKL5,MNO6,PQRS7,TUV9,WXYZ9".split(",")[int(j[0])][len(j)-1] for j in re.findall(r'[1-9]+|0+',i)])

कोई बोनस (अभी तक) नहीं। मुझे नहीं पता कि मैं रेगेक्स में पहला बोनस कैसे लागू करूंगा। दूसरा बोनस बहुत सारे बाइट्स जोड़ देगा क्योंकि लुकअप एलिमेंट्स समान आकार के नहीं हैं। तीसरे बोनस को वास्तव में न समझें।

— डेफ
स्रोत

1

पर्ल 5: 106 (104 कोड + 2 झंडे)

डिलीट को हैंडल करने के लिए संशोधित।

#!perl -lp
s/((\d)\2*)#?|./chr$2*5+length$1/ge;y//d 0-3.?!1 ABC2 DEF3 GHI4 JKL5 MNO6 P-S7TUV8 W-Z9/c;1while s/.?d//

उपयोग:

perl t9.pl <<<'8#99999#055#33#999#22#666#2#777#3#'
perl t9.pl <<<'899999055339992266627773'

पर्ल 5: 88 (86 कोड + 2 झंडे)

स्टार-डिलीट के बिना पुराना संस्करण।

#!perl -lp
s/(\d)(\1*)#?/chr$1*5+length$2/ge;y// 0-3.?!1 ABC2 DEF3 GHI4 JKL5 MNO6 P-S7TUV8 W-Z9/c

— nutki
स्रोत

@ ऑप्टिमाइज़र ने इसकी कोशिश की, और यह वास्तव में * के साथ काम नहीं करता है। हालांकि यह वास्तव में आवश्यक है? यह कहता है: "ध्यान दें कि इसमें बैकस्पेस के लिए * शामिल हो सकता है ..."

— डेफ

चूंकि इसके बोनस का हिस्सा नहीं है। इसका एक अनिवार्य नियम है।

— ऑप्टिमाइज़र

ऐसा कहे जाने के बाद। सवाल बहुत स्पष्ट नहीं है कि एक नियम क्या है और एक बोनस क्या है। मैंने ओपी से कई घंटे पहले स्पष्टीकरण मांगा। यदि कोई प्रतिक्रिया नहीं है, तो मैं इस प्रश्न को अस्पष्ट रूप में बंद करने के लिए मतदान कर रहा हूं।

— ऑप्टिमाइज़र

क्षमा करें, मुझे उन भाषाओं में वर्तमान उत्तरों के रूप में गुमराह किया गया था जिन्हें मैं पढ़ सकता हूं * भी समर्थन नहीं करता है।

— नटकी

यदि आप मेरे अजगर उत्तर की बात कर रहे हैं, तो आप सही हैं। मैंने प्रश्न का गलत अर्थ निकाला।

— डेफ

1

AWK 211 बाइट्स (बोनस के साथ)

{split(".?!1-ABC2-DEF3-GHI4-JKL5-MNO6-PQRS7-TUV8-WXYZ9- 0",k,"-");split($0"#",a,"");while(1+(b=a[++i])){if(b==p)++c;else{for(g in k)if(p==substr(k[g],l=length(k[g])))printf(substr(k[g],1+((c-1)%l),1));c=1;p=b}}}

यह एक पूर्ण कार्यक्रम है जो स्टड से इनपुट को पढ़ता है। यह प्रत्येक पंक्ति के लिए कीबोर्ड को फिर से शुरू नहीं करने के लिए अधिक कुशल होगा, लेकिन यह स्क्रिप्ट को लंबा कर देगा।

इसके अलावा अगर "0" कुंजी 0 के अलावा कुछ और थी, तो स्क्रिप्ट 4 बाइट्स छोटी होगी, लेकिन यह गेम का हिस्सा है: o)

— LeFauve
स्रोत

1

सी (245 बाइट्स)

#define M "8#44#33#0#999#*77#88#444#222#55#0#22#777#666#9#66#0#333#666#99#0#5#88#6#7#7777#0#666#888#33#777#0#8#44#33#0#555#2#99#*9999#999#0#3#666#4#111#"

#include<stdio.h>
char K[][4]={" ",".?!","ABC","DEF","GHI","JKL","MNO","PQRS","TUV","WXYZ"},I[]=M;int       
i,j,k,r;main(){for(;I[i];++i){if(I[i]=='#')I[j++]=K[k][--r],r=k=0;else               
if(I[i]=='*')j?--j:0;else if(!r++)k=I[i]-'0';}I[j]=0;printf("%s\n",I);}

उत्पादन

THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG!

व्याख्या

बाइट काउंट में पहले दिए गए इनपुट स्ट्रिंग शामिल नहीं हैं #define।

मैं किस वर्ण को मुद्रित करने के लिए लुकअप तालिका के रूप में द्वि-आयामी सरणी का उपयोग करता हूं। कार्यक्रम के द्वारा सीमांकित पात्रों में पढ़ता है '#'।

प्रत्येक समूह के लिए, इनपुट संख्या पहले-आयाम सरणी सूचकांक को निर्धारित करती है, और इनपुट संख्या की पुनरावृत्ति की संख्या दूसरे-आयाम सरणी सूचकांक को निर्धारित करती है। '*'चाल उत्पादन स्ट्रिंग के लिए सरणी के सूचकांक वापस इतनी के रूप में पिछले पत्र अधिलेखित करने के लिए।

तो इनपुट स्ट्रिंग 44#(1 पुनरावृत्ति '4') को लुकअप टेबल पर अनुवादित K[4][1]किया जाता है, जो कि चरित्र है H।

Ungolfed संस्करण

#define INPUT "8#44#33#0#999#*77#88#444#222#55#0#22#777#666#9#66#0#333#666#99#0#5#88#6#7#7777#0#666#888#33#777#0#8#44#33#0#555#2#99#*9999#999#0#3#666#4#"

#include<stdio.h>

static const char keyboard[10][4] = {" ", ".?!", "ABC", "DEF", "GHI", "JKL", "MNO", "PQRS", "TUV", "WXYZ"};

int main(void)
{
  char input[] = INPUT;
  char output[256];
  int i, j;
  int key = 0;
  int reps = 0;

  for (i = j = 0; input[i] != '\0'; ++i) {
    switch (input[i]) {
    case '#':
      output[j] = keyboard[key][reps - 1];
      ++j;
      reps = key = 0;
      break;
    case '*':
      if (j > 0) --j;
      break;
    default:
      if (reps == 0)  {
        key = (int)input[i] - '0';
      }
      ++reps;
      break;
    }
  }

  output[j] = '\0';
  printf("%s\n", output);

  return(0);
}

— musarithmia
स्रोत

1

रूबी 254 , 248 , 229 बाइट्स

golfed:

n=->(t){r,m,b=[]," _.?!1_ABC2_DEF3_GHI4_JKL5_MNO6_PQRS7_TUV8_WXYZ9_*_0_#".split("_"),nil;t.scan(/((.)\2*)/){|l,_|(!(l=~/\#/)?(l=~/\*/?(r.pop l.size):(l=="00"?r<<(b ? "0 ":" 0"):(c=m[l[0].to_i];r<<c[l.size%c.size-1]))):b=l)};r*""}

Ungolfed:

def t9totext(t)
  bonq = nil
  numpad = [" ",".?!1","ABC2","DEF3","GHI4","JKL5","MNO6","PQRS7","TUV8","WXYZ9","*","0","#"]

  r = []
  t.scan(/((.)\2*)/) do |l, _|
    if !(l =~ /\#/)
      if l =~ /\*/
        r.pop(l.size)
      elsif l == "00"
        r << (bonq ? "0 " : " 0")
      else
        c = numpad[l[0].to_i]
        r << c[l.size % c.size - 1]
      end
    else
      bonq = l
    end
  end
  r.join
end

ये सभी ऐनक सफल होने चाहिए:

  it "outputs the correct word" do
    expect(n.call('8#99999#055#33#999#22#666#2#777#3#1')).to eq("T9 KEYBOARD.")
    expect(n.call('4433555#55566609666666677755533*3111')).to eq("HELLO WORLD!")
    expect(n.call('7##222#222**7#222#4')).to eq('PPCG')
    expect(n.call('00#0#00')).to eq(' 0 0 ')
  end

इसका 0 0जवाब एक हैकी समाधान की तरह दिखता है। समय मिलने पर इस पर गौर करेंगे।

— Biketire
स्रोत

0

PHP, 183-10 = 173 बाइट्स

सभी संस्करण कमांड लाइन तर्क से इनपुट लेते हैं; साथ बुलाओ php -r '<code>' <string>।

नोट : यदि इनपुट शुरू होता है तो सभी संस्करण चेतावनी देते हैं *। उस दोष को दूर करने के लिए कोड को
प्रेप करें $o=[];।

preg_match_all("%(\d)\1*|\*%",$argv[1],$m);foreach($m[0]as$w)if("*"==$w)array_pop($o);else$o[]="- 0   .?!1 ABC2 DEF3 GHI4 JKL5 MNO6 PQRS7TUV8 WXYZ9"[$w[0]*5+strlen($w)];echo join($o);

हैश टैग की जरूरत नहीं है
यदि कोई कुंजी बहुत बार दबाया जाता है तो विफल रहता है

210-10 - ?? = ??? बाइट्स

$a=[" 0",".?!1",ABC2,DEF3,GHI4,JKL5,MNO6,PQRS7,TUV8,WXYZ9];preg_match_all("%(\d)\1*|\*%",$argv[1],$m);foreach($m[0]as$w)if("*"==$w)array_pop($o);else$o[]=$a[$w[0]][strlen($w)%strlen($a[$w[0]])-1];echo join($o);

हैश टैग की जरूरत नहीं है
घूमता है यदि एक कुंजी को बहुत बार दबाया जाता है

181 बाइट्स, कोई बोनस नहीं

preg_match_all("%\d+#|\*%",$argv[1],$m);foreach($m[0]as$w)if("*"==$w)array_pop($o);else$o[]=" 0   .?!1 ABC2 DEF3 GHI4 JKL5 MNO6 PQRS7TUV8 WXYZ9"[$w[0]*5+strlen($w)-2];echo join($o);

टूट - फूट

"नो हैश टैग" संस्करण स्ट्रिंग को (समान संख्या की लकीर) और (तारांकन) में विभाजित करते हैं और बाकी सब कुछ भूल जाते हैं। नो-बोनस संस्करण लेता है (इसके बाद संख्या की लकीर #) और (तारांकन)।

फिर मैचों के माध्यम से लूप करें: यदि कोई '*' पाया जाता है, तो परिणाम सरणी के अंतिम तत्व को हटा दें।

संस्करणों के बीच का अंतर elseभाग में है:

कोई बोनस संस्करण: मैप स्ट्रिंग को (कुंजी * 5) ऑफसेट करें, फिर (कीस्ट्रोक्स = शब्द लंबाई -1) -1 जोड़ें, उस स्थिति से परिणाम में वर्ण जोड़ें।
सरल नो-टैग संस्करण: लगभग समान, लेकिन: (कीस्ट्रोक्स = शब्द लंबाई); दूसरे से छुटकारा पाने के लिए मैप स्ट्रिंग में एक वर्ण जोड़ा -1।
घूर्णन संस्करण: मानचित्र सरणी से आइटम (कुंजी) लें, परिणाम में उस आइटम से चरित्र (कीस्ट्रोक% आइटम लंबाई -1) जोड़ें।

— टाइटस
स्रोत

0

जावास्क्रिप्ट, 147 बाइट्स

Conor के जवाब मेरे PHP जवाब से regex के साथ तय किए गए हैं और नीचे गोल्फ हैं।

t=i=>i.match(/(\d)\1*|\*/g).map(w=>(" 0~.?!1~ABC2~DEF3~GHI4~JKL5~MNO6~PQRS7~TUV8~WXYZ9".split`~`[w[0]]||"*")[w.length-1]).join``.replace(/.\*/g,"")

टूट - फूट

t=i=>i
    .match(/(\d)\1*|\*/g)   // split input to streaks of equal numbers and single `*`
    .map(w=>                // replace each item with ...
                            // .. take string depending on the digit
        (" 0~.?!1~ABC2~DEF3~GHI4~JKL5~MNO6~PQRS7~TUV8~WXYZ9".split`~`[w[0]]
        ||"*")              // .. ("*" for not a digit)
        [w.length-1]        // -> the (item length)th character of that string
    )
    .join``                 // join without delimiter
    .replace(/.\*/g,"")     // and recursively remove every (letter,asterisk) combination

घूर्णन संस्करण, 158 बाइट्स

s=स्ट्रिंग को याद करने और %s.lengthघुमाने के लिए जोड़ा गया ।

t=i=>i.match(/(\d)\1*|\*/g).map(w=>(s=" 0~.?!1~ABC2~DEF3~GHI4~JKL5~MNO6~PQRS7~TUV8~WXYZ9".split`~`[w[0]]||"*")[w.length%s.length-1]).join``.replace(/.\*/g,"")

— टाइटस
स्रोत

एक T9 कीबोर्ड बनाएं

T9 कैसे काम करता है

इनपुट और आउटपुट उदाहरण:

नियम

CJam, 109 94 बाइट्स (2 एन डी बोनस)

जावास्क्रिप्ट ईएस 6 , 220-10 = 210 178 बाइट्स

व्याख्या

पायथन, 167 157 151 बाइट्स

पर्ल 5: 106 (104 कोड + 2 झंडे)

पर्ल 5: 88 (86 कोड + 2 झंडे)

AWK 211 बाइट्स (बोनस के साथ)

सी (245 बाइट्स)

उत्पादन

व्याख्या

Ungolfed संस्करण

रूबी 254 , 248 , 229 बाइट्स

PHP, 183-10 = 173 बाइट्स

जावास्क्रिप्ट, 147 बाइट्स

CJam, 109 94 बाइट्स (2 ^{एन डी} बोनस)