क्रॉसिंग शब्दों को गिनें

Question

निम्नलिखित मानक 15 × 15 क्रॉसवर्ड पहेली ग्रिड पर विचार करें ।

हम सफेद वर्गों के #लिए ब्लॉक और (स्थान) का उपयोग करके ASCII कला में इसका प्रतिनिधित्व कर सकते हैं ।

     #    #    
     #    #    
          #    
   #   #       
###     ##   ##

     ##   #    
   #       #   
    #   ##     

##   ##     ###
       #   #   
    #          
    #    #     
    #    #     

ऊपर ASCII कला प्रारूप में एक क्रॉसवर्ड ग्रिड को देखते हुए, यह निर्धारित करें कि यह कितने शब्द रखता है। (उपरोक्त ग्रिड में 78 शब्द हैं। यह पिछले सोमवार के न्यूयॉर्क टाइम्स की पहेली है ।)

एक शब्द दो या दो से अधिक लगातार रिक्त स्थान या क्षैतिज रूप से चलने वाले स्थानों का एक समूह है। एक शब्द ग्रिड के किनारे या ब्लॉक के साथ शुरू और समाप्त होता है और हमेशा ऊपर से नीचे या बाएं से दाएं, कभी भी तिरछे या पीछे की ओर नहीं चलता है। ध्यान दें कि शब्द पहेली की पूरी चौड़ाई को फैला सकते हैं, जैसा कि ऊपर की पहेली की छठी पंक्ति में है। एक शब्द का दूसरे शब्द से जुड़ा होना जरूरी नहीं है।

विवरण

• इनपुट हमेशा एक आयत होगा जिसमें वर्ण #या स्थान (स्पेस) होगा, जिसमें एक नई रेखा () द्वारा अलग की गई पंक्तियाँ होंगी \n। आप मान सकते हैं कि ग्रिड किसी भी 2 अलग मुद्रण योग्य ASCII वर्णों से बना है #और इसके बजाय ।
• आप मान सकते हैं कि एक वैकल्पिक अनुगामी न्यूलाइन है। ट्रेलिंग स्पेस कैरेक्टर डीओ गिनती करते हैं, क्योंकि वे शब्दों की संख्या को प्रभावित करते हैं।
• ग्रिड हमेशा सममित नहीं होगा, और यह सभी रिक्त स्थान या सभी ब्लॉक हो सकता है।
• आपका कार्यक्रम सैद्धांतिक रूप से किसी भी आकार के ग्रिड पर काम करने में सक्षम होना चाहिए, लेकिन इस चुनौती के लिए यह 21 × 21 से बड़ा कभी नहीं होगा।
• आप ग्रिड को इनपुट या ग्रिड वाली फ़ाइल के नाम के रूप में देख सकते हैं।
• स्टड या कमांड लाइन तर्कों और आउटपुट से स्टडआउट तक इनपुट लें।
• यदि आप चाहें, तो आप एक प्रोग्राम के बजाय एक नामित फ़ंक्शन का उपयोग कर सकते हैं, ग्रिड को एक स्ट्रिंग तर्क के रूप में ले सकते हैं और एक पूर्णांक या स्ट्रिंग को स्टडआउट या फ़ंक्शन रिटर्न के माध्यम से आउटपुट कर सकते हैं।

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

1. इनपुट:

       #
       #
       #
   

   आउटपुट: 7(प्रत्येक से पहले चार रिक्त स्थान हैं #। परिणाम वही होगा यदि प्रत्येक संख्या चिह्न हटा दिया गया था, लेकिन मार्केड स्ट्रिप्स रिक्त स्थान से अन्यथा खाली हैं।)

2. इनपुट:

   ##
    #
   ##
   

   आउटपुट: 0(एक अक्षर के शब्दों की गिनती नहीं है।)

3. इनपुट:

   ######
   #    #
     ####
   # ## #
   # ## #
   #### #
   

   आउटपुट: 4

4. इनपुट: (10 मई रविवार को एनवाई टाइम्स पहेली)

      #    ##   #       
      #    #    #       
      #         #       
          #     ###   ##
       #       #        
   ##   #   #           
           #       ##   
         #   ##         
      #        ##      #
            #   ###   ##
   #   ##         ##   #
   ##   ###   #         
   #      ##        #   
            ##   #      
      ##       #        
              #   #   ##
           #       #    
   ##   ###     #       
          #         #   
          #    #    #   
          #   ##    #   
   

   आउटपुट: 140

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर सबसे पुराना पद है।

Answer 1

सीजाम, 18 17 13 11 बाइट्स

डेनिस द्वारा बचाए गए 2 बाइट्स।

भरी हुई कोशिकाओं और 1खाली कोशिकाओं के लिए रिक्त स्थान का उपयोग करता है:

qN/_z+:~1-,

इसका परीक्षण यहां करें।

व्याख्या

q    e# Read the entire input.
N/   e# Split into lines.
_z   e# Make a copy and transpose it.
+    e# Add the lines of the two grids together.
:~   e# Evaluate each line which will push a rep-digit number for each empty-cell chunk.
1-   e# Remove all the 1s as these correspond to individual empty cells.
,    e# Get the length of the array.

Answer 2

पर्ची , 18 + 3 = 21 बाइट्स

>? ( +(X|$^)<<){2}

झंडे के साथ चलाएं no(इसलिए +3), और अंतरिक्ष का उपयोग करता है / अंतरिक्ष के Xबजाय / #। अनायास यह CJam / Pyth की तुलना में लंबा है, लेकिन मुझे लगता है कि स्लिप को विशेष रूप से गोल्फ नहीं बनाया गया था ...

इसे ऑनलाइन आज़माएं । ध्यान दें कि पहला उदाहरण कुछ लाइनों पर रिक्त स्थान गायब है।

व्याख्या

>?           Optionally turn right, hence matching either horizontally or vertically
[space]      Match a space
(    ){2}    Group, twice:
[space]+       Match 1+ spaces
(X|$^)         Either an X or the boundary of the grid
<<             Reverse the match pointer by turning left twice

nझंडा उत्पादन मैचों की संख्या प्रिंट बनाता है, और oझंडा एक ही वर्ग से शुरू ओवरलैपिंग मैचों सक्षम बनाता है। आगे-पीछे का कारण यह है क्योंकि स्लिप हर वर्ग से शुरू होने वाले मैचों की कोशिश करता है, और हम यह सुनिश्चित करना चाहते हैं कि हम केवल एक आंशिक के बजाय एक पूरी पंक्ति से मेल खाते हैं। स्लिप केवल अद्वितीय मैच लौटाता है, भले ही वे विभिन्न पदों से शुरू किए गए हों।

नोट: मूल रूप से मेरे पास था >?( +(X|$^)<<){2}, अंदर पर पहली जगह के साथ। यह कुछ मामलों को किनारे पर 2 स्थान लंबे शब्दों के साथ याद करेगा, क्योंकि सूचक इस तरह से जाएगा:

XXX       XXX       XXX       XXX
X>        X >       X<        <
XXX       XXX       XXX       XXX

[sp]    [sp]+$^    <<[sp]    [sp]+   (uh oh match fails)

Comments

दो झंडे तीन बाइट्स क्यों हैं?

— lirtosiast

@ThomasKwa मुझे लगता है कि कमांड लाइन के झंडे के साथ वर्तमान नीति यह मेटा पोस्ट है , जो कोड के सामान्य आह्वान से अंतर के रूप में बाइट्स की संख्या को गिनाती है। तो यहाँ अंतर है py -3 slip.py regex.txt input.txtऔर py -3 slip.py regex.txt input.txt no, जो तीन बाइट्स हैं (पहले की जगह सहित n)

— Sp3000

यह समझ आता है। मैं इसके बारे में सोच रहा था कि यह एक अपमानजनक दृष्टिकोण से था; कभी-कभी मैं भूल जाता हूं कि यह हमारे द्वारा गिने जाने वाले अक्षर हैं।

— lirtosiast

Answer 3

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

import Data.List
m x=sum[1|(_:_:_)<-words x]
f x=m x+m(unlines$transpose$lines x)

रिक्त कक्ष के रूप में रिक्त स्थान और किसी भी अन्य (गैर व्हाट्सएप) चरित्र के रूप में रिक्त स्थान का उपयोग करता है ।

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

Answer 4

जावास्क्रिप्ट ( ईएस 6 ) 87 121 147

इनपुट स्ट्रिंग के ट्रांसपोज़न का निर्माण करें और इसे इनपुट में जोड़ें, फिर 2 या अधिक स्थानों के स्ट्रिंग्स की गणना करें।

परीक्षण करने के लिए फ़ायरफ़ॉक्स में स्निपेट चलाएँ।

क्रेडिट @IsmaelMiguel, ES5 (122 बाइट्स) के लिए एक समाधान:

function F(z){for(r=z.split(/\n/),i=0;i<r[j=0][L='length'];i++)for(z+='#';j<r[L];)z+=r[j++][i];return~-z.split(/  +/)[L]};

F=z=>
(
  r=z.split(/\n/),
  [r.map(r=>z+=r[i],z+='#')for(i in r[0])],
  ~-z.split(/  +/).length
)

// TEST
out=x=>O.innerHTML += x + '\n';

[
'     #    #    \n     #    #    \n          #    \n   #   #       \n###     ##   ##\n               \n     ##   #    \n   #       #   \n    #   ##     \n               \n##   ##     ###\n       #   #   \n    #          \n    #    #     \n    #    #     ', '##\n #\n##', '    #\n    #\n    #',
 '######\n#    #\n  ####\n# ## #\n# ## #\n#### #',
 '   #    ##   #       \n   #    #    #       \n   #         #       \n       #     ###   ##\n    #       #        \n##   #   #           \n        #       ##   \n      #   ##         \n   #        ##      #\n         #   ###   ##\n#   ##         ##   #\n##   ###   #         \n#      ##        #   \n         ##   #      \n   ##       #        \n           #   #   ##\n        #       #    \n##   ###     #       \n       #         #   \n       #    #    #   \n       #   ##    #   '  
].forEach(x=>out(x.replace(/ /g,'.')+'\n'+F(x)+'\n'))

<pre id=O></pre>

Comments

किस बारे में F=z=>{for(r=z.split(/\n/),i=0;i<r[j=0][L='length'];i++)for(z+='#';j<r[L];)z+=r[j++][i];return~-z.split(/ +/)[L]}? यह 113 बाइट लंबा है। आपका रेगेक्स / +/(2 रिक्त स्थान) के साथ बदल दिया गया था , j=0'पैरेंट' forलूप में जोड़ा गया था और सिंटैक्स का उपयोग करने के बजाय obj.length, मैंने उपयोग करना बदल दिया L='length'; ... obj[L], जिसे 3 बार दोहराया जाता है।

— इस्माइल मिगुएल

मुझे यह es6fiddle.net/iakdcpdh (इसके बजाय F=z=>, मुझे उपयोग करना पड़ा var F=(z,i,L,j,r)=>) पर काम करने के लिए मिला । मैंने इसे IE11 पर परीक्षण किया और यह काम करता है!

— इस्माईल मिगुएल

@IsmaelMiguel अच्छा हुआ! और ES5 के लिए सबसे उपयुक्त है। इसे फिर से देखते हुए, मैंने कुछ अधिक ES6ish और कम पाया। शायद आप ES5 के लिए अपना समाधान प्रकाशित कर सकते हैं।

— edc65

नहीं, यह ठीक है। यह आपका समाधान था, मैंने इसे कम कर दिया। मुझे यह जवाब देना उचित नहीं लगता कि यह मेरा अपना था।

— इस्माइल मिगुएल

अब जब मैं इसके बारे में सोचता हूं, तो आप /\n/एक टेम्पलेट स्ट्रिंग के साथ एक वास्तविक न्यूलाइन के बीच बदल सकते हैं। 1 बाइट बचाता है क्योंकि आपको भागने का क्रम लिखना नहीं आता है।

— इस्माइल मिगुएल

Answer 5

पायथ, 15 14 13 बाइट्स

lftTcjd+.zC.z

मैं सेपरेटर के रूप में उपयोग कर रहा हूं और #पात्रों को ओपी से उनके विपरीत अर्थ के बजाय भर रहा हूं । इसे ऑनलाइन आज़माएँ: प्रदर्शन

#भरण पात्र के बजाय यह अक्षर भी स्वीकार करता है। तो आप वास्तव में हल की गई पहेली को ले सकते हैं, और यह शब्दों की संख्या को प्रिंट करेगा। और यदि आप lकमांड हटाते हैं , तो यह सभी शब्दों को प्रिंट भी करता है। इसे यहाँ टेस्ट करें: 10 मई की रविवार NY टाइम्स की पहेली

व्याख्या

        .z      all input rows
          C.z   all input columns (C transposes)
       +        add them (all rows and columns)
     jd         join by spaces
    c           split by spaces
 f              filter for pieces T, which satisfy:
  tT              len(T) > 1
l               length, implicitly printed