स्क्रैबल स्कोरर

Question

चुनौती:

इनपुट (वैकल्पिक) के रूप में ऊपरी या निचले मामलों के पत्रों की एक स्ट्रिंग लें, और स्कोर की गणना करें कि स्ट्रिंग को अंग्रेजी में स्क्रैबल के खेल में मिलेगा ।

नियम:

प्रत्येक अक्षर का स्कोर इस प्रकार है (खेल के अन्य संस्करण होने पर भी इसका उपयोग करें):

1 point: E, A, I, O, N, R, T, L, S, U
2 points: D, G
3 points: B, C, M, P
4 points: F, H, V, W, Y
5 points: K
8 points: J, X
10 points: Q, Z

एक स्ट्रिंग का स्कोर इस्तेमाल किए गए अक्षरों में से प्रत्येक के स्कोर का योग है। आप मान सकते हैं कि आपके पास बहुत सारी टाइलें उपलब्ध हैं, इतने लंबे शब्द और एक ही अक्षर के कई शब्द वैध इनपुट हैं।

परीक्षण के मामलों:

ABC       ->    7
PPCG      ->   11
STEWIE    ->    9
UGPYKXQ   ->   33
FIZZBUZZ  ->   49
ABCDEFGHIJKLMNOPQRSTUVWXYZ  -> 87

प्रत्येक भाषा में सबसे छोटा उत्तर जीतता है! इनपुट और आउटपुट प्रारूप लचीले हैं, इसलिए यदि आप चाहें तो इनपुट को वर्णों (ऊपरी या निचले मामले) की एक सरणी के रूप में ले सकते हैं।

Comments

मैं एक MATLAB / ऑक्टेव समाधान देखने की उम्मीद कर रहा हूँ। मेरे सभी प्रयास बहुत लंबे थे ... = /

— स्टिव ग्रिफिन

मैं एक बीटनिक समाधान देखने की उम्मीद कर रहा हूं। क्यूज, आप जानते हैं, यह नौकरी के लिए सही उपकरण होगा।

— ग्यूसेप

@StewieGriffin क्या 85 बाइट्स की गिनती बहुत लंबी होती है?

— लुइस मेंडो

क्या Mathematica इसके लिए बिल्ट-इन नहीं है?

— सर्गियोल

@manassehkatz आपको इसे निश्चित रूप से देना चाहिए! मैं अत्यधिक अनुशंसा करता हूं कि आप सैंडबॉक्स में चुनौती को कुछ प्रतिक्रिया प्राप्त करें और इसे मुख्य साइट पर पोस्ट करने से पहले मदद करें। जटिल चुनौतियों को बिना किसी प्रतिक्रिया के सही तरीके से प्राप्त करना कठिन है।

— स्टीवी ग्रिफ़िन

Answer 1

sed 4.2.2 , 81

s/[QZ]/JD/g
s/[JX]/KB/g
s/K/FE/g
s/[FHVWY]/BE/g
s/[BCMP]/DE/g
s/[DG]/EE/g
s/./1/g

आउटपुट एकात्मक में है ।

प्रत्येक अक्षर को कम स्कोरिंग अक्षरों के संयोजन तक कम कर देता है जब तक कि सभी अक्षर 1-स्कोरर नहीं होते हैं। फिर 1एस के साथ उन लोगों की जगह एक unary गिनती देने के लिए।

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

Answer 2

हास्केल , 86 84 बाइट्स

f s=length s+sum[n|x<-s,(n,y)<-zip(9:7:[1..])$words"QZ JX DG BCMP FHVWY K",x`elem`y]

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

व्याख्या

अधिकांश अक्षर 1 का स्कोर देते हैं और इस प्रकार हमें इन पर नज़र रखने की आवश्यकता नहीं होती है, इसके बजाय हम प्रत्येक स्कोर को घटाते हैं (1 बाइट 10को भी बचाता है ) और फिर परिणामी स्कोर में स्ट्रिंग की लंबाई जोड़ते हैं।

-2 बाइट्स के लिए @nimi धन्यवाद (शब्दों को फिर से जोड़ना और [1..]इसके बजाय उपयोग करना [4,3..])!

Comments

zip[1..]$words"DG BCMP FHVWY K . . JX . QZ"बराबर लंबाई के साथ एक और विकल्प देता है

— 21

Answer 3

ऑक्टेव , 50 बाइट्स

@(t)'				'/3*sum(65:90==t')'

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

चुनौती स्वीकार की गई। स्पष्टीकरण:

@(t)             % Define anonymous function taking a single argument t.
    ' ... '/3    % Row vector with letter scores. Corresponds to char([1 3 3 2 ...]*3). 
                 % The factor 3 was necessary to avoid a newline.

*                % Dot product (yes, * is dot product, .* is not. Go figure). Equivalent to sum of element-wise products.
     65:90       % Alphabet
          ==t'   % Broadcast equality with input string.
 sum(         )  % Sum this matrix. Gives the count of each letter in the alphabet
               ' % Transpose into column vector for dot product

Comments

बहुत चालाक! Unprintables का उपयोग करना एक अच्छा स्पर्श था! :)

— स्टीवी ग्रिफ़िन

@StewieGriffin इसकी तुलना में केवल एक बाइट है, -47लेकिन यह आपके लिए कोड-गोल्फिंग है!

— सैनचाइज़्स

आह। अच्छी तरह से और सही मायने में बाहर गोल्फ। मुझे महसूस नहीं हुआ था कि आप ==उस तरह का इस्तेमाल ऑक्टेव में कर सकते हैं । MATLAB में काम नहीं करता है। जानकार अच्छा लगा।

— टॉम कारपेंटर

@TomCarpenter मैं घाव में किसी भी नमक को रगड़ने का मतलब नहीं है, लेकिन यह (साथ bsxfun) करने का 'पुराना' तरीका 61 बाइट्स से भी छोटा है: इसे ऑनलाइन आज़माएं!

— Sanchises

वॉट 50 बाइट्स मैं भी नहीं

— लुइस मेंडो

Answer 4

बीटनिक , 733 बाइट्स

चूंकि यह वास्तव में किया जाना था, यहाँ यह है। यह डिबग करने के लिए वास्तव में बुरा था और कुछ चुनौतियां प्रदान करता था।

इनपुट केवल बड़े अक्षर होना चाहिए। आउटपुट एकात्मक है (आशा है कि ठीक है?)

J K ZZZZZZK Z ZD ZB ZZZZZZZZZZZZZZZZZA K A Z ZD ZB ZZZZZZZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZZZKD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZZD K A Z ZD ZB ZZZZZZZZZZZZ K A Z ZD ZB ZZZZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZKA K A Z ZD ZB ZZZZZZZZZKF K A Z ZD ZB ZZZZZZZZZZK K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZZB K A Z ZD ZB ZZZZZZZZKD K A Z ZD ZB ZZZZZZZK K A Z ZD ZB ZZZZKB K A Z ZD ZB ZZZZZZKF K A Z ZD ZB ZZZZZZB K A Z ZD ZB ZZZZZFB K A Z ZD ZB ZZZZZA K A Z ZD ZB ZZZAK K A Z ZD ZB ZZZ K A Z ZD ZB ZD K A Z ZD ZB ZKB K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K ZZZZKF KF K A ZKA ZZZZZZZZZZZZZZZZZZY

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

सामान्य प्रक्रिया है:

• इनपुट से चरित्र प्राप्त करें
• घटाना ६५
• जाँच करें कि परिणाम 0 है
  • यदि 0 शब्दों की मात्रा निर्दिष्ट करें।
  • अन्यथा 1 घटाएं और चेक दोहराएं।
• छलांग लक्ष्य धक्का प्रिंट संचालन हैं कार्यक्रम के शुरुआत में एक पाश वापस होना चाहिए।

एक त्रुटि के साथ समाप्त होता है।

एक अधिक पूर्ण विवरण:

J K ZZZZZZK Z ZD               # Get input and subtract 65
ZB ZZZZZZZZZZZZZZZZZA K A Z ZD # Character A - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZKF K A Z ZD  # Character B - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZB K A Z ZD   # Character C - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZZ K A Z ZD    # Character D - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZZKD K A Z ZD   # Character E - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character F - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZZD K A Z ZD     # Character G - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZ K A Z ZD       # Character H - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZZZB K A Z ZD      # Character I - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKA K A Z ZD        # Character J - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZKF K A Z ZD        # Character K - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZZK K A Z ZD        # Character L - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character M - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZZB K A Z ZD         # Character N - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZZKD K A Z ZD         # Character O - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZZK K A Z ZD           # Character P - if 0 jump to print, otherwise subtract 1
ZB ZZZZKB K A Z ZD             # Character Q - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZKF K A Z ZD           # Character R - if 0 jump to print, otherwise subtract 1
ZB ZZZZZZB K A Z ZD            # Character S - if 0 jump to print, otherwise subtract 1
ZB ZZZZZFB K A Z ZD            # Character T - if 0 jump to print, otherwise subtract 1
ZB ZZZZZA K A Z ZD             # Character U - if 0 jump to print, otherwise subtract 1
ZB ZZZAK K A Z ZD              # Character V - if 0 jump to print, otherwise subtract 1
ZB ZZZ K A Z ZD                # Character W - if 0 jump to print, otherwise subtract 1
ZB ZD K A Z ZD                 # Character X - if 0 jump to print, otherwise subtract 1
ZB ZKB                         # Character Y - if 0 jump to print, otherwise subtract 1
K ZZZZKF KF                    # Jump Point for print 1111111111
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111111
K ZZZZKF KF                    #
K ZZZZKF KF                    #
K ZZZZKF KF                    # Jump Point for print 11111
K ZZZZKF KF                    # Jump Point for print 1111
K ZZZZKF KF                    # Jump Point for print 111
K ZZZZKF KF                    # Jump Point for print 11
K ZZZZKF KF                    # Jump Point for print 1
K A ZKA ZZZZZZZZZZZZZZZZZZAAAA # Jump back to start

Comments

Golfed।

— jimmy23013

@ jimmy23013 बहुत अच्छा, आपको एक पोस्ट करना चाहिए।

— मिकट

Answer 5

ब्रेन-फ्लैक , 210, 204, 198, 184 , 170 बाइट्स

({<([{}]<>(({}{}))(([][][][][])<((([]())<([][])>))((((()))))>)[](((()()())<((()))>)((())()()()()))((())()()())((()())()())[]((((())())()))(())){({}<{}>())}>{}{}<{{}}><>})

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

14 बाइट बचाने के लिए @JoKing को धन्यवाद!

पठनीय संस्करण:

({              # For each character

                # Push array of letter scores
                # Also adjust character to 1-indexing
        <([{}]<>
        (({}{}))    # Push 2 0s
        (([][][][][])   # 10
        <((([]())   # 4
        <([][])>    # 8
        ))      # 4,4
        ((((()))))> # 1,1,1,1
        )       # 10
        []      # Add 12 to difference
        (((()()())  # 3
        <((()))>    # 1,1
        )       # 3
        ((())()()()())) # 1, 5
        ((())()()())    # 1, 4
        ((()())()())    # 2, 4
        []      # Add 22 to difference
        ((((())())()))  # 1,2,3
        (())        # 1
        )   # Push 65-char

        {({}<{}>())} # Index character into score array
        >
        {}{}         # Add score to running total
        <{{}}><>     # Clear the stack

})               # Implicit print of total score

Comments

170 बाइट्स

— जो किंग

'पठनीय' की दी गई परिभाषा के लिए :)

— मैट लेसी

मैंने कोशिश करने और स्पष्टीकरण को स्पष्ट करने के लिए एक संपादन किया, यदि आपको कोई समस्या मिलती है तो रोलबैक करने के लिए स्वतंत्र महसूस करें।

— कामिल दकरी २४'१ari

Answer 6

पायथ, 40 बाइट्स

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1

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

व्याख्या

sm+2x.e}dbc." zØÍ jÙ¹>;%OG5§"\ 1
 m                              Q  For each character in the (implicit) input...
    x.e  b                     1   ... find the first index in...
          c." zØÍ jÙ¹>;%OG5§"\     ['dg','bcmp','fhvwy','k','','','jx','','qz']
       }d                          ... containing the character...
  +2                               ... 2-indexed.
s                                  Take the sum.

Answer 7

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

lambda x:sum(map(('ABCEIKLMNOPRSTU'+'BCDGMPQZ'*2+'FHJJKQQVWXXYZZ'*4).count,x))

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

छोटा संस्करण, डैनियलइंडी के जवाब का बंदरगाह , 71 70 बाइट्स

^{-1 सनी पटेल को धन्यवाद}

lambda x:sum(int('02210313074020029000033739'[ord(c)-65])+1for c in x)

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

Answer 8

जावास्क्रिप्ट (Node.js) , 71 66 63 62 बाइट्स

• @ अर्नुलद भयानक के रूप में हमेशा 7 बाइट्स को कम करता है
• 1 बाइट द्वारा rducing के लिए l4m2 के लिए धन्यवाद

s=>Buffer(s).map(x=>s="02210313074020029000033739"[x-65]-~s)|s

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

Answer 9

जावा 8, 75 71 70 बाइट्स

s->s.chars().map(c->"\n\n".charAt(c-65)).sum()

-1 बाइट "02210313074020029000033739".charAt(c-65)-47को unprintables (और दो \n) में बदलकर ताकि -47हटाया जा सके। @ सेंचुरीज़ ऑक्टेव उत्तर से प्रेरित ।

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

s->          // Method with String parameter and integer return-type
  s.chars()  //  Loop over the characters as IntStream
   .map(c->"\n\n".charAt(c-65))
             //   Convert the character to its value
   .sum()    //   And sum it all together

Answer 10

ऑक्टेव / MATLAB, 85 बाइट्स

@(x)sum([1:4 7 9]*any(reshape(char(strsplit('DG BCMP FHVWY K JX QZ')),6,1,5)==x,3)+1)

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

Comments

मेरे प्रयासों से बेहतर :-) अब भी इससे पहले कि मैं इसे आजमाने से पहले सोचा था कि इससे भी अधिक ... आप इसे करने के लिए एक बहुत अलग दृष्टिकोण था!

— स्टीवी ग्रिफ़िन

Answer 11

जेली , 19 बाइट्स

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S

एक मोनडिक लिंक जो ऊपरी मामले के पात्रों की एक सूची को स्वीकार करता है जो पूर्णांक देता है

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें ।

कैसे?

Oị“ÆẠḃbṂƬɠF#ṁ²’ḃ⁵¤S - Link: list of characters
O                   - ordinals ('A'->65, B->66...)
                 ¤  - nilad followed by link(s) as a nilad:
  “ÆẠḃbṂƬɠF#ṁ²’     -   literal 14011114485013321424185131
                ⁵   -   literal 10
               ḃ    -   bijective-base = [1,3,10,1,1,1,1,4,4,8,4,10,1,3,3,2,1,4,2,4,1,8,5,1,3,1]
 ị                  - index into (1-based & modular) (vectorises)
                    -  i.e. mapping from: O P  Q R S T U V W X Y  Z A B C D E F G H I J K L M N)
                  S - sum

Answer 12

आर , 90 63 बाइट्स

function(W,u=utf8ToInt)sum(u('

')[u(W)-64])

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

एक बड़े स्ट्रिंग के रूप में इनपुट लेता है। आर मुद्दों के बिना unprintables और बहुपरत तारों को संभालता है, इसलिए यह अच्छा है। अब हम लगभग दो बार बाहरी पैकेज कर रहे हैं!

और क्योंकि CRAN में बहुत सारे यादृच्छिक उपहार हैं:

आर + स्क्रैबलस्कोर 31 बाइट्स

ScrabbleScore::sws(scan(,""),F)

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

अफसोस की बात है swsकि डिफ़ॉल्ट रूप से वैधता के लिए जाँच की जाती है।

Comments

स्कोर सूची के साथ एक नाटक था और एक जोड़े को

— छाँटा था

@ मिक्की अच्छा! मैं unprintables के साथ चारों ओर खेला और के utf8ToIntबजाय फिर से उपयोग कर रहा है matchऔर कुछ और नीचे पाने में कामयाब रहे!

— ग्यूसेप

Answer 13

इमोजीकोड , 358 बाइट्स

🐖🔥➡️🔡🍇🍮s 0🔂l🍡🐕🍇🍮s➕s🍺🐽🍯🔤a🔤1🔤e🔤1🔤i🔤1🔤l🔤1🔤n🔤1🔤o🔤1🔤r🔤1🔤s🔤1🔤t🔤1🔤u🔤1🔤d🔤2🔤g🔤2🔤b🔤3🔤c🔤3🔤m🔤3🔤p🔤3🔤f🔤4🔤h🔤4🔤v🔤4🔤w🔤4🔤y🔤4🔤k🔤5🔤j🔤8🔤x🔤8🔤q🔤10🔤z🔤10🍆🔡l🍉🍎🔡s 10🍉

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

स्पष्टीकरण:

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

🐋🔡🍇      👴 define a class that takes a string
 🐖🔥➡️🔡🍇    👴 define a method that returns a string
  🍦values🍯    👴 create int dictionary
   🔤a🔤1 🔤e🔤1 🔤i🔤1 🔤l🔤1 🔤n🔤1 🔤o🔤1 🔤r🔤1 🔤s🔤1 🔤t🔤1 🔤u🔤1 🔤d🔤2 🔤g🔤2
   🔤b🔤3 🔤c🔤3 🔤m🔤3 🔤p🔤3 🔤f🔤4 🔤h🔤4 🔤v🔤4 🔤w🔤4 🔤y🔤4 🔤k🔤5 🔤j🔤8 🔤x🔤8
   🔤q🔤10 🔤z🔤10
  🍆        👴 ^ dictionary contains letters(keys) and their numerical values

  🍮score 0                         👴 declare 'score' variable and set to 0
   🍦iterator🍡🐕                     👴 transform input string to iterator
    🔂letter iterator🍇                👴 iterate over each byte in input string
     🍮score➕score 🍺🐽values 🔡letter   👴 add value of each letter to score
   🍉
  🍎🔡score 10    👴 return the score as a string
 🍉
🍉

🏁🍇          👴 begin the program here
 😀🔥🔤abc🔤    👴 call scoring method and print the score
 😀🔥🔤ppcg🔤    👴 repeat with other test cases
 😀🔥🔤stewie🔤
 😀🔥🔤fizzbuzz🔤
 😀🔥🔤abcdefghijklmnopqrstuvwxyz🔤
🍉

Comments

ouch ... माई आईज़ ... क्या गोल्फ के लिए कोई विकल्प है। कुछ विशिष्ट लैंगेज को छिपाने के लिए? ^ ^

— ओलिवियर दुलक

@OlivierDulac ब्राउज़र को विशेष रूप से इमोजी को प्रस्तुत करने से रोकने का एक तरीका है। उनके पास मानक यूनिकोड काले और सफेद वर्ण हैं जो उनसे जुड़े हैं।

— mbomb007

Answer 14

05AB1E , 21 बाइट्स

वर्णों की एक निचली सूची के रूप में इनपुट लेता है।

•_JÊ¿ùã$Ƶ½œM•11вAIkèO

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

Answer 15

ऑक्टेव , 73 बाइट्स

@(x)sum('09977433333222211'(([~,y]=ismember(x,'QZJXKFHVWYBCMPDG'))+1)-47)

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

लुकअप स्ट्रिंग ismemberमें प्रत्येक चरित्र को इनपुट स्ट्रीम में मैप करने के लिए इसका उपयोग xइंडेक्स पर होता है 'QZJXKFHVWYBCMPDG'। पाया गया कोई भी तत्व 0 के सूचकांक में मैप नहीं किया जाएगा (इसमें 1-बिंदु वर्ण शामिल होंगे)।

अगला हम 0 को मान्य 1-इंडेक्स संदर्भ बनाने के लिए इंडेक्स में 1 जोड़ते हैं, और स्ट्रिंग में देखते हैं '09977433333222211'। यह पहले लुकअप स्ट्रिंग की तुलना में एक तत्व लंबा है। अंक मूल तत्व में प्रत्येक तत्व के बिंदु मान का प्रतिनिधित्व करते हैं, शून्य से 1, अतिरिक्त तत्व के साथ '0' में हैbeginning ।

अंत में परिणामी स्ट्रिंग को घटाकर पूर्णांक में बदल दिया जाता है 47( '0'-1), प्रत्येक अक्षर के लिए बिंदु मान की पैदावार, और सभी बिंदु मान तब अभिव्यक्त किए जाते हैं।

Comments

बहुत चालाक! :)

— स्टीवी ग्रिफिन

Answer 16

सी ++, 95 बाइट्स

char*m="02210313074020029000033739";
int f(char*p){int n=0;while(*p)n+=m[*p++-65]-47;return n;}

इसे ऑनलाइन आज़माएं (TIO लिंक क्षमा नहीं)

स्पष्टीकरण:

• घोषणा m, क्रम में प्रत्येक अक्षर के मानों की एक सरणी, शून्य से 1. शून्य 1 क्यू और जेड के कारण है: मैं वहां दो अंकों की संख्या नहीं रख सकता
• स्ट्रिंग के माध्यम से Iterates pजब तक हम अशक्त चरित्र के लिए नहीं मिलता है, और संख्या का स्कोर जोड़ता है ( *pहमें पत्र देता है, और -65इसलिए हम सरणी को ठीक से अनुक्रमित कर सकते हैं)। चूँकि mयह एक शून्य में char*परिवर्तित होता है charइसलिए हम 48इसे 0 पर लाते हैं, लेकिन जोड़ते हैं 1क्योंकि mप्रत्येक वर्ण के लिए एक अंक कम घोषित किया जाता है।

_{मैं यहाँ एक शौकीन चावला पोस्टर नहीं हूँ इसलिए मुझे आशा है कि मैंने इसे सही ढंग से किया है। मेरा मानना ​​है कि वे nमान की छपाई के रूप में मायने रखते हैं, और यह कि एक समारोह की घोषणा करना ठीक है।}

Comments

बहुत अच्छा! एकमात्र बाइट जो आप बचा सकते हैं, वह है नई लाइन: इसे ऑनलाइन आज़माएं!

— २१:३

Answer 17

हास्केल , 66 बाइट्स

sum.map(\c->1+read["02210313074020029000033739"!!(fromEnum c-65)])

इसे ऑनलाइन आज़माएं! डैनियलइंडीज जावास्क्रिप्ट जवाब के रूप में एक ही दृष्टिकोण ।

---

हास्केल , 82 81 बाइट्स

sum.map(\c->1+sum(read.pure<$>lookup c(zip"DGBCMPFHVWYKJXQZ""1122223333347799")))

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

Answer 18

पॉवरशेल , 60 बाइट्स

$args|% t*y|%{$s+='02210313074020029000033739'[$_-65]-47}
$s

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

Answer 19

जाप , 36 बाइट्स

£2+`dg
bcmp
fhvwy
k


jx

qz`·bøX
x

एक लोअरकेस स्ट्रिंग के रूप में इनपुट लेता है, एक नंबर देता है।
संक्षिप्त विवरण:

£2+`dg
¬       // Split the input into chars,
 £      // then map over each char, returning
  2+`dg // 2 plus

qz`·bøX
    bøX // the char's index in
qz`·    // the hardcoded string split by newlines.
x       // And finally sum the whole thing.

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

Answer 20

रूबी , 60 बाइट्स

->s{s.sum{|c|"BDDCBECEBIFBDBBDKBBBBEEIEK"[c.ord-65].ord-65}}

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

एक लैम्ब्डा, (अपरकेस) वर्णों की एक सरणी के रूप में इनपुट स्वीकार करना और पूर्णांक वापस करना।

Answer 21

पर्ल 5 -pF , 50 बाइट्स

_1DG2BCMP3FHVWY4K7JX9QZ=~/\d\D*$_/,$\+=1+$&for@F}{

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

Answer 22

गॉर्थ , 109 बाइट्स

: V s" 1332142418513113:11114484:" ; : C 0 NAME 0 DO DUP C@ 65 - V DROP + C@ 48 - ROT + SWAP 1+ LOOP DROP . ;

इनपुट अपरकेस होना चाहिए:
C PPCG 11 OK

पठनीय

\ String used as table with values for each letter in the alphabet
\ : follows 9 in the ASCII-table
: V
   s" 1332142418513113:11114484:"
;

: C
   0                   \ Initialize sum        ( sum               )
   NAME                \ Get the string        ( sum  c-addr count )
   0 DO                \ Start of loop         ( sum  c-addr       )
      DUP C@           \ Get letter            ( sum  c-addr char  )
      65 -             \ Calculate table index ( sum  c-addr index )
      V DROP + C@      \ Get table entry       ( sum  c-addr entry )
      48 -             \ Calculate entry value ( sum  c-addr value )
      ROT + SWAP       \ Update sum            ( sum' c-addr       )
      1+               \ Next character        ( sum' c-addr'      )
   LOOP
   DROP .              \ Drop c-addr and print result
;

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

Answer 23

पर्ल 6 , 52 बाइट्स

{TR/A..Z/02210313074020029000033739/.comb.sum+.ords}

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

प्रत्येक वर्ण को एक अंक में मैप करता है, और उन्हें रकम देता है। और प्रत्येक वर्ण के लिए 1 जोड़ता है क्योंकि यूनिकोड बाइट्स के बिना अंक 10 नहीं है।

Answer 24

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

T`BCDGJKMPQXZF\HVWY`221174229793
.
$*..
.

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं। व्याख्या: हास्केल उत्तर की तरह, nontrivial अक्षरों का उनके अंक से 1 कम अनुवाद किया जाता है, और 1 को बाद में जोड़ा जाता है जब वर्णों को एकात्मक में बदल दिया जाता है। FHVWYअंतिम डालने से उन सभी को 3 + 1 के स्कोर पर मैप करने की अनुमति मिलती है।

Answer 25

सी (जीसीसी), 78 72 बाइट्स

i;f(char*s){for(i=0;*s;)i+="\n\n"[*s++-65];s=i;}

उस तार में वास्तव में 26 अक्षर हैं। कोड को ठीक से रेंडर करके देखें और उसे यहां चलाएं ।

6 बाइट्स के लिए गैस्ट्रोपनर के लिए धन्यवाद ।

Ungolfed संस्करण:

i; // declare a variable to store the score; it is implicitly of type int
f(char* s) { // function taking a string as argument and implicitly returning an int
    for(i = 0; // initialize the score to 0
        *s; ) // iterate over the string until we hit terminating NUL byte
        i += "\n\n"[*s++ - 65]; // this is a 26-char string containing the ASCII equivalent of each numeric scrabble value; 65 is ASCII code for 'A', mapping the alphabet onto the string
    s = i; // implicitly return the score
}

Answer 26

एक्सेल, 91 बाइट्स

{=LEN(A1)+SUM(0+("0"&MID("02210313074020029000033739",CODE(MID(A1,ROW(A:A),1)&"z")-64,1)))}

स्पष्टीकरण:

• इनपुट सेल में है A1
• सूत्र को Ctrl+ Shift+ के साथ एक सरणी सूत्र के रूप में दर्ज किया जाना चाहिए Enter, जो घुंघराले कोष्ठक जोड़ता है{ } को दोनों सिरों पर है।
• MID(A1,ROW(A:A),1) बदले में प्रत्येक चरित्र को बाहर निकालता है (और बहुत सारे खाली मान भी, क्योंकि यह शीट में पंक्तियों के रूप में कई मूल्यों को वापस करने जा रहा है)
• CODE(MID(~)&"z")प्रत्येक वर्ण के लिए ASCII मान निकालता है। &"z"एक संलग्न कर देता है zके अंत तक MID()क्योंकि परिणाम CODE()खाली आदानों की तरह नहीं है। zहालाँकि, ASCII का मूल्य प्रत्येक कैपिटल लेटर से अधिक है, लेकिन बाद में इसे प्रभावी रूप से अनदेखा कर दिया जाता है।
• MID("02210313074020029000033739",CODE(~)-64,1) स्कोर स्ट्रिंग से एक अक्षर खींचता है इसके ASCII मूल्य के आधार पर 64 से समायोजित किया गया है ताकि पत्र 65-90 के बजाय 1-26 चलें।
• "0"&MID(~)MID()परिणाम के लिए एक शून्य प्रीपेन्ड करता है क्योंकि एक्सेल आपको खाली तारों के साथ गणित नहीं करने देगा, जिनमें से कई होंगे।
• 0+("0"&MID(~)) उन सभी तारों को संख्याओं में बदल देता है।
• SUM(0+("0"&MID(~))) उन सभी तारों को जोड़ता है जो अब संख्याएं हैं।
• LEN(A1)+SUM(~)इनपुट की लंबाई को जोड़ देता है क्योंकि स्कोर स्ट्रिंग ( 02210313074020029000033739) में सभी मान एक-एक करके नीचे समायोजित किए गए थे, इसलिए वे सभी एक-एक अंक लंबे होंगे।

---

Google शीट्स में एक बहुत ही समान समाधान है, लेकिन यह 97 बाइट्स में आता है क्योंकि इससे ArrayFromula()अधिक लंबा है {}(लेकिन कम से कम यह संभाल सकता है 0 + "" = 0)।

=Len(A1)+ArrayFormula(Sum(0+Mid("02210313074020029000033739",Code(Mid(A1,Row(A:A),1)&"z")-64,1)))

Comments

बहुत बढ़िया। मेरे पास 26 का उपयोग करके एक एक्सेल समाधान हैSUBSTITUTE() , एक भारी 527 बाइट्स में आ रहा है।

— वेर्निस्क

Answer 27

वोल्फ्राम भाषा (गणितज्ञ) , 74 बाइट्स

बेशक वुल्फराम | अल्फा स्क्रैबल स्कोरिंग का समर्थन करता है! यह एक अनाम फ़ंक्शन है।

Plus@@(First[WolframAlpha["Scrabble "<>##,"NumberData"]]&/@Characters[#])&

यह TIO पर काम नहीं करता है।

चलाने के लिए, यहां जाएं , नीचे स्क्रॉल करें और "नया नोटबुक बनाएं" पर क्लिक करें। नोटबुक में उपयोग करने के लिए कोड इस TIO प्रोग्राम में है ताकि आप इसे कॉपी कर सकें। प्रत्येक फ़ंक्शन कॉल को अपने कोड ब्लॉक में पेस्ट करें। यदि आप किसी एकल ब्लॉक में बहुत अधिक भाग लेते हैं, तो निष्पादन पूर्ण नहीं होगा।

ध्यान दें कि WolframAlphaइंटरनेट का उपयोग करके एक अनुरोध भेजता है। हालांकि पीपीसीजी पर अन्य उत्तर हैं जो इसका उपयोग करते हैं, मैंने सोचा कि आपको पता होना चाहिए।

यह प्रोग्राम नीचे दिए गए छोटे फ़ंक्शन का उपयोग करता है, लेकिन इसे इनपुट के प्रत्येक अलग-अलग चरित्र पर कॉल करता है ( हर बार वुल्फराम को एक अलग कॉल भेजना । अल्फा हर बार!)

---

यह केवल 15 की लंबाई तक इनपुट के लिए काम करता है, एक स्क्रैबल बोर्ड की चौड़ाई। (49 बाइट्स)

First[WolframAlpha["Scrabble "<>#,"NumberData"]]&

---

ऊपर जैसा ही है, लेकिन परिणाम को एक बॉक्स में प्रदर्शित करेगा, साथ ही इनपुट एक वैध स्क्रैबल शब्द है। (45 बाइट्स)

First[WolframAlpha["Scrabble "<>#,"Result"]]&

Answer 28

सी # (.NET कोर) , 50 + 18 = 68 बाइट्स

s=>s.Sum(c=>"02210313074020029000033739"[c-65]-47)

+18 बाइट्स के लिए using System.Linq;

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

Answer 29

के (ओके) , 60 38 बाइट्स

उपाय:

+/1+.:'"02210313074020029000033739"65!

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

स्पष्टीकरण:

अंकों में सूचकांक, परिणाम का योग।

+/1+.:'"02210313074020029000033739"65! / the solution
                                   65! / input modulo 65 to get position in A-Z
       "02210313074020029000033739"    / index into the scores (1 point lower)
    .:'                                / value (.:) each (') to convert to ints
  1+                                   / increase by 1
+/                                     / sum up

Answer 30

जाप -x, 43 39 35 30 बाइट्स

£2+`dglbcÛghvwylk¥ljx¥qz`qÊaøX

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

35 बाइट समाधान:

¬£Ò('0+#Ý03#740#È29e4+33739 g65nXc

इसे ऑनलाइन चलाएं