एक फोन नंबर (अक्षरों सहित) में रोटरी डायल दालों की गणना

34

आपके दादा दादी के दिन में, इस तरह एक रोटरी डायल के साथ एक फोन नंबर डायल किया गया था :

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

अंक N को डायल करने के लिए N की आवश्यकता है जैसे कि "दालों" को छोड़कर N = 0 जो कि दस दालों की है।

रोटरी फोन में वह गुण होता है जो बड़े अंकों (8, 9, 0) को छोटे अंकों (1, 2, 3) से अधिक समय तक डायल करने में लेता है। प्रारंभिक क्षेत्र कोड मानचित्रों को खींचने में यह एक महत्वपूर्ण विचार था, और इसकी भारी आबादी (और फोन लाइन) घनत्व के साथ न्यूयॉर्क सिटी को 212 (केवल 5 दालें) क्यों मिलीं , जबकि 907 (26 दालों) अलास्का में काफी हद तक चली गईं। बेशक, यह सब तब अप्रासंगिक हो गया जब टच-टोन डायलिंग लोकप्रिय हो गई।

चुनौती

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

अंक

  • अंक 1-9 को दालों की संख्या के रूप में गिना जाता है।
  • अंक 0 10 दालों के रूप में गिना जाता है।

पत्र

ध्यान दें कि डायल पर अंक 2-9 में लैटिन वर्णमाला के अक्षर उनके साथ जुड़े हुए हैं। ये मूल रूप से नामित एक्सचेंजों के लिए अभिप्रेत थे , लेकिन बाद में फोनवार्ड के लिए पुन: विनियोजित किए गए थे , और पाठ संदेश इनपुट सिस्टम के लिए।

आपको अपने फ़ोन नंबर में अक्षरों का समर्थन करना चाहिए, अंकों के लिए E.161 असाइनमेंट का उपयोग करते हुए :

  • ए, बी, सी = 2
  • डी, ई, एफ = 3
  • जी, एच, आई = 4
  • जे, के, एल = ५
  • एम, एन, ओ = 6
  • पी, क्यू, आर, एस = 7
  • टी, यू, वी = 8
  • डब्ल्यू, एक्स, वाई, जेड = 9

आप मान सकते हैं कि इनपुट पहले से ही केस-फोल्ड हो चुका है, ऊपरी या निचले मामले में।

अन्य कैरेक्टर

आपको चरित्रों और स्थान के मनमाने ढंग से उपयोग को विभाजकों को स्वरूपित करने की अनुमति देनी चाहिए()+-./ । इस प्रयोजन के लिए किसी भी गैर-अल्फ़ान्यूमेरिक वर्ण की अनुमति देने के लिए आपने चुना हो सकता है , अगर इसे लागू करना आसान हो।

ये वर्ण नाड़ी गणना में योगदान नहीं करते हैं।

उदाहरण कोड

पायथन में एक गैर-गोल्फ लुकअप टेबल और फंक्शन:

PULSES = {
    '1': 1,
    '2': 2, 'A': 2, 'B': 2, 'C': 2,
    '3': 3, 'D': 3, 'E': 3, 'F': 3,
    '4': 4, 'G': 4, 'H': 4, 'I': 4,
    '5': 5, 'J': 5, 'K': 5, 'L': 5,
    '6': 6, 'M': 6, 'N': 6, 'O': 6,
    '7': 7, 'P': 7, 'Q': 7, 'R': 7, 'S': 7,
    '8': 8, 'T': 8, 'U': 8, 'V': 8,
    '9': 9, 'W': 9, 'X': 9, 'Y': 9, 'Z': 9,
    '0': 10
}

def pulse_count(phone_num):
    return sum(PULSES.get(digit, 0) for digit in phone_num)

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

  • 911 → 11
  • 867-5309 → 48
  • 713 555 0123 → 42
  • +1 (212) PE6-5000 → 57
  • 1-800-FLOWERS → 69
  • PUZZLES → 48
code-golf  number 
— dan04
स्रोत
मेरा मानना ​​है कि महत्वाकांक्षी ASCII विराम चिह्न और रिक्त स्थान उन लोगों के लिए प्रतिबंधित हैं जो सामान्य रूप से फोन नंबर ( +- ()*#.) के लिए उपयोग किए जाते हैं जैसे अक्षर अपरकेस तक सीमित हैं। यदि मैं गलत हूं तो मुझे सही करों।
— शाम
1
@ Adám: मैंने कुछ सामान्य विभाजकों के लिए आवश्यक विराम चिह्न को प्रतिबंधित कर दिया है। इसमें जानबूझकर शामिल नहीं है *और #, जिनके टच-टोन फोन पर विशेष अर्थ हैं और रोटरी पर डायल करने योग्य नहीं हैं।
— dan04
1
क्या हम ऑल-अपरकेस के बजाय सभी-लोअरकेस इनपुट का उपयोग कर सकते हैं? क्या हम एक स्ट्रिंग के बजाय एक वर्ण ले सकते हैं?
— ग्रैमी
1
मैं एक समय यात्री हूँ! मैं एक समय यात्री हूँ! मैं एक समय यात्री हूँ! चूंकि मैं निश्चित रूप से इस तरह के फोन का इस्तेमाल करता था जब मैं एक बच्चा था, स्पष्ट रूप से मैं अपना खुद का हूं !!!!!!! जब मैं इसके बारे में सोचता हूं तो यह वास्तव में बहुत ही अजीब है। Bleah !!!
— बॉब जार्विस -
3
मैं दादा हूं। मैंने 1950 के दशक में इस तरह के फोन का इस्तेमाल किया था। और जब मैं एक ग्रामीण स्थान के एक शहर में चला गया, तो मुझे पता चला कि फोन कंपनी ने टच-टोन सेवा की पेशकश नहीं की है। यह 1985 में था! मजाक नहीं! मेरी दादी के पास पार्लर में एक फोन था जिसमें एक हुक और एक क्रैंक था। आपने हुक से इयरपीस लिया, और स्विचबोर्ड ऑपरेटर प्राप्त करने के लिए क्रैंक को चालू किया। प्रत्यक्ष दूरी डायलिंग स्थापित किए जाने पर उसे इसे बदलना पड़ा।
— वाल्टर मिती

जवाबों:

25

05AB1E , 19 18 17 15 बाइट्स

AÁ0ªā6+žq÷9š‡þO

इसे ऑनलाइन आज़माएं!

Π का उपयोग करने का यह पहला उत्तर है। Might का उपयोग क्यों करें, आप पूछ सकते हैं? ठीक है, पत्र क्रम में 22233344455566677778889999 से जुड़े हैं। ध्यान दें कि अधिकांश अंक 3 बार दोहराते हैं, लेकिन 7 बार 4 बार दोहराते हैं। आप कह सकते हैं कि प्रत्येक अंक औसतन (3 + 1/7) बार दोहराता है। मुझे आश्चर्य है कि अगर कोई संख्या है जो लगभग 3 + 1/7 है और 22/7 से कम बाइट लेती है ...

यह केवल 4 7s देता है, 4 9s नहीं, इसलिए हमें अभी भी एक विशेष मामले के रूप में Z को संभालने की आवश्यकता है।

A               # alphabet (abcdefghijklmnopqrstuvwxyz)
 Á              # rotate right (zabcdefghijklmnopqrstuvwxy)
  0ª            # append 0 (zabcdefghijklmnopqrstuvwxy0)

ā6+             # range [7..33]
   žq÷          # divide by π (22233344455566677778889991010)
      9š        # prepend 9 (922233344455566677778889991010)

‡               # transliterate the implicit input with the two lists above
                # this replaces z → 9, a → 2, … y → 9, 0 → 10
 þ              # remove all non-digits
  O             # sum
— ग्रिमी
स्रोत
अपरकेस की जगह लोअरकेस क्यों?
— dan04
1
@ dan04 क्योंकि 05AB1E में पुश करने के लिए बिल्ट-इन है "abcdefghijklmnopqrstuvwxyz", लेकिन इसके लिए नहीं "ABCDEFGHIJKLMNOPQRSTUVWXYZ"। मैं वर्णमाला को अपरकेस में इनपुट करने के बजाय लोअरकेस में परिवर्तित कर सकता था, लेकिन यह वही बाईटेकाउंट है।
— ग्रैमी
1
मैंने आपके पहले दो आदेशों को अनावश्यक बनाने के लिए प्रश्न संपादित किया है।
— dan04
3
@ जोनाह मैंने वांछित अनुक्रम प्राप्त करने के लिए एक निरंतर द्वारा एक सीमा को विभाजित करने के विचार के साथ शुरू किया, फिर 05AB1E में "थोड़ा अधिक 3" व्यक्त करने का सबसे अच्छा तरीका खोज रहा था मुझे याद था कि पी एक अंतर्निहित था।
— ग्रैमी
2
पी के उपयोग के लिए +1
— ड्रेकिन
9

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 51 बाइट्स

n=>n.Sum(x=>x>64?(x-59-x/83-x/90)/3:x>47?1-~x%~9:0)

@ बचे के लिए 1 बाइट धन्यवाद

सहेजे गए 10 बाइट्स @ ExpiredData के अवलोकन के लिए धन्यवाद जो केवल () +-/.इनपुट में होंगे

इसे ऑनलाइन आज़माएं!

n =>                     // Function taking input as string
  n.Sum(x =>             // Map each value 'x' through the following
    x>64 ?               //   If 'x' is an uppercase letter
      (x-59-x/83-x/90)/3 //     Take each char's ASCII value subtracted by 59, and subtract
                         //     one if the char is 'S' and one if the char is 'Z'
    : x>47 ?             //   Else if the char is a digit
      1-~x%~9            //   Take 1 - (-x - 1) % -10 (Maps 0 to 10, and 1-9 to themselves
    : 0                  //   Else, 0
  )                      // And sum it all up, then return it
— अज्ञान का अवतार
स्रोत
4
-10है ~9जो संदर्भ में काम करना चाहिए,।
— पुनरावर्ती
@recursive स्मार्ट है, धन्यवाद
— अज्ञानता का अवतार
1
x <91 चेक निरर्थक है क्योंकि इनपुट में केवल () + - / / ही होगा अंतरिक्ष कुंजी और संख्या जो सभी <64 हैं इसलिए हम यह निर्धारित कर सकते हैं कि क्या x> 64 (इसलिए -5 बाइट्स) को चेक करके ही चरित्र अपरकेस है
— डाटा
समान x <58 चेक के लिए जाता है, क्योंकि 58-64 में कुछ भी इनपुट में नहीं होगा
— एक्सपायर्ड डेटा
— समय सीमा समाप्त डेटा
5

एपीएल (Dyalog यूनिकोड) , 27 बाइट्स SBCS

बेनामी tacit उपसर्ग समारोह।

+/'@ADGJMPTW'∘⍸+11|(1⌽⎕D)∘⍳

इसे ऑनलाइन आज़माएं!

(... )∘⍳ लगता है ɩ : ndex * निम्नलिखित स्ट्रिंग में प्रत्येक चरित्र के
  सूचकांक 1 + अधिकतम सूचकांक, यानी 11 * तत्वों को नहीं मिला रहे हैं, प्राप्त
 ⎕D  अंक:"0123456789"

 1⌽ चक्रीय रूप से एक कदम छोड़ दिया घुमाएँ; "1234567890"

11| विभाजन शेष जब 11 *
  * से विभाजित होता है, तो यह सभी गैर-अंकों के लिए 0 देता है
... + इसे निम्नलिखित में जोड़ें:

 '@ADGJMPTW'∘⍸ɩ nterval ɩ ndex * हर किरदार के लिए
  * तो [-∞, "@") 0 देता है, [ "@", "ए") 1 देता है, [ 'ए', 'डी') 2 देता है, आदि
+/  योग कि

— एडम
स्रोत
5

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

lambda s:sum([(n-59-n/83-n/90)/3,1-~n%~9][n<58]for n in map(ord,s)if n>47)

इसे ऑनलाइन आज़माएं!

प्रत्येक वर्ण के लिए ASCII मान पर कुछ अंकगणित करता है। पहला विकल्प अक्षरों के लिए जाँचता है और दूसरा विकल्प संख्याओं के लिए जाँच करता है। इनपुट में अनुमत सभी विराम चिह्नों के स्पष्टीकरण 48 से कम ASCII मूल्यों वाले हैं जो मुझे तर्क को सरल बनाते हैं, लेकिन पूरी तरह से एक नया तरीका अब बेहतर हो सकता है।

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

lambda s:sum(1+'1xxxx2ABCx3DEFx4GHIx5JKLx6MNOx7PQRS8TUVx9WXYZ0'.find(c)/5for c in s)

इसे ऑनलाइन आज़माएं!

एक हार्डकोड लुकअप स्ट्रिंग का उपयोग करता है, जिसमें प्रत्येक वर्ण को देने वाले वर्णों के अनुरूप 5 वर्णों के प्रत्येक ब्लॉक 1. रिक्त स्थान से भरे होते हैं x, जो कि इनपुट में नहीं होता है जो कि कैपिटल है। सौभाग्य से, स्ट्रिंग में प्रदर्शित नहीं होने वाले पात्र जिसके -1लिए .findशून्य का सारांश दिया जाता है।

— XNOR
स्रोत
5

जावास्क्रिप्ट (Node.js) , ... 76 69 बाइट्स

s=>s.replace(/\w/g,q=>w+=1/q?+q||10:parseInt(q,35)*.32-1|0||9,w=0)&&w

इसे ऑनलाइन आज़माएं!

-7 धन्यवाद @Arnauld!

व्याख्या

 q |     1/q     |  +q  | parseInt(q,35)*.32 | parseInt(q,35)*.32-1|0 | Output
---+-------------+------+--------------------+------------------------+--------
 0 | Infinity(T) | 0(F) |         N/A        |           N/A          |   10
 1 |  1.0000(T)  | 1(T) |         N/A        |           N/A          |    1
 2 |  0.5000(T)  | 2(T) |         N/A        |           N/A          |    2
 3 |  0.3333(T)  | 3(T) |         N/A        |           N/A          |    3
 4 |  0.2500(T)  | 4(T) |         N/A        |           N/A          |    4
 5 |  0.2000(T)  | 5(T) |         N/A        |           N/A          |    5
 6 |  0.1666(T)  | 6(T) |         N/A        |           N/A          |    6
 7 |  0.1428(T)  | 7(T) |         N/A        |           N/A          |    7
 8 |  0.1250(T)  | 8(T) |         N/A        |           N/A          |    8
 9 |  0.1111(T)  | 9(T) |         N/A        |           N/A          |    9
 A |    NaN(F)   |  N/A |        3.20        |          2(T)          |    2
 B |    NaN(F)   |  N/A |        3.52        |          2(T)          |    2
 C |    NaN(F)   |  N/A |        3.84        |          2(T)          |    2
 D |    NaN(F)   |  N/A |        4.16        |          3(T)          |    3
 E |    NaN(F)   |  N/A |        4.48        |          3(T)          |    3
 F |    NaN(F)   |  N/A |        4.80        |          3(T)          |    3
 G |    NaN(F)   |  N/A |        5.12        |          4(T)          |    4
 H |    NaN(F)   |  N/A |        5.44        |          4(T)          |    4
 I |    NaN(F)   |  N/A |        5.76        |          4(T)          |    4
 J |    NaN(F)   |  N/A |        6.08        |          5(T)          |    5
 K |    NaN(F)   |  N/A |        6.40        |          5(T)          |    5
 L |    NaN(F)   |  N/A |        6.72        |          5(T)          |    5
 M |    NaN(F)   |  N/A |        7.04        |          6(T)          |    6
 N |    NaN(F)   |  N/A |        7.36        |          6(T)          |    6
 O |    NaN(F)   |  N/A |        7.68        |          6(T)          |    6
 P |    NaN(F)   |  N/A |        8.00        |          7(T)          |    7
 Q |    NaN(F)   |  N/A |        8.32        |          7(T)          |    7
 R |    NaN(F)   |  N/A |        8.64        |          7(T)          |    7
 S |    NaN(F)   |  N/A |        8.96        |          7(T)          |    7
 T |    NaN(F)   |  N/A |        9.28        |          8(T)          |    8
 U |    NaN(F)   |  N/A |        9.60        |          8(T)          |    8
 V |    NaN(F)   |  N/A |        9.92        |          8(T)          |    8
 W |    NaN(F)   |  N/A |       10.24        |          9(T)          |    9
 X |    NaN(F)   |  N/A |       10.56        |          9(T)          |    9
 Y |    NaN(F)   |  N/A |       10.88        |          9(T)          |    9
 Z |    NaN(F)   |  N/A |         NaN        |          0(F)          |    9

सभी [space]().+-/द्वारा कब्जा नहीं किया जाता है /\w/g, इसलिए वे कुल को प्रभावित नहीं करेंगे।

— शायरु असकोतो
स्रोत
4

रेटिना 0.8.2 , 34 बाइट्स

T`WTPMJGDA`Rd
}T`L`2L
0
55
\d
$*
1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

T`WTPMJGDA`Rd

अक्षरों WTPMJGDAको अंकों में परिवर्तित करें 9..0।

}T`L`2L

शेष सभी अक्षरों को 1 से नीचे फेरें और तब तक दोहराएं जब तक कि सभी अक्षर अंकों में परिवर्तित नहीं हो जाते।

0
55

प्रतिस्थापित 0करने 55के लिए वे डायल करने के लिए दालों की समान संख्या लेते हैं।

\d
$*
1

डिजिटल योग को लें।

— नील
स्रोत
3

K4 , 44 बाइट्स

समाधान:

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?

उदाहरण:

q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"911"
11
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"867-5309"
48
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"+1 (212) PE6-5000"
57
q)k)+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")?"1-800-FLOWERS"
69

स्पष्टीकरण:

अच्छा दृष्टिकोण, बहुत सुंदर गोल्फ होने की संभावना है। वर्ण का लुकअप इंडेक्स, लुकअप स्कोर, योग।

+/(1+(1+&(5#3),4 3 4),!10)(.Q.A,1_.Q.n,"0")? / the solution
                                           ? / lookup
                          (               )  / do this together
                                       "0"   / string "0"
                                      ,      / join with
                                  .Q.n       / string "0123456789"
                                1_           / drop first
                               ,             / join with
                           .Q.A              / "A..Z"
  (                      )                   / do this together
                      !10                    / range 0..9
                     ,                       / join with
     (              )                        / do this together
               4 3 4                         / list (4;3;4)
              ,                              / join with
         (5#3)                               / list (3;3;3;3;3)
        &                                    / where, creates list 0 0 0 1 1 1 2 2 etc
      1+                                     / add 1
   1+                                        / add 1
+/                                           / sum up
— streetster
स्रोत
3

सी (जीसीसी) , 94 89 86 80 बाइट्स

सुझाव के लिए सीलिंग, नेलनहोफ और रोजम के लिए धन्यवाद।

c;f(char*s){c=*s-48;s=*s?(c<10U?c?c:10:c-17<26U?(c-11-c/35-c/42)/3:0)+f(s+1):0;}

इसे ऑनलाइन आज़माएं!

— ErikF
स्रोत
एक लूप के बजाय पुनरावृत्ति का उपयोग करके 80 बाइट्स ।
सुझाएँ c<43Uबजायc-17<26U
— ceilingcat
2

दे घुमा के , 256 बाइट्स

आप समान बाइट गणना के (( … ))साथ निर्माणों को बदल सकते हैं let। मामले के बयानों को कम करने के लिए एक अच्छा एल्गोरिथ्म हो सकता है लेकिन अभी तक इसे नहीं मिला है। थोड़े से काम के साथ आप इसे एक फ़ंक्शन भी बना सकते हैं (लेकिन समान या कम बाइट्स में नहीं जब तक आप function fname { … }शीर्ष और पूंछ को छूट नहीं दे सकते )।

read p;while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; ([ABC) ((d+=2));; ([P-S]) ((d+=7));; ([W-Z]) ((d+=9));;([DEF]) ((d+=3));; ([GHI]) ((d+=4));; ([JKL]) ((d+=5));; ([MNO]) ((d+=6));; (?) d=$d; esac;p=${p#?};done;echo $d

इसे ऑनलाइन आज़माएं!

मैप कैरेक्टर तकनीक का उपयोग करने वाला एक बेहतर समाधान trटूल का उपयोग करता है:

[बश ट्र के साथ], 173 बाइट्स

read p;p=$(echo $p|tr A-Z 22233344455566677778889999);while ((${#p}>0));do case ${p:0:1} in ([1-9]) ((d+=${p:0:1}));; ([0]) ((d+=10));; (?) d=$d; esac;p=${p#?}; done;echo $d

इसे ऑनलाइन आज़माएं!

— PJF
स्रोत
एक एल्गोरिथ्म मैं निश्चित रूप से चूक गया, AZ पर कुछ स्ट्रिंग प्रतिस्थापन / अनुवाद करना है। यह अच्छा होगा। मैं उपर्युक्त में संशोधन करूंगा।
— पीजेएफ
while((${#p}))काम करता है, तीन बाइट्स की बचत। c=${p:0:1};case c in ([0-9]) ((d+=c?c:10));;एक और 16 बचाता tr -dc 0-9है। ट्र पाइपलाइन के साथ जोड़े जाने पर आपको केस स्टेटमेंट की आवश्यकता नहीं होती है और इसके whileसाथ स्थिति को जोड़ दिया जा सकता है &&।
— ओह माय गुडनेस
धन्यवाद OMG मैं अक्सर टर्नरी असाइनमेंट का उपयोग नहीं करता हूं, इसलिए मैं चूक गया। डिलीट सप्लिमेंट का रोचक उपयोग (लेकिन मेरे समाधान की तरह यह किसी अन्य चरित्र को अनदेखा करता है)। मैं इसे 133 बाइट्स तक नीचे लाने में कामयाब रहा हूं: read p;p=$(echo $p|tr A-Z 22233344455566677778889999|tr -dc [0-9]);while ((${#p}));do c=${p:0:1}&&((d+=c?c:10));p=${p#?};done;echo $d
— PJF
1
118: p=$(head -1|tr A-Z 22233344455566677778889|tr -dc 0-9);while((${#p}));do((d+=(c=${p:0:1})?c:10));p=${p#?};done;echo $d.. अंतिम तीन 9 की जरूरत नहीं है क्योंकि यदि दूसरा तर्क बहुत छोटा है तो tr अंतिम प्रतिस्थापन चरित्र का पुन: उपयोग करेगा।
— ओह माय गुडनेस
1
पहले उदाहरण को कुछ अनावश्यक स्थानों को हटाकर 256 से 236 तक नीचे ले जाया जा सकता है। read p;while((${#p}>0));do case ${p:0:1} in ([1-9])((d+=${p:0:1}));;([0])((d+=10));;([ABC)((d+=2));;([P-S])((d+=7));;([W-Z])((d+=9));;([DEF])((d+=3));;([GHI])((d+=4));;([JKL])((d+=5));;([MNO])((d+=6));;(?)d=$d;esac;p=${p#?};done;echo $d
— स्टीव
2

जेली , 33 24 बाइट्स

7r32:ØP«9Ṿ€ØAżFyfØDV€o⁵S

इसे ऑनलाइन आज़माएं!

अपने तर्क के रूप में एक कड़ी ले रहा है और दालों की संख्या लौटाता है। @ ग्रिम के 05AB1E उत्तर से प्रेरित फिर से लिखा गया ताकि उन्हें उखाड़ फेंका जाए!

— निक केनेडी
स्रोत
2

पॉवरशेल , 109 102 87 बाइट्स

$(switch -r($args|% t*y){\d{$_}[A-Y]{("{0}"-f(.313*$_-18))[0]}[Z]{9}0{10}})-join'+'|iex

इसे ऑनलाइन आज़माएं!

संपादित करें: कुछ स्ट्रिंग स्ट्रिंग के साथ एक regex स्विच के लिए @ mazzy के विचार का इस्तेमाल किया -> int -> स्ट्रिंग और केवल पहले 'अंक' को पकड़ो

मूल: 

[char[]]"$args"|%{$a+=(48,(('22233344455566677778889999')[$_-65],(58,$_)[$_-ne48])[$_-lt64])[$_-gt47]-=48};$a

मैं <100 बाइट्स प्राप्त करने की उम्मीद कर रहा था, इसलिए मैं यह देखने के लिए देखता रहूंगा कि क्या कुछ और है जो मैं कर सकता हूं। नंबर स्ट्रिंग को हटाने का एक तरीका शायद है

क्षमा करें, अगर यह भ्रामक है क्योंकि मैंने बूलियन इंडेक्सिंग स्टेटमेंट के साथ एरेस्टेड नेस्ट किया है लेकिन -

स्पष्टीकरण:

[char[]]"$args"|%{इनपुट स्ट्रिंग के रूप casted पढ़ता है और उसके बाद एक चार सरणी के लिए यह विस्फोट और एक के लिए-प्रत्येक जाँच के साथ पाश शुरू होता है ()[$_-gt47], यदि कोई हो को देखने के लिए ()+-./प्रवेश किया था (सभी ASCII वर्ण मान हो <48)
नोट: Powershell स्वीकार करता है $trueऔर $falseके रूप में 1और 0सरणी सूचकांक के लिए क्रमश:

फिर हम या तो 48प्रतीकों के लिए मिलते हैं , या:
('22233344455566677778889999'[$_-65],(58,$_)[$_-ne48])[$_-lt64]

[$_-lt64]एक नंबर या एक पत्र (यहाँ सब ग्रहण राजधानी) के लिए जाँच करता है। यदि यह एक अक्षर है, तो '22233344455566677778889999'[$_-65]इसे 0-25 में बदलकर सरणी में अनुक्रमित करें और पल्स वैल्यू (एक चार के रूप में) आउटपुट दें। यदि चरित्र एक संख्या है, तो हम इसके बजाय देखते हैं: आउटपुट और (58,$_)[$_-ne48]चेकिंग058 या केवल संख्यात्मक चार हैं।

लगभग सब कुछ $a+= ... -=48एक संख्यात्मक चर $ पर आरंभ करता है 0और फिर आउटपुट जोड़ता है। आउटपुट एक संख्या का एससीआईई चार मूल्य है, इसलिए घटाना 48।

नोट: यदि इनपुट एक प्रतीक था, तो हम $a+=48-48इसे प्रभावी ढंग से अनदेखा कर देते हैं। यदि ऐसा था 0, तो हमें $a+=58-48अपना +10 प्राप्त करना होगा

अंत में, ;$aबस प्रत्येक लूप के लिए हमारे अंतिम मूल्य पोस्ट को आउटपुट करता है

— sinusoid
स्रोत
आप कुछ बाइट्स बचा सकते हैं इसे ऑनलाइन आज़माएं!
— माज़ी
आह, हाँ, मेरे पास कुछ अतिरिक्त कोष्ठक थे और =वहाँ, इसे हल करने के अपने पिछले तरीकों से बचा था, पकड़ने के लिए धन्यवाद! हालांकि, मैंने पहले नहीं देखा है t*y, क्या आप बता सकते हैं कि स्ट्रिंग को वर्ण सरणी में विस्फोट करने के लिए क्यों काम करता है?
— साइनसॉइड
1
— mazzy
'<100 बाइट्स' पाने के लिए: इसे ऑनलाइन आज़माएं! :)
— mazzy
-fऔर के साथ अच्छा विचार है [0]।
— माज़ी
2

पॉवरशेल , 95 85 79 बाइट्स

nwellnhof के उत्तर से प्रेरित है ।

साइनसॉइड के उत्तर[0] से प्रेरित ।

$(switch -r($args|% t*y){\d{$_}0{10}[A-Y]{"$(.313*$_-18)"[0]}Z{9}})-join'+'|iex

इसे ऑनलाइन आज़माएं!

अनियंत्रित संस्करण:

$(
    switch -r($args|% toCharArray){
        \d    {$_}
        0     {10}
        [A-Y] {"$(.313*$_-18)"[0]}
        Z     {9}
    }
)-join '+'|Invoke-Expression
key .313*$_-18 "$(...)"[0]
--- ---------- -----------
  A      2.345 2
  B      2.658 2
  C      2.971 2
  D      3.284 3
  E      3.597 3
  F      3.910 3
  G      4.223 4
  H      4.536 4
  I      4.849 4
  J      5.162 5
  K      5.475 5
  L      5.788 5
  M      6.101 6
  N      6.414 6
  O      6.727 6
  P      7.040 7
  Q      7.353 7
  R      7.666 7
  S      7.979 7
  T      8.292 8
  U      8.605 8
  V      8.918 8
  W      9.231 9
  X      9.544 9
  Y      9.857 9
— Mazzy
स्रोत
1
दल बल! : डी
— साइनसोइड
0

पायथन 3 , 134 123 बाइट्स

f=lambda n:sum(map(int,n.translate(n.maketrans('ADGJMPTWBEHKNQUXCFILORVYSZ','23456789'*3+'79','()+-./ '))))+10*n.count('0')

इसे ऑनलाइन आज़माएं!

-11 बाइट्स @ dan04 की बदौलत

— आर्टेमिस फोवेल
स्रोत
1
अक्षरों को फिर से व्यवस्थित करके 'ADGJMPTWBEHKNQUXCFILNRVYSZ', आप संख्याओं की स्ट्रिंग को कम कर सकते हैं '23456789'*3+'79'।
— dan04
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.