परिभाषाएं

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

Width  Characters
1      i l I '
2      f j r t -
3      a b c d e g h k n o p q s u v x y z
4      m w A B C D E F G H J K L N O P Q R S T U V X Y Z
5      M W

मेरे स्पष्टीकरण और परीक्षण के मामलों के लिए, |उस स्थान को निरूपित करता है जिसमें किसी शब्द को सफाई से आधे में विभाजित किया जा सकता है।(और )एक पत्र के दोनों ओर संकेत मिलता है कि एक साफ विभाजन बनाने के लिए उस पत्र को आधे में विभाजित किया जाएगा।

इनपुट

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

काम

इनपुट के सभी रूपों (सभी संभव ऊपरी या निचले मामले के पदों पर सभी पत्र) के माध्यम से क्रमांकित करें। उदाहरण के लिए, इनपुट के लिए, it'sनीचे सभी क्रमपरिवर्तन हैं:

it's
it'S
iT's
iT'S
It's
It'S
IT's
IT'S

किसी शब्द के क्रमांकन को आधे हिस्से में विभाजित करने के लिए, शब्द के एक तरफ के अंक शब्द के दूसरे पक्ष के बिंदुओं के समान होने चाहिए। हालाँकि, यदि कोई पत्र दो खंडों के बीच में अटक जाता है, तो आप एक पत्र को आधे में भी सफाई से काट सकते हैं।

कृपया ध्यान दें कि "आधा" का मतलब यह नहीं है कि आप स्ट्रिंग में आधे रास्ते पर चले गए हैं। "आधा" का अर्थ है कि दोनों तरफ के बिंदु समान हैं।

उदाहरण:

W5 अंक है। i1 अंक है। Wiiiiiआधे में क्रमिक बंटवारे के परिणामस्वरूप W | iiiii, प्रत्येक पक्ष पर 5 अंक होंगे |।

T3 अंक है। TTTTआधे में क्रमिक बंटवारे के परिणामस्वरूप TT | TT, प्रत्येक पक्ष पर 6 अंक होंगे| ।

w4 अंक है। ए 3 अंक है। wawआधे हिस्से में क्रमचय को विभाजित करने के परिणामस्वरूप w (a) wप्रत्येक पक्ष पर 5.5 अंक होंगे। aदोनों तरफ से अंक वितरित किए गए हैं, जैसा aकि आधे हिस्से में विभाजित है।

उत्पादन

आपका आउटपुट इनपुट के अनूठे क्रमपरिवर्तन की संख्या का पूर्णांक है, जिसे सफाई से आधे में विभाजित किया जा सकता है। यदि आवश्यक हो तो अनुगामी नईलाइन्स की अनुमति दी गई है।

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

मैं परीक्षण मामलों के लिए इनपुट के सभी वैध क्रमांकन का उत्पादन करूंगा। याद रखें कि यह आपके लिए चश्मे का हिस्सा नहीं है।

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

Input: a
( a ) 
  3   
( A ) 
  4   
Output: 2

Input: in
Output: 0

Input: ab
A | B 
4   4 
a | b 
3   3 
Output: 2

Input: abc
A ( B ) C 
4   4   4 
A ( b ) C 
4   3   4 
a ( B ) c 
3   4   3 
a ( b ) c 
3   3   3 
Output: 4

Input: will
W ( I ) L l 
5   1   4 1 
W ( I ) l L 
5   1   1 4 
W ( i ) L l 
5   1   4 1 
W ( i ) l L 
5   1   1 4 
w I | L l 
4 1   4 1 
w I | l L 
4 1   1 4 
w i | L l 
4 1   4 1 
w i | l L 
4 1   1 4 
Output: 8

Input: stephen
S T E ( P ) H E N 
4 4 4   4   4 4 4 
S T E ( p ) H E N 
4 4 4   3   4 4 4 
S T E | p h e n 
4 4 4   3 3 3 3 
S T e ( P ) H E n 
4 4 3   4   4 4 3 
S T e ( P ) H e N 
4 4 3   4   4 3 4 
S T e ( P ) h E N 
4 4 3   4   3 4 4 
S T e ( p ) H E n 
4 4 3   3   4 4 3 
S T e ( p ) H e N 
4 4 3   3   4 3 4 
S T e ( p ) h E N 
4 4 3   3   3 4 4 
S t E ( P ) H e n 
4 2 4   4   4 3 3 
S t E ( P ) h E n 
4 2 4   4   3 4 3 
S t E ( P ) h e N 
4 2 4   4   3 3 4 
S t E ( p ) H e n 
4 2 4   3   4 3 3 
S t E ( p ) h E n 
4 2 4   3   3 4 3 
S t E ( p ) h e N 
4 2 4   3   3 3 4 
S t e ( P ) h e n 
4 2 3   4   3 3 3 
S t e p | H E N 
4 2 3 3   4 4 4 
S t e ( p ) h e n 
4 2 3   3   3 3 3 
s T E ( P ) H E n 
3 4 4   4   4 4 3 
s T E ( P ) H e N 
3 4 4   4   4 3 4 
s T E ( P ) h E N 
3 4 4   4   3 4 4 
s T E ( p ) H E n 
3 4 4   3   4 4 3 
s T E ( p ) H e N 
3 4 4   3   4 3 4 
s T E ( p ) h E N 
3 4 4   3   3 4 4 
s T e ( P ) H e n 
3 4 3   4   4 3 3 
s T e ( P ) h E n 
3 4 3   4   3 4 3 
s T e ( P ) h e N 
3 4 3   4   3 3 4 
s T e ( p ) H e n 
3 4 3   3   4 3 3 
s T e ( p ) h E n 
3 4 3   3   3 4 3 
s T e ( p ) h e N 
3 4 3   3   3 3 4 
s t E ( P ) h e n 
3 2 4   4   3 3 3 
s t E p | H E N 
3 2 4 3   4 4 4 
s t E ( p ) h e n 
3 2 4   3   3 3 3 
s t e P | H E N 
3 2 3 4   4 4 4 
s t e p | H E n 
3 2 3 3   4 4 3 
s t e p | H e N 
3 2 3 3   4 3 4 
s t e p | h E N 
3 2 3 3   3 4 4 
Output: 37

Input: splitwords
S P L I T | W O r d s 
4 4 4 1 4   5 4 2 3 3 
<snip>
s p l i t w | o R d S 
3 3 1 1 2 4   3 4 3 4 
Output: 228

Input: 'a-r
' a ( - ) R 
1 3   2   4 
' a | - r 
1 3   2 2 
Output: 2

Input: '''''-
' ' ' ( ' ) ' - 
1 1 1   1   1 2 
Output: 1

विजय

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है। आप उचित समय में सभी परीक्षण मामलों (इसलिए, 10 वर्णों तक के सभी इनपुट) को आउटपुट करने में सक्षम होना चाहिए। कृत्रिम रूप से अपने इनपुट को कैप न करें।

इनाम

मुझे नहीं पता कि यह संभावना के दायरे में है या नहीं। हालाँकि, आप गोल्फर हैं - आप प्रतिनिधि के लिए कुछ भी करेंगे। मैं एक 200 प्रतिनिधि इनाम की पेशकश कर रहा हूं (एक बार यह इनाम शर्त पूरी हो जाने के बाद मैं इसे शुरू करूंगा, क्योंकि यह मेरे लिए मूल रूप से असंभव लगता है) एक प्रोग्राम के लिए antidisestablishmentarianismजो औसत कंप्यूटर (उर्फ मेरा) पर 15 सेकंड के लिए सही आउटपुट देता है। कृपया ध्यान दें कि इस परीक्षण मामले को किसी भी तरह से कठोर नहीं बनाया जाना चाहिए।

@DigitalTrauma ने मेरे इनाम को कुचल दिया, दो सेकंड के भीतर अच्छी तरह से आ रहा है। उसका उत्तर यहां देखें ।

code-golf string

— स्टीफन
स्रोत

2

@MackenzieMcClane को छोड़कर पाँच हैं 'मैं इसे 2 ^ 23 = 8,388,608 पर ले रहा हूं।

— जोनाथन एलन

2

antidisestablishmentarianism(गैर-गोल्फरी) के लिए मेरी पहली गिनती 83307040(और सभी परीक्षण मामलों से मेल खाती है) है, लेकिन मेरे लैपटॉप पर ~ 37 सेकंड लगते हैं (आपको लगता है कि यह पायथन है)। किसी को भी इसके लिए एक गिनती है?

— जोनाथन एलन

2

टीआईओ

— जोनाथन एलन

8

मेरा दिमाग अजीब है आप सही जगह पर हैं

— लुइस मेंडो

6

मुझे ऐसा करने की कोशिश नहीं करनी चाहिए। मैं थानेदार | uld ऐसा ही करने की कोशिश नहीं करता। I sho | uld n (o) tt (r) yt | od | ot (h) e sa | me | O | h cr | ap ...

— अरनौलड

8

पायथ , 75 74 73 70 बाइट्स

lfsm} St-Bysded._Tm.n] d * महिला पुरूष पुरूष कश्मीर | QD \ मैं 4} d "मेगावाट" |} d "इल '" ज |?} d "fjrt -" + 2} d "मेगावाट" -2 } d " '-
 lfsm} sT-Bysded._Tm.n] d * Fmm?? qd \ i + 4} d" mw "| x} Ld + c" mw il' fjrt! ") G1 4-2} घ " '-
 lfsm} sT-Bysded._Tm.n] d * Fm <; x} Ld + c" mw il' fjrt - ") G1 4 | qd \ i + 4}" mw "-2} d | " '-
lfsm} sT-Bysded._Tm.n] d * Fm <; x} Ld + c "mw il 'fjrt -") G1 4 | qd \ i + 4} d "mw" h} dG |

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

भगवान के प्यार के लिए, कृपया भी प्रयास न करें antidisestablishmentarianism दुभाषिया में । आप इसे क्रैश कर देंगे।

व्याख्या

lfsm}sT-Bysded._Tm.n]d*Fm<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

आइए इस कोड को एक्स भागों में विभाजित करते हैं।

पहला भाग: कैसड वर्जन तैयार करना और मूल्यों को मैप करना

m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

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

m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dGQ  Q implicitly appended
m                                             Q  for d in Q:
                                           }dG       d in alphabet?
                                          h          +1 (T/F as 1/0)
 <   take the first ^ elements of the following array
     for d in alphabet, it will take 2 elements;
     for d being ' or -, it will take 1 element.
  ,          pair up the following two values
   |x}Ld+c"mw il' fjrt-")G1 4                  this is the first value
                             |qd\i+4}d"mw"    this is the second value

जैसा कि आप देखते हैं, यहां तक कि पहला भाग बहुत लंबा है।

पहला मान लोअरकेस संस्करण के लिए है, जिसमें शामिल है 'और -। दूसरा मान अपरकेस संस्करण के लिए, के साथ 'और है- नहीं ले जाएगा।

पहला मूल्य:

|x}Ld+c"mw il' fjrt-")G1 4
       "mw il' fjrt-"        does what it says on the tin
      c              )       split on spaces, creating an
                             array with three elements
     +                G      append another element, which
                             is the alphabet, as a fail-safe;
                             now the array has 4 elements
  }Ld                        check if d is in each array
                             as with above, True becomes 1
                             and False becomes 0 (T/F as 1/0)
 x                     1     find the first occurrence of 1
|                        4   logical or with 4. If it was 0,
                             it would become 4 now.

पहले स्ट्रिंग में "mw"इंडेक्स 0. शामिल है । इसमें 4 का मान है, जो तार्किक की आवश्यकता को बताता है या। ध्यान दें कि पायथन 0-इंडेक्सिंग का उपयोग करता है। इसके अलावा, इससे पहले की जगह को इससे 4अलग करना है1 ।

दूसरा मूल्य (अपरकेस):

|qd\i+4}d"mw"
 qd\i          d=="i"
|              logical OR
       }d"mw"  is d in "mw"? That is, is d "m" or "w"?
     +4        +4

अगर dहै "i", तो वह देता है1 पहले कदम पर । अन्यथा, यह जारी है। अगर dहै "m"या "w", फिर तीसरे चरण देता है 1, जो करने के लिए जोड़ा जाता है 4देने के लिए 5। यदि dनहीं है "m"या है "w", तो तीसरा चरण देता है 0, जिसे 4देने के लिए जोड़ा जाता है 4।

दूसरा भाग: काम पूरा करना

lfsm}sT-Bysded._Tm.n]d*F

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

रिकैप: पहले भाग में, हमने पत्रों को उनके संभावित मानों (अक्षरों के लिए निचला और बड़ा अक्षर), दो विराम चिह्नों के लिए सिर्फ एक मान) में मैप किया। इनपुट के लिए "ab", एक मिलेगा[[3,4],[3,4]] ।

विभिन्न आवरण संस्करणों को उत्पन्न करने के लिए (जो पहले भाग में किया जाना चाहिए था, लेकिन यह अतिप्रवाह होगा), हम कार्टेशियन उत्पाद का बार-बार उपयोग करते हैं, और फिर परिणाम को समतल करते हैं। समस्या तब होती है जब केवल एक अक्षर (पहला टेस्टकेस) होता है, क्योंकि कार्टेसियन उत्पाद हमें एक सरणी नहीं देता है, और .nसंख्याओं के लिए अजीब परिणाम देने के लिए फ्लैटन कमांड ( ) ओवरफ्लो होता है। हम देखेंगे कि मैंने इस मुद्दे को कैसे दरकिनार किया।

lfsm}sT-Bysded._Tm.n]d*F
                      *F  reduce by Cartesian product
                 m   d    for d in each unflattened version:
                    ]         [d] (wrap in array)
                  .n          flatten
 f                filter for resulting arrays as T
              ._T all prefixes of T
   m              for d in each prefix:
          sd          find the sum of d
         y            double
       -B   ed        [above, above - last element of d]
    }sT               is the sum of T in the above array of 2 elements?
  s               sum the 1/0 generated in each prefix
                  any non-zero value is regarded as truthy
l                 length

यदि यह बीच में एक विभाजन है | , तो उपसर्ग कुल योग होने का योग होगा।

यदि यह द्वारा विभाजित है () , तो उपसर्ग योग शून्य से दोगुना हो , कोष्ठक में मान कुल का योग होगा।

— लीक नन
स्रोत

हां, जब मेरे पास समय होगा। (मैं अपने व्यस्त कार्यक्रम के लिए माफी माँगता हूँ।)

— लीक नून

11

सी, 378 बाइट्स; के लिए लगभग 0.6 s`antidisestablishmentarianism`

अद्यतन उत्तर । मैं @ के बारे में JonathanAllan की टिप्पणी को पढ़ने i, और पहले मैं कम से इस अनुकूलन समझ में नहीं आया, लेकिन अब मुझे लगता है कि जब से दोनों iऔर I1 की चौड़ाई है, तो हम जुड़े क्रमपरिवर्तन दो बार केवल एक बार मान्य करने के लिए होने के साथ भरोसा कर सकते हैं। पहले मेरे समाधान ने कई सीपीयू पर लोड फैलाने के लिए कई थ्रेड्स का उपयोग किया और इसके साथ ही मैं अपनी मशीन पर सभी 2 ²⁸ संभावनाओं के माध्यम से जाने में सक्षम था । अब iअनुकूलन के साथ थ्रेड्स के साथ गड़बड़ करने की कोई आवश्यकता नहीं है - एक एकल धागा समय प्रतिबंध के भीतर आसानी से काम करता है।

आगे की हलचल के बिना - गोल्फ सी समारोह:

char m[128]={[39]=10,[45]=20};f(s,l,p)char *s;{m[65]?:bcopy("PPPPPPPPPPPdPPPPPPPPPdPPP      <<<<<(<<(<P<<<<(<(<<P<<<",m+65,58);int g,h,u=0,v=0,x=0,y=0,c=0;if(p<l){g=s[p];if(g>64&&g-'i'){s[p]-=32;c+=f(s,l,p+1);}s[p]=g;c+=((g=='i')+1)*f(s,l,p+1);}else{for(l--,p=0,g=m[s[p]],h=m[s[l]];p<=l;){y=v;x=u;if(u+g>v+h){v+=h;h=m[s[--l]];}else{u+=g;g=m[s[++p]];}}c=u==v||y==x;}return c;}

पुनरावर्ती फ़ंक्शन f3 पैरामीटर लेता है - इनपुट स्ट्रिंग के लिए एक सूचक, स्ट्रिंग की लंबाई और स्ट्रिंग में ऑफसेट प्रसंस्करण शुरू करने के लिए (शीर्ष-स्तरीय कॉल के लिए 0 होना चाहिए)। फ़ंक्शन क्रमचय की संख्या लौटाता है।

इसे ऑनलाइन आज़माएं । TIO आमतौर पर सभी टेस्टकेस ( antidisestablishmentarianism2 सेकंड से कम सहित) के माध्यम से चलता है ।

ध्यान दें कि स्ट्रिंग में कुछ unprintables हैं जो bcopy()एड करने के लिए हैं m[]। TIO इन्हें सही तरीके से हैंडल करने लगता है।

Ungolfed:

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>

int width_tbl[] = {
    ['\''] = 1,
    ['-'] = 2,
    ['A'] = 4,4,4,4,4,4,4,4,1,4,4,4,5,4,4,4,4,4,4,4,4,4,5,4,4,4,
    ['a'] = 3,3,3,3,3,2,3,3,1,2,3,1,4,3,3,3,3,2,3,2,3,3,4,3,3,3
};

int
f (char *str, int len, int pos) {
    int lidx, ridx;
    int tot_width = 0;
    int lwidth, rwidth;
    int tot_lwidth = 0, tot_rwidth = 0;
    int prev_tot_lwidth = 0, prev_tot_rwidth = 0;
    char tmp;
    int perm_cnt = 0;

    if (pos < len) {
        tmp = str[pos];
        if (isalpha(tmp) && (tmp != 'i')) {
            str[pos] = toupper(str[pos]);
            perm_cnt += f(str, len, pos+1);
        }
        str[pos] = tmp;
        perm_cnt += ((tmp == 'i') + 1) * f(str, len, pos+1);
    } else {
        //puts(str);
        lidx = 0;
        ridx = len - 1;
        lwidth = width_tbl[str[lidx]];
        rwidth = width_tbl[str[ridx]];
        while (lidx <= ridx) {
            prev_tot_rwidth = tot_rwidth;
            prev_tot_lwidth = tot_lwidth;
            if (tot_lwidth + lwidth > tot_rwidth + rwidth) {
                tot_rwidth += rwidth;
                rwidth = width_tbl[str[--ridx]];
            } else {
                tot_lwidth += lwidth;
                lwidth = width_tbl[str[++lidx]];
            }
        }
        if (tot_lwidth == tot_rwidth) {
            perm_cnt = 1;
        } else if (prev_tot_rwidth == prev_tot_lwidth) {
            perm_cnt = 1;
        }
    }
    return perm_cnt;
}


int main (int argc, char **argv) {
    int i;
    int perm_cnt;

    if (argc > 0) {
        char *str = strdup(argv[1]);
        assert(str);

        perm_cnt = f(str, strlen(str), 0);

        printf("n = %d\n", perm_cnt);
    }

    return 0;
}

मेरे पास एक 2015 का मैकबुक प्रो है जो मैकओएस 10.12.4 पर चल रहा है। कंपाइलर डिफ़ॉल्ट MacOS क्लैंग है। मैं इसका संकलन कर रहा हूं:

cc splitwords.c -O2 -o splitwords

सभी टेस्टकेस चलाना, जिसमें ये शामिल हैं antidisestablishmentarianism:

$ time ./splitwords
Testcase "a": n = 2
Testcase "in": n = 0
Testcase "ab": n = 2
Testcase "abc": n = 4
Testcase "will": n = 8
Testcase "stephen": n = 37
Testcase "splitwords": n = 228
Testcase "'a-r": n = 2
Testcase "'''''-": n = 1
Testcase "antidisestablishmentarianism": n = 83307040

real    0m0.573s
user    0m0.564s
sys 0m0.003s
$

यह किसी भी तरह से इष्टतम नहीं है। एल्गोरिथ्म बस सभी संभावनाओं (मॉडुलो i- ऊपर टिप्पणियां देखें) के माध्यम से अपने तरीके से बल देता है , और उन शब्दों को गिनता है जो मापदंड के अनुसार विभाजित हो सकते हैं।

— डिजिटल आघात
स्रोत

अच्छा काम किया, वास्तव में मुझे लगता है कि यह शायद हे (एन) में परिणाम का मूल्यांकन करने के पत्र के 7 कक्षाओं की तय प्रभाव का उपयोग कर सकता है, i, -, ', l, mw, fjrt, और abcdeghknopqsuvxyz, लेकिन इसके बारे में एक आवेदन पत्र ले जाएगा Pólya गणन प्रमेय (या समतुल्य कॉम्बीनेटरियल एन्यूमरेशन विधि), जिसमें मैं अच्छी तरह से वाकिफ नहीं हूं।

— जोनाथन एलन

आपने मेरी उम्मीदों को नष्ट कर दिया, जैसा कि मुझे उम्मीद थी। यह है कि आप पुनरावर्तन का उपयोग कैसे करते हैं :)

— स्टीफन

1

जावास्क्रिप्ट (ईएस 6), 199 169 167 बाइट्स

कम मामले में इनपुट स्ट्रिंग की अपेक्षा करता है। इनाम के लिए बहुत धीमी।

f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

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

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

f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

;[ "a", "in", "ab", "abc", "will", "stephen", "splitwords", "'a-r", "'''''-" ]
.map(
  s => console.log(s, '->', f(s))
)

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

सी, 403 394 बाइट्स,

धन्यवाद केविन!

r;char*g[]={"","ilI'","fjrt-","","mw","MW",0},**p,b[99];q(c){for(p=g;*p;p++)if(strchr(*p,c))return p-g;return c>='a'&&c<='z'?3:4;}f(char*w,int l){int i,n,c,t,x,y;if(*w){for(i=0;i<2;i++)x=tolower(*w),y=toupper(*w),!i||x!=y?b[l]=i%2?x:y,b[l+1]=0,f(w+1,l+1):0;}else{t=0;for(c=0;c<2;c++)for(i=0;i<l;i++){x=y=0;for(n=0;n<l;n++)c==0||n!=i?((n<i)?(x+=q(b[n])):(y+=q(b[n]))):0;t|=x==y;}r+=t;}return r;}

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

अघोषित कोड:

int getwidth(int c)
{
    char **p, *g[] = { "", "ilI'", "fjrt-", "", "mw", "MW", 0};
    for (p=g; *p; p++)
    {
        if (strchr(*p,c))
            return p-g;
    }
    return c >= 'a' && c <= 'z' ? 3 : 4;
}

int test(char* w, int l)
{
    int i, n, c, t, x, y;

    if (*w)
    {
        for (i=0;i<2; i++)
        {
            x = tolower(*w);
            y = toupper(*w);
            if (!i || x != y)
            {
                b[l] = i % 2 ? x : y;
                b[l + 1] = 0;
                test(w + 1, l+1);
            }
        }
    }
    else
    {
        t = 0;
        for (c=0; c<2; c++)
        {
            for (i=0; i<l; i++)
            {
                x = 0;
                y = 0;
                for (n=0; n<l; n++)
                {
                    if (c == 0 || n != i)
                    {
                        if (n < i)
                            x += getwidth(b[n]);
                        else
                            y += getwidth(b[n]);
                    }
                }
                t |= x == y;
            }
        }
        r += t;
    }
    return r;
}

— जोहान डू टिट
स्रोत

आप यहाँ कुछ स्थानों को भूल गए: f(char* w, int l){->f(char*w,int l){

— केविन क्रूज़सेन

Sp | Lit wo (r) dS, S (P) lit wO | rds

परिभाषाएं

इनपुट

काम

उत्पादन

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

विजय

इनाम

पायथ , 75 74 73 70 बाइट्स

व्याख्या

पहला भाग: कैसड वर्जन तैयार करना और मूल्यों को मैप करना

दूसरा भाग: काम पूरा करना

सी, 378 बाइट्स; के लिए लगभग 0.6 santidisestablishmentarianism

जावास्क्रिप्ट (ईएस 6), 199 169 167 बाइट्स

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

सी, 403 394 बाइट्स,

सी, 378 बाइट्स; के लिए लगभग 0.6 s`antidisestablishmentarianism`