एक स्ट्रिंग का स्क्रैबल स्कोर और वैधता निर्धारित करें

Question

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

यदि आप स्क्रैबल नहीं खेलना जानते हैं: तो आपके पास उन पर छपे विभिन्न अक्षरों ए-जेड के साथ 100 टाइलें हैं, साथ ही दो वाइल्डकार्ड हैं जो किसी भी पत्र का प्रतिनिधित्व कर सकते हैं। प्रत्येक अक्षर में कुछ निश्चित अंक होते हैं, और प्रत्येक टाइल (लेकिन जरूरी नहीं कि शब्द) केवल एक बार उपयोग किया जा सकता है। जब कोई शब्द खेला जाता है, तो उपयोग की जाने वाली प्रत्येक टाइल का बिंदु मान ऊपर जोड़ा जाता है, जो स्कोर बन जाता है। चूंकि सीमित संख्या में पत्र उपलब्ध हैं, एक शब्द में केवल एक निश्चित अक्षर हो सकता है क्योंकि उस पत्र में टाइल्स + किसी अप्रयुक्त वाइल्डकार्ड होते हैं। स्क्रैबल बोर्ड 15 × 15 सेल है, इसलिए शब्द 2 और 15 अक्षरों के बीच लंबा होना चाहिए।

अंग्रेजी संस्करण में प्रत्येक अक्षर की मात्रा और स्कोर की सूची के लिए, नीचे देखें या http://boardgames.about.com/od/scrabble/a/tile_distribute.htm ( संग्रह )।

पत्र मात्रा अंक पत्र मात्रा अंक
------------------- -------------------
ए ९ १ ओ 9 १
बी 2 3 पी 2 3
सी 2 3 क्यू 1 10
डी ४ २ आर ६ १
ई १२ १ एस ४ १
एफ 2 4 टी 6 1
जी ३ २ यू ४ १
एच 2 4 वी 2 4
मैं ९ १ डब्ल्यू २ ४
जे १ J एक्स १ १ 8
के 1 5 वाई 2 4
एल 4 1 जेड 1 10
एम २ ३ [जंगली] २ ०
एन ६ १

आगे के नियम

• कार्यक्रम एसटीडीआईएन या इस तरह से इनपुट का एक ही तार ले जाएगा।
• इनपुट में हमेशा केवल बड़े अक्षर होंगे।
• यदि स्ट्रिंग में एक अक्षर की अधिक प्रतियां हैं, तो उस पत्र के लिए अप्रयुक्त वाइल्डकार्ड या टाइलें हैं या स्ट्रिंग की लंबाई 2 और 15 के बीच नहीं है, तो कार्यक्रम को आउटपुट करना चाहिए Invalid।
• अन्यथा, स्कोर को ऊपर दिए गए चार्ट और आउटपुट से डेटा का उपयोग करके जोड़ा जाना चाहिए।
• जब तक आवश्यक न हो वाइल्डकार्ड का उपयोग न करें।
• बोनस के बारे में चिंता न करें जैसे कि डबल शब्द स्कोर या क्या स्ट्रिंग एक वास्तविक शब्द है।
• कार्यक्रम STDOUT या जैसे के माध्यम से परिणाम का उत्पादन करेगा।
• डिफ़ॉल्ट रूप से मना किए गए लूपोल्स की अनुमति नहीं है।
• बाहरी स्रोत जैसे कि वेबसाइट, साथ ही किसी भी लाइब्रेरी, एपीआई, फ़ंक्शंस या इस तरह का उपयोग करना कि स्क्रैबल स्कोर या उचित मात्रा की गणना नहीं की जाती है।
• यह कोड-गोल्फ है , इसलिए सबसे कम बाइट जीतती है।

पूर्वाभ्यास

Input: CODEGOLF
C -> 3, O -> 1, D -> 2, E -> 1, G -> 2, O -> 1, L -> 1, F -> 4
3 + 1 + 2 + 1 + 2 + 1 + 1 + 4 = 15
Output: 15

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

इनपुट आउटपुट
------------------------
SCRABBLE 14
जाज १ ९
STACKEXCHANGE 32
XYWFHQYVZVJKHFW 81
PIZZAZZ अमान्य है
KIXOKEJAJAX अमान्य है
MISUNDERSTANDING अमान्य है

Comments

एक वैध शब्द के लिए एक परीक्षण केस जोड़ना चाह सकते हैं जिसमें वाइल्ड कार्ड का उपयोग किया जाता है (जैसे। जाज = 19, 29 नहीं)

— अलकनजा

तुम्हें पता है, यह चुनौती इतनी अधिक दुष्ट होगी यदि इसमें ऐसी भाषा शामिल हो, जिसकी स्क्रैबल टाइल्स को एक ही चरित्र के साथ प्रस्तुत नहीं किया जा सकता है, जैसे कि स्पेनिश, बास्क, हंगेरियन, तुवन या वेल्श।

— user0721090601

क्या विशेष रूप से "अमान्य" आउटपुट के लिए उत्तर आवश्यक हैं, या क्या हम किसी भी व्यवहार को तब तक चुन सकते हैं जब तक कि यह स्पष्ट रूप से एक अंक न हो? उदाहरण के लिए -1,?

— कामिल दकरी

@KamilDrakari यह बिल्कुल कहना चाहिए Invalid।

— NinjaBearMonkey

Answer 1

पर्ल 5 228 205 186 184 178 177 153 150 149 142 137 135

पर्ल-ई के साथ भागो।

golfed:

$_=<>;@a=@b=map-ord,'            0 0@0 H        ``'=~/./g;say s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

यह समाधान कुछ गैर-मुद्रण योग्य वर्णों का उपयोग करता है, इसलिए नीचे एक हेक्सडंप प्रदान किया गया है:

00000000: 245f 3d3c 3e3b 4061 3d40 623d 6d61 702d  $_=<>;@a=@b=map-
00000010: 6f72 642c 2703 0904 0909 2030 2030 030e  ord,'..... 0 0..
00000020: 4030 0e20 0704 4809 1809 601d 0e0e 6027  @0. ..H...`...`'
00000030: 3d7e 2f2e 2f67 3b73 6179 2073 212e 2128  =~/./g;say s!.!(
00000040: 2461 5b24 713d 3634 2d6f 7264 2426 5d2b  $a[$q=64-ord$&]+
00000050: 3d38 293c 383f 242d 2b3d 312d 3239 2f24  =8)<8?$-+=1-29/$
00000060: 625b 2471 5d3a 2b2b 246a 2167 657e 7e5b  b[$q]:++$j!ge~~[
00000070: 322e 2e31 355d 2626 246a 3c33 3f24 2d3a  2..15]&&$j<3?$-:
00000080: 496e 7661 6c69 64                        Invalid

वैकल्पिक रूप से, Ctrl + Key का उपयोग कर:

$_=<>;@a=@b=map-ord,'^C^I^D^I^I 0 0^C^N@0^N ^G^DH^I^X^I`^]^N^N`'=~/./g;print s!.!($a[$q=64-ord$&]+=8)<8?$-+=1-29/$b[$q]:++$j!ge~~[2..15]&&$j<3?$-:Invalid

Ungolfed + टिप्पणी की:

# Read in input
$_=<>;
# @a and @b: represents approximately 8x the number of tiles (when rounded up). The 
#   non-multiple-of-8 values distinguish tiles that are given equally, but are worth
#  different values
@b=@a=map-ord,"...."~=/./g;
# above is equivalent to
# @a=@b=(-03,-09,-04,-09,-09,-32,-48,-32,-48,-03,-14,-64,-48,-14,-32,-07,-04,-72,-09,-24,-09,-96,-29,-14,-14,-96);
say
    # for each character
    s!.!
        # $q: A->-1, B->-2, etc.
        # decrement number of $q tiles, add points if needed, otherwise
        #    increment j, which counts number of wilds used
        # truncate(1-29/b[q]): decimal values were chosen specifically
        #    for this to return the point value. b[q] is the number of tiles
        #    of the qth letter after a originally given.
        #  $- contains the score, is initially zero (if in a one line program, 
        #   as the golfed version is), and is always an integer
        ($a[$q=64-ord$&]+=8)<8 ? $- += 1 - 29/$b[$q] : ++$j
    # s returns length, check if between 2 and 15
    !ge ~~ [2..15]
    # make sure less than 3 negative tiles (aka wilds) 
    && $j < 3 ?
        # print score
        $-
    # or invalid
    : Invalid

Comments

आप कुछ रचनात्मक हेरफेर के साथ उन सरणियों में से कम से कम 20 बाइट्स को निचोड़ सकते हैं

— Spur

गह, हमेशा मुझसे एक कदम आगे। :) एक उत्थान है।

— Alconja

यह दिलचस्प रहा है, हमारे स्कोर पूरे रास्ते इतने करीब रहे हैं। +1।

— लेवल रिवर सेंट

क्या यह काम करता है -M5.010(0 का दंड क्योंकि यह भाषा के एक संस्करण का उपयोग करने के लिए निर्दिष्ट करता है) बजाय -e(1 का दंड)? आप तर्कों में एक बाइट को बचाने में सक्षम हो सकते हैं।

Answer 2

सी, रेव 2, 151 145 138

@ Bebe की टिप्पणी में 159-बाइट कोड से प्रेरित होकर, मैंने एक और 8 14 21 अक्षर बाहर निकाले:

लंबाई काउंटर को फिर से व्यवस्थित करके 4 बाइट्स बचाए गए i। यह 1 से शुरू होता है (यह मानते हुए कि कार्यक्रम में कोई तर्क नहीं है) तब हर बार 4 से गुणा करके एक पत्र पढ़ा जाता है। जब शब्द की लंबाई 15 से अधिक होती है, तो यह शून्य से अधिक हो जाता है, इसलिए यह जांचने के लिए कि क्या शब्द की लंबाई खराब है, हम बस यह जांचते हैं कि क्या है i<5( अगर मैंने i<9ऐसा किया तो यह अभी भी एक-अक्षर के शब्दों के लिए अमान्य होगा यदि उपयोगकर्ता गलती iसे 2 डालने से इंकार कर देता है कमांड लाइन पर एकल तर्क।)

लूप कंडीशन टेस्ट को साधारण में बदलकर 4 बाइट्स बचाए गए &31। इसके लिए यह आवश्यक है कि यह शब्द एक स्थान (ASCII 32) या एक अशक्त चरित्र (ASCII 0.) के साथ समाप्त हो गया है। आम तौर पर कीबोर्ड इनपुट को एक नई लाइन (ASCII 10) द्वारा समाप्त किया जाता है, इसलिए प्रोग्राम का उपयोग करने के लिए थोड़ा असुविधाजनक है, क्योंकि आपको टाइप करना है अंतरिक्ष तो बफर को पढ़ने के लिए कंप्यूटर को वापस पाने के लिए भी प्रेस करें। न्यूलाइन-टर्मिनेटेड स्ट्रिंग्स के लिए, मैं मैच कर सकता था लेकिन बीब के तरीके को हरा नहीं सकता था।

6 13 बाइट्स को एन्कोडिंग को बदलकर बचाया गया - (प्रत्येक अक्षर की टाइल्स की संख्या) - (उस अक्षर -1 के लिए स्कोर) * 13 । इसके लिए अब Q, Z के लिए L, S, U से -118 के लिए -4 रेंज की आवश्यकता होती है। ऋणात्मक संख्याओं का उपयोग करने का कारण अप्राप्य ASCII श्रेणी 0 से 31 तक से बचना है। इसके बजाय उपयोग की जाने वाली सीमा ऋणात्मक संख्याओं का दो पूरक है 256-4 = 252 से 256-118 = 138। ये मुद्रण योग्य, विस्तारित ASCII वर्ण हैं। यूनिकोड में इन्हें कॉपी करने और चिपकाने के मुद्दे हैं (जिस तरह से यह वापस ASCII के लिए सरल हो जाता है, वह स्थापित किए गए कोड पेज पर निर्भर करता है जिससे अप्रत्याशित परिणाम हो सकते हैं) इसलिए मैंने प्रोग्राम कमेंट में सही ASCII कोड शामिल किए हैं।

इस एन्कोडिंग का लाभ वैरिएबल का उन्मूलन है rक्योंकि टाइल्स की संख्या हमेशा 1 से कम हो जाती है (क्योंकि यह एक नकारात्मक संख्या के रूप में संग्रहीत है, हम करते हैं t[x]++। इसके अलावा, पोस्टफिक्स ऑपरेटर का मतलब है कि हम इस वेतन वृद्धि को उसी समय पर कर सकते हैं। स्कोर जोड़ने के लिए s।

//char t[]={32,247,228,228,239,244,215,240,215,247,164,203,252,228,250,248,228,138,250,252,250,252,215,215,164,215,138,0};
b,s;
main(i,x){
  for(char t[]=" ÷ääïô×ð×÷¤ËüäúøäŠúüúü×פ׊";x=getchar()&31;i*=4)
    t[x]%13?
      s-=t[x]++/13-1:
      b++;
  printf(i<9|b>2?"Invalid":"%d",s);
} 

C, 184 Rev 1 173 (या संकलक विकल्प के साथ 172)

मैं जीसीसी का उपयोग कर रहा हूं, और संकलक विकल्प के साथ -std=c99यह मुझे एक अतिरिक्त अर्धविराम की बचत के लिए लूप char t[]="...."के आरंभ में ले जाने की अनुमति देगा for। पठनीयता के लिए, मैंने इस बदलाव के बिना कार्यक्रम दिखाया है, और व्हाट्सएप के साथ छोड़ दिया है।

#define T t[x[1][i]-65]
i,b,s;
main(int r,char**x){
  char t[]="Z>>QxS=SZW6(><P>m<(<(SSWSm";
  for(;x[1][i];i++)
    T/10?
      s+=r=T%10+1,T-=r*10:
      b++;
  printf(i<2|i>15|b>2?"Invalid":"%d",s);
}

चाल डिटैटेबल में है। प्रत्येक अक्षर के लिए प्रपत्र का एक ASCII कोड (उस पत्र के लिए टाइल का कुल स्कोर) * 10 + (एक टाइल -1 का स्कोर) तालिका में संग्रहीत किया जाता है t[]। रनटाइम के दौरान, ये कुल स्कोर कम हो जाते हैं क्योंकि टाइल्स का उपयोग किया जाता है।

प्रत्येक अक्षर के लिए सभी टाइलों का कुल स्कोर L, S, U के लिए E के नीचे 12 से 4 तक होता है। एन्कोडिंग का यह रूप केवल मुद्रण योग्य ASCII वर्णों का उपयोग करने में सक्षम बनाता है (ASCII 120, xE डाउन के लिए ASCII 40 के लिए, (L, S, U के लिए।) टाइल्स की संख्या का उपयोग करके 120 से 10 तक की सीमा की आवश्यकता होती है, यही कारण है कि। इससे परहेज किया।

#defineमैक्रो के लिए धन्यवाद , Tमुख्य प्रोग्राम iमें पहले कमांडलाइन तर्क से पत्र इंडेक्स को पुनः प्राप्त करने के लिए एक एकल प्रतीक का उपयोग किया जाता है, Aएक इंडेक्स देने के लिए इसमें से ASCII = 65 को घटाएं , और इसे तालिका T में देखें t[x[1][i]-65]।

forपाश अधिक एक तरह प्रयोग किया जाता है whileपाश: पाश समाप्त होता है जब एक शून्य बाइट (स्ट्रिंग टर्मिनेटर) इनपुट स्ट्रिंग में आई है।

यदि उस पत्र की टाइलें समाप्त नहीं हुई हैं ( T/10तो नॉनज़रो है) कुल स्कोर रखने के sलिए टाइल स्कोर द्वारा बढ़ाई गई है T%10+1। एक ही समय में टाइल स्कोर में संग्रहीत किया जाता है r, ताकि यह दर्शाया Tजा सके r*10कि एक टाइल का उपयोग किया गया है या नहीं। यदि टाइलें समाप्त हो जाती हैं, तो वाइल्डकार्ड / खाली काउंटर बढ़ bजाता है।

printfबयान काफी आत्म व्याख्यात्मक है। यदि शब्दकूट सीमा से बाहर है या रिक्त संख्या बहुत अधिक है, तो प्रिंट करें Invalidअन्यथा स्कोर प्रिंट करें s।

Comments

चूँकि अब एक और दिन है, आप r + = (r == 7) * 3 को r + r-r-7? 0: 3 से बदलकर एक वर्ण को बचा सकते हैं। इसके अलावा आपको ब्रैकेट्स की आवश्यकता नहीं है T- = r * 9, s + = r।

— अल्काइमर

@Alchymist कोष्ठक के बारे में टिप के लिए धन्यवाद, मैं हमेशा भूल जाता हूं कि ऑपरेटर की पूर्ववर्ती के साथ कोई समस्या नहीं है ?और :। आपकी दूसरी बात समाप्त हो गई है, क्योंकि मैंने एन्कोडिंग को पूरी तरह से बदल दिया है, इसलिए क्यू और जेड के किसी विशेष हैंडलिंग की कोई आवश्यकता नहीं है। अब आपकी मदद से 173/172 तक नीचे।

— लेवल रिवर सेंट 10

साथ getchar(): यह 159 है l,w,f;main(t,i){for(char b[]="Z>>QxS=SZW6(><P>m<(<(SSWSm";(i=getchar()-65)>=0;l++)b[i]/10?f+=t=b[i]%10+1,b[i]-=t*10:w++;printf(l<2|l>15|w>2?"Invalid":"%d",f);}, हालांकि मैं अभी भी क्यों नहीं मिलता है char*foo=<string>दुर्घटनाओं। यह 2 वर्ण बचा सकता है।

— bebe

@bebe char*foo="string"एक स्ट्रिंग शाब्दिक है, और इसकी सामग्री को संशोधित करने की अनुमति नहीं है। दूसरी ओर, char foo[]="string"वर्णों की एक सारणी बनाई गई है string\0, जिसे तब संशोधित किया जा सकता है।

— es1024

@ कबी कूल, मुझे यह उपयोग करने का विचार याद आया कि getchar().मैंने आपके सुधार का उपयोग कोड के साथ किया है (मेरे उत्तर के साथ संगतता के लिए मेरे चर नामों के साथ), साथ ही साथ शब्दावलिटी की वैधता की जांच में सुधार, और लूप की स्थिति में सुधार परीक्षण (मैंने आपको छोटा करने की कोशिश की, लेकिन समान कार्यक्षमता के साथ ऐसा नहीं कर सका।) मैंने भी कोशिश की getche()और getch()लेकिन मेरे कंपाइलर (साइबर पर gcc) उन्हें स्वचालित रूप से लिंक नहीं करेंगे।

— लेवल रिवर सेंट

Answer 3

जावास्क्रिप्ट (ES6) - 241 230 199 182

f=s=>{for(i=t=_=0,E=12,A=I=9,B=C=M=P=28,D=17,F=H=V=W=Y=41,G=16,J=X=92,K=53,L=S=U=4,N=R=T=6,O=8,Q=Z=118;c=s[i++];)this[c]%13<1?_++:t+=1+this[c]--/13|0;alert(i<3|i>16|_>2?"Invalid":t)}

संपादित करें - मैंने आकार को कम करने और गैर-एस्की वेरिएबल्स को निकालने के लिए मात्रा / अंकों को इनकोड करने के तरीके को बदल दिया

2 संपादित करें - स्ट्रिंग्स के बजाय पूर्णांक के लिए मात्रा / स्कोर एन्कोडिंग को बदल दिया

संपादित 3 - स्विच करने के लिए %13(धन्यवाद @ edc65), एन्कोडिंग उलटा, सीधे मूल्यों को संशोधित, और कुछ अन्य छोटे सुधार

फ़ायरफ़ॉक्स कंसोल में परीक्षण किया गया।

Comments

+1 बहुत चालाक। सुझाव: 1. f[c]=1+f[c]||1-> f[c]=-~f[c], 2.%

— edc65

192 एफ = एस => {के लिए (ई = 12, ए = आई = 9, बी = सी = एम = पी = 28, डी = 17, एफ = एच = वी = वाई = वाई = 41, जी = 16, जे। = एक्स = 92, कश्मीर = 53, एल = एस = यू = 4, एन = आर = टी = 6, हे = 8, क्यू = जेड = 118, $ = 2, टी = मैं = 0; ग = रों [i ++ ];) (च [सी] = - ~ च [सी])> (एल = इस [सी])% 13 - $: टी + = एल / 13 + 1 | 0; चेतावनी (i <3 | i> 16 | $ <0? "अमान्य": t)}

— edc65

@ edc65 - धन्यवाद ढेर। उस पहली चाल को नहीं देखा था, लेकिन इसका उपयोग नहीं किया क्योंकि मैं अब सीधे मूल्यों को संशोधित कर रहा हूं (मानसिक रूप से भविष्य के गोल्फ के लिए इसे दूर करना)। %13हालांकि प्रतिभा का एक स्ट्रोक है। मैं यह सोचकर अटक गया कि मुझे अंकों में चीजों को संग्रहीत करना है, लेकिन गणित बेस 10 और बेस 13 के बीच अंतर के बारे में परवाह नहीं करते हैं।

— अल्कंजा

अच्छा! (क्रोम के कंसोल, बीटीडब्ल्यू में काम नहीं करता है SyntaxError: Unexpected token >।)

— डीएलओएस

@DLosc - हाँ, मुझे लगता है कि फ़ायरफ़ॉक्स इस समय एकमात्र ऐसा ब्राउज़र है जो सभी ECMAScript 6 सामान का समर्थन करता है (क्रोम को f=s=>{...}नोटेशन पसंद नहीं है)।

— अलकनजा

Answer 4

पायथन 3, 217 201

b=2;i=s=0;w=input()
while i<26:n=w.count(chr(i+65));q=int('9224c232911426821646422121'[i],16);b-=max(0,n-q);s+=min(n,q)*int('1332142418513113a11114484a'[i],16);i+=1
print(["Invalid",s][-b<1<len(w)<16])

Ungolfed:

b=2    # number of blanks available
i=s=0  # letter index 0..25, running score tally
w=input()

# Loop through each letter of the alphabet
while i<26:
    # Get number of occurrences in the word
    n=w.count(chr(i+65))
    # Get quantity of the letter from hex encoded string
    q=int('9224c232911426821646422121'[i],16)
    # Remove blanks for each occurrence over that letter's quantity
    b-=max(0,n-q)
    # Score the non-blank tiles, getting scores from hex-encoded string
    s+=min(n,q)*int('1332142418513113a11114484a'[i],16)
    # Increment
    i+=1

# If b > -1 and 1 < len(w) < 16, print the score; otherwise, print "Invalid"
print(["Invalid",s][-b<1<len(w)<16])

संपादित करें: एक टिप के लिए @BeetDemGuise के लिए धन्यवाद जिसने अंततः मुझे 1-चरित्र की कमी से बहुत अधिक प्रेरित किया! नीचे मूल कोड:

q=[77-ord(x)for x in'DKKIAKJKDLLIKGEKLGIGIKKLKL'];b=2;s=0;w=input()
for c in set(w):n=w.count(c);o=ord(c)-65;b-=max(0,n-q[o]);s+=min(n,q[o])*(1+int('02210313074020029000033739'[o]))
print(["Invalid",s][-b<1<len(w)<16])

Comments

यह काफी न्यूनतम है लेकिन आप अपने स्कोर स्ट्रिंग को हेक्स में एन्कोडिंग करके 1byte को बचा सकते हैं: int('1332142418513113a11114484a'[o],16) :)

— BeetDemGuise

Answer 5

BEFUNGE 93 - 210 बाइट्स।

लेकिन यह 15 अक्षर की सीमा की जांच नहीं करता है।

v1332142418513113:11114484: >01g:"0"-!#v_1-01p1+\v
 9224<232911426821646422121v  "Invalid"<      vp0<
<vp00p10"20"p200p900
>>~:55+-!#v_"@"-::1g:"0"-! #^_1-\1p0g+"0"-02g+>02p
_v#:-1<    #p90+g90-"0"g1:<
     @.g20<        @,,,,,,,<

Answer 6

सी, 197

मान लें कि स्ट्रिंग को कमांड लाइन तर्क के रूप में प्रदान किया गया है, जैसे ./scrabble STACKEXCHANGE

s;n;m=31;main(int c,char**v){char d[]="BIBBDLBCBIAADBFHBAFDFDBBABA@ACCBADBDAHEACAACJAAAADDHDJ";for(;c=*v[1]++&m;d[c]--,s+=d[c+27]&m)n+=1+m*(!(d[c]&m||d[c=0]&m));printf(n>1&&n<16?"%d":"Invalid",s);}

Answer 7

जावास्क्रिप्ट - 232 201

t=[9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1];w=r=0;for(i=y=z.length;i--;){x=z.charCodeAt(i)-65;if(!t[x])w++;else{t[x]--;r+=-~"02210313074020029000033739"[x]}}alert(w>2|y<2|y>15?"Invalid":r)

zभंडार शब्द। चेतावनी के रूप में आउटपुट।

संपादित करें: नीचे दी गई सिफारिशों के अनुसार सुधार हुआ है।

Comments

sकेवल एक बार उपयोग किया जाता है, इसलिए आपको इसे एक परिवर्तनशील बनाने की आवश्यकता नहीं है; आपको लगता है कि घोषणा को हटाने और जगह ले सकता है r+=s[x]के साथ r+=-~"02210313074020029000033739"[x]। इसके अलावा, आपको (w>2|y<2|y>15)अलर्ट में कोष्ठक की आवश्यकता नहीं है ।

— निंजाबियरनॉकी

Answer 8

हास्केल - 538

इसे scrabble.hs के रूप में सहेजें और फिर इसका उपयोग करके संकलित करें

ghc --make scrabble && ./scrabble

फिर इनपुट के रूप में अपना शब्द दर्ज करें और एंटर दबाएं

l=['A'..'Z']
sc=zip l [1,3,3,2,1,4,2,4,1,8,5,1,3,1,1,3,10,1,1,1,1,4,4,8,4,10]
vfs a y =snd $ filter (\x -> fst x == y) a !! 0
q = zip l [9,2,2,4,12,2,3,2,9,1,1,4,2,6,8,2,1,6,4,6,4,2,2,1,2,1]
i s =filter (\x -> (fst x) >=0) [(length [x | x <- s, x == a] - vfs q a,a) | a <- l]
main = do
 s <- getLine
 if length s <= 15 && length s > 2 && sum (map fst (i s)) <= 2 then
  putStrLn $ show (sum [vfs sc x| x <- s] - sum [(vfs sc (snd x)) * (fst x) | x <- (filter (\x -> fst x > 0) (i s))])
 else do
  putStrLn "Invalid"

Comments

आप बहुत सारे स्थान हटा सकते हैं और हास्केल में `['ए', 'बी', 'सी'] ==" एबीसी "। इसके अलावा, आप प्रत्येक स्तर के इंडेंट के लिए केवल एक स्थान का उपयोग कर सकते हैं। और आप छोटे नामों का उपयोग कर सकते हैं। गोल्फ के लिए बहुत कुछ है।

— रे

@ रे ने किया है कि, मैं हास्केल के लिए नया हूं, क्या इन्ट्स की सूचियों को अधिक संक्षिप्त रूप से दर्शाने का एक तरीका है [1,2,3]?

— तूओमास लाककोनेन

"ABCDEFG"के रूप में लिखा जा सकता है ['A'..'G'], के रूप में लिखा [1,2,3]जा सकता है[1..3]

— रे

आप अपनी बाइट की गिनती कैसे प्राप्त करेंगे? wc मुझे आपके कोड के लिए 500 से अधिक अक्षर देता है।

— TheSpanishInquisition

@TheSpanishInquisition बस मेरे st3 शब्द गणना विस्तार के लिए एक अद्यतन मिला, लेखक ने गलती से दो गणनाओं की अदला-बदली की थी, जिसे 538 तक संपादित किया गया था

— Tuomas Laakkonen

Answer 9

पायथन 2.7 - 263

मैं कहीं भी DLosc के उत्तर के करीब नहीं आ सका , लेकिन यह प्रत्येक अक्षर को एक 'बैग' के रूप में मानता है जिसे आप अपने खाली होने तक खींचते हैं, फिर आप रिक्त स्थान को खींचते हैं, और जब वह खाली होता है तो त्रुटियां होती हैं।

S=input().lower()
X={chr(97+i):[int(y)+1]*(77-ord(x))for i,(x,y)in enumerate(zip('DKKIAKJKDLLIKGEKLGIGIKKLKL','02210313074020029000033739'))}
B=[0,0]
try:
 if len(S)>15:1/0
 print sum(map(lambda x:X[x].pop()if len(X[x])>0 else B.pop(),S))
except:
 print "invalid"

Comments

यह एक स्वच्छ दृष्टिकोण है! raw_inputअगर आपको Python2 की ज़रूरत है (एक चीज़ जो मुझे Python3 के बारे में पसंद है)। इनपुट अपरकेस गारंटी है, तो निकालें .lower()और परिवर्तन 97+iकरने के लिए 65+i। 2 वर्णों से कम इनपुट को भी अमान्य होना चाहिए। आप एक ifबयान के बिना शून्य-विभाजन त्रुटि उठा सकते हैं : अपने कुल स्कोर को विभाजित करें (1<len(S)<16)। एक जोड़े को अन्य tweaks डाल की तरहprint से ब्लॉक हेडर के रूप में एक ही लाइन पर एस और अंतरिक्ष को हटाने से पहले "Invalid"मेरी गिनती से 250 तक एक और मोड़ आता है। :)

— DLosc

Answer 10

हास्केल, 290 283

जहाँ तक मैं इसे अभी के लिए बना सकता हूँ:

import Data.List
t="CdC8d::Od;D;d41N:dd:6dNdN;;4;6"
s w@(_:_:_)=let d=concat(zipWith(replicate.(`div`11).f 33)t("AEIO"++['A'..]))\\w;y=drop 15w in if length(d++w++y++y++y)>100 then s""else show$187-(sum$map((`mod`11).f 0.(t!!).f 61)d)
s _="Invalid"
f n=(-n+).fromEnum
main=interact s

यह कोड नियमों का बहुत सख्ती से पालन करता है, इसलिए सुनिश्चित करें कि आप इसे किसी भी अतिरिक्त वर्ण (जैसे कि अंत-पंक्ति) के पास नहीं देते हैं। इस तरह का उपयोग करें:echo -n "JAZZ" | runghc scrabble.hs।

व्याख्या

पैटर्न (_:_:_)यह सुनिश्चित करता है कि केवल कम से कम दो वर्णों के तार को माना जाता है, बाकी सब कुछ "Invalid"( नतीजा पैटर्न _) में होता है। टाइल्स की मेज को 11*nTiles+valueएक ऑफसेट के साथ ASCII में बदल दिया जाता है, जो लुकअप मोड्यूलो 11 को काम करने की अनुमति देता है, जहां अक्षरAEIO की नकल की जाती है क्योंकि वे प्रत्येक में 6 गुना से अधिक होते हैं। टाइलों के पूल का उपयोग करके बनाया जाता है replicate, जिसमें से शब्द के अक्षर हटा दिए जाते हैं जैसे कि वे होते हैं (सूची अंतर,\\)। पूल में 98 टाइलें हैं, इसलिए यदि शब्द की कुल लंबाई और पूल का शेष भाग 100 से बड़ा है, तो हमने बहुत सारे वाइल्डकार्ड का उपयोग किया है। इसके अलावा, पहले 15 अक्षरों का माइनस शब्द तीन बार लंबाई की गणना में जोड़ा जाता है, इसलिए 15 अक्षरों से अधिक लंबा कोई भी शब्द स्वचालित रूप से तीन वाइल्डकार्ड का उपयोग करता प्रतीत होता है और इसलिए अमान्य है। शेष पूल पर स्कोरिंग की जाती है, जिसमें शुरू में 187 अंक थे, जिसे हम बस से घटाते हैं। पूल की शुरुआत में डुप्लिकेट की वजह से, के f 61बजाय ध्यान दें । बाकी सिर्फ बॉयलरप्लेट है।f 65, 65 ASCII की संख्या है 'A'"AEIO"

Answer 11

पायथन 3 - 197

s,i,c,r=input(),0x1a24182424416141611a2381612341151891243224c142232391,[],[]; p=len(s)
for w in s:e=8*ord(w)-520;c+=[s.count(w)<=i>>e+4&15];r+=[i>>e&15]
print(['Invalid',sum(r)][all([p>2,p<15]+c)])

चलो उपयोग करने के लिए bignums डालते हैं: D (यह वर्तमान में वाइल्डकार्ड नहीं संभालता है, मैंने उस नियम को पूरी तरह से पढ़ना छोड़ दिया है, लानत है)

Answer 12

रूबी - 195

b=2
i=s=0
w=$*[0]
(?A..?Z).map{|l|n=w.count(l);q='9224c232911426821646422121'[i].to_i(16);b-=[0,n-q].max;s+=[n,q].min*'1332142418513113a11114484a'[i].to_i(16);i+=1}
p(-b<1&&w.size<16?s:'Invalid')

मैं मान रहा हूँ कि उत्पादन "Invalid"ठीक है, अगर मुझे ऐसा करने की आवश्यकता नहीं है $><<(-b<1&&w.size<16?s:'Invalid')जो इसे 198 तक टक्कर देगा

लौंग - 325

मैंने थोड़ी देर में क्लोजर नहीं किया है, इसलिए मुझे यकीन है कि मेरे समाधान को सुधारने के कई तरीके हैं।

(let[w(first *command-line-args*)o(map #(count(filter #{%}(seq w)))(map char(range 65 91)))i(apply +(filter neg?(map #(- % %2)'(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1) o)))](println(if(or(> -2 i)(not(<= 2(count w)15)))"Invalid"(apply +(map #(* % %2)o'(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10))))))

कुछ अन-गोल्फ वाले

(let [word    (first *command-line-args*)
      letters (map char(range 65 91))
      occ     (map #(count (filter #{%} (seq word))) letters)
      invalid (apply + (filter neg? (map #(- % %2)
                '(9 2 2 4 12 2 3 2 9 1 1 4 2 6 8 2 1 6 4 6 4 2 2 1 2 1)
                occ)))
      score   (apply + (map #(* % %2) occ '(1 3 3 2 1 4 2 4 1 8 5 1 3 1 1 3 10 1 1 1 1 4 4 8 4 10)))]
    (println
      (if (or (> -2 invalid)
              (not (<= 2 (count word) 15)))
        "Invalid"
        score)))

Answer 13

ES6: 184 (गैर-सख्त)

wपहले से ही शब्द शामिल माना जाता है। rआउटपुट स्ट्रिंग है।

i=0,o=[..."291232342c124322491181541236181231a61416141242418241a"].map(c=>parseInt(c,16)),r=!w[16]&&w[2]&&[...w].every(c=>o[c=c.charCodeAt()*2-129]-->0?i+=o[c+1]:o[0]--)?i+"":"Invalid"

यहाँ यह समझाया गया है और थोड़ा कम गोल्फ है:

// The sum.
i = 0,

// The data for the letters. It's encoded similar to the Ruby version, with
// the first being the wildcard holder. The rest hold in hex form the
// following: first = quantity left, second = value.
// The .map(c => parseInt(c, 16) simply parses all the hex characters.
o = [..."291232342c124322491181541236181231a61416141242418241a"]
  .map(c => parseInt(c, 16)),

// The result, `r`.
r = !w[16] || // If there is a 16th character in the word or no 2nd character,
    w[2] &&   // then the next section isn't evaluated. It immediately equates
              // to true, thus returning "Invalid".
   [...w] // Convert the string into an array of characters (ES6 equivalent to
          // `.split('')`
    .every(c => // This loop terminates when the callback returns a falsy
                // value.
      // Gets the ASCII value, subtracts 65, doubles it (the lookup table is
      // in pairs within one array), and decrements the counter at that entry.
      // The lookup table also doubles as a data holder.
      o[c = c.charCodeAt() * 2 - 129]--
        > 0 ?  // Test if there is something to take away. This must return
               // false at 0 and -1 so wildcards can be taken.
        i += o[c+1] : // If there was something to take away, then add the
                      // letter value to the sum.
        o[0]--) // Otherwise, take a wildcard. If this is already at 0, then
                // it returns falsy.
      ? "Invalid" : i + "" // This is where the text is returned.

Answer 14

डार्ट - 201

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:2}){if((m=a[0].length)>1&&m<16)for(i in a[s=0].codeUnits)x>>(m=i*8-520)&15>0?r+=(x-=1<<m)>>m+4&15:++s;print(s<2?r:"Invalid");}

इसके लिए bignums की आवश्यकता होती है, इसलिए यह JavaScript को संकलित नहीं करेगा।
अधिक व्हाट्सएप के साथ:

main(a,{x:0xa14281424214161416a132181632145181194223421c24323219,i,r:0,m,s:3}){
  if((m=a[0].length)>1&&m<16)
    for(i in a[s=0].codeUnits)
      x>>(m=i*8-520)&15>0
      ? r+=(x-=1<<m)>>m+4&15
      : ++s;
  print(s<3?r:"Invalid");
}

Answer 15

PHP, 180 170 168 बाइट्स

for($q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);$o=31&ord($argv[1][$i++]);)$s+=$q[$o]++>L?$q[0]++>L?$f=1:0:X02210313074020029000033739[$o]+1;echo$f|$i<3|$i>16?Invalid:$s;

वाह! जेएस की पिटाई!

टूट - फूट

for(
    $q=str_split(KDKKIAKJKDLLIKGEKLGIGIKKLKL);  // init quantities: L=1,A=12
    $o=31&ord($argv[1][$i++]);                  // loop through characters: map to [1..26]
)
    $s+=                                          // increase score by ...
        $q[$o]++>L?                                 // old quantity below 1?
        $q[0]++>L?$f=1                              // no more wildcards? set error flag
        :0                                          // wildcard: 0 points
        :X02210313074020029000033739[$o]+1;         // else: letter score
echo$f|$i<3|$i>16?Invalid:$s;                   // output

मुझे खुशी है कि 10 से बड़ा कोई अक्षर स्कोर नहीं है।