प्राकृतिक पाई # 2 - नदी

लक्ष्य

हैश की ट्रेन के साथ एक स्ट्रिंग को देखते हुए, इसकी कुल लंबाई की गणना करें और शुरू से अंत तक दूरी से विभाजित करें।

सिमुलेशन

हम क्या अनुकरण कर रहे हैं? इस पत्र के अनुसार , शुरू और अंत के बीच की दूरी के लिए एक नदी की लंबाई का अनुपात लगभग पाई है! (यह अनुभवजन्य रूप से अस्वीकृत हो सकता है, लेकिन मुझे डेटा मिल सकता है और इस चुनौती के लिए हम मान लेंगे कि यह सच है)।

हम इसका अनुकरण कैसे कर रहे हैं?

व्हॉट्सएप और हैश का एक स्ट्रिंग इनपुट लें
प्रत्येक हैश के पास दो अन्य लोग होंगे
- पहले और आखिरी हैश के अपवाद के साथ जो केवल 1 होगा
प्रत्येक वर्ण एक जाली बिंदु पर स्थित होता है (x, y)
x अपनी लाइन में चरित्र का सूचकांक है
- उदाहरण cके लिए 4 वर्ण है0123c567
y चरित्र की पंक्ति संख्या है
- उदाहरण c3 पंक्ति पर है:

      0line
      1line
      2line
      3c...

आसन्न हैश के बीच की दूरी, इसे बुलाओ S
पहले और आखिरी हैश के बीच की दूरी लें, इसे कॉल करें D
वापसी S/D

विशिष्टता

इनपुट
- लचीले, किसी भी मानक तरीके (जैसे फ़ंक्शन पैरामीटर, एसटीडीआईएन) और किसी भी मानक प्रारूप (जैसे स्ट्रिंग, बाइनरी) में इनपुट लें
उत्पादन
- लचीले, मानक तरीकों में से किसी में आउटपुट दें (जैसे वापसी, प्रिंट)
- श्वेत स्थान, अनुगामी और प्रमुख श्वेत स्थान स्वीकार्य है
- सटीकता, कृपया सटीकता के कम से कम 4 दशमलव स्थान प्रदान करें (अर्थात 3.1416)
स्कोरिंग
- सबसे छोटा कोड जीतता है!

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

ये मेरी नदियाँ हैं। मेरे अनुमान खराब हो सकते हैं या ये मेरे नदी की आबादी का खराब नमूना हो सकते हैं। इसके अलावा, मैंने यह गणना हाथ से की थी; मैं गणना में चूक सकता था।

पीली नदी

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

1.6519

नील नदी

1.5498

मिसिसिप्पी नदी

1.5257

टी एल; डॉ

ये चुनौतियां एल्गोरिदम का अनुकरण हैं जो केवल प्रकृति और आपके मस्तिष्क (और शायद कुछ पुन: उपयोग करने योग्य संसाधनों) को लगभग अनुमानित पीआई की आवश्यकता होती है। यदि आपको ज़ोंबी सर्वनाश के दौरान पाई की आवश्यकता है, तो ये तरीके बारूद बर्बाद नहीं करते हैं ! कर रहे हैं नौ चुनौतियों कुल।

— NonlinearFruit
स्रोत

वे अपने दम पर हैश कहते हैं। "हैशटैग" सिर्फ एक इनलाइन टैग के लिए शब्द है#<tag>

— FlipTack

मेरा मानना है कि पाइथागोरस प्रमेय का उपयोग करके दूरी की गणना की जानी चाहिए। क्या ये सही है?

— लोजोवो डे

क्या हम इनपुट को लाइनों की सूची के रूप में भी ले सकते हैं?

— लवजो

@Lovjo ^ ^ यह हो सकता है, यह यूक्लिडियन ज्यामिति है, लेकिन आप गणना करना चाहते हैं कि यह ठीक है। ^ हां, इनपुट लचीला है।

— NonlinearFruit

@NonlinearFruit को धन्यवाद। फिर शायद यह है कि एएससीआईआई संस्करण पर्याप्त पापी नहीं हैं :)

— लुइस मेंडू

जवाबों:

MATL , 48 44 42 37 33 बाइट्स

काफी कुछ बाइट्स ने rahnema1 के विचार (ऑक्टेव उत्तर) के लिए धन्यवाद को बचाया, एक ही बार में दो दोषों को ढहाने का

t5BQ4B&vX^Z+*ssGt3Y6Z+1=*&fdwdYy/

यह इनपुट को बाइनरी मैट्रिक्स के ;रूप में, पंक्ति विभाजक के रूप में लेता है । 1हैश और 0अंतरिक्ष से मेल खाती है ।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यहां एक प्रारूप कनवर्टर है जो इनपुट को 2 डी चार सरणियों (फिर से, ;सेपरेटर के रूप में) के रूप में लेता है और संबंधित बाइनरी मैट्रिस के स्ट्रिंग अभ्यावेदन का उत्पादन करता है।

व्याख्या

यह मजेदार था! कोड ~~तीन~~ दो 2D-संकल्पों का उपयोग करता है , प्रत्येक एक अलग उद्देश्य के लिए:

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

आइटम 1 के संयुक्त मुखौटे का उत्पादन करने के लिए इसका वर्ग उत्पन्न करने के लिए छोटा है और फिर वर्गमूल को लें। आइटम 2 में मुखौटा एक पूर्वनिर्धारित शाब्दिक है।

t     % Take input matrix implicitly. Duplicate
5B    % 5 in binary: [1 0 1]
Q     % Add 1; [2 1 2]
4B    % 4 in binary: [1 0 0]
&v    % Concatenate vertically
X^    % Square root of each entry
Z+    % 2D convolution, maintaining size
*     % Multiply, to only keep results corresponding to 1 in the input
ss    % Sum of all matrix entries. This gives total distance
Gt    % Push input again. Duplicate
3Y6   % Predefined literal. This gives third mask
Z+    % 2D convolution, maintaining size
1=    % Values different than 1 are set to 0
*     % Multiply, to only keep results corresponding to 1 in the input
&f    % Push array of row indices and array of column indices of nonzeros
d     % Difference. This is the horizontal difference between start and end
wd    % Swap, difference. This is the vertical difference between start and end 
Yy    % Hypothenuse. This gives total distance in straight line
/     % Divide. Display implicitly

— लुइस मेंडो
स्रोत

कुछ लोग कहते थे, कि दृढ़ विश्वास सफलता की कुंजी है !

— दोष

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

@(a)sum((c=conv2(a,[s=[q=2^.5 1 q];1 0 1;s],'same').*a)(:))/2/{[x y]=find(c<2&c>0),pdist([x y])}{2}

MATL उत्तर के रूप में लगभग एक ही विधि है, लेकिन यहाँ संकल्पों का कर्नेल है

1.41 ,  1  , 1.41
1    ,  0  , 1 
1.41 ,  1  , 1.41

यह sqrt(2) =1.41विकर्ण पड़ोसियों के लिए है और 1 प्रत्यक्ष पड़ोसियों के लिए है, इसलिए जब हम नदी से अधिक परिणाम प्राप्त करते हैं तो हम वास्तविक दूरी से दोगुना हो जाते हैं।
अपंग संस्करण :

a=logical([...
0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 
1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 1 1 1 1 1 0 0 0 0 
0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 
0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ]);
sq = sqrt(2);
kernel = [...
    sq ,  1  , sq
    1  ,  0  , 1 
    sq ,  1  , sq];
%2D convolution
c=conv2(a,kernel,'same').*a;
#river length
river_length = sum(c (:))/2;
#find start and end points
[x y]=find(c<2&c>0);
# distance between start and end points
dis = pdist([x y]);
result = river_length/ dis

ऑक्टेव ऑनलाइन पर इसे आज़माएं (पेस्ट करें)

— rahnema1
स्रोत

आपका विचार पहले दो दृढ़ संकल्पों को एक में समेटने के लिए मुझे कुछ बाइट्स देने से बच गया :)

— लुइस मेंडू

{[x y]=find(c<2&c>0),pdist([x y])}{2}बहुत चालाक है !!!

— दोष

एक अच्छी खबर यह है कि हमारे पास MATLAB के प्रतिबंध नहीं हैं!

— rahnema1

@ फ़्लावर सहमत। कि ऑक्टेव गोल्फ युक्तियाँ पर जाना चाहिए !

— लुइस मेंडू

@LuisMendo कुछ प्रविष्टियों को युक्तियों में शामिल करता है

— rahnema1

जावास्क्रिप्ट (ईएस 6), 178

आयताकार रूप में newlines के साथ एक स्ट्रिंग के रूप में इनपुट : प्रत्येक पंक्ति रिक्त स्थान के साथ समान लंबाई (उदाहरणों में) के साथ गद्देदार

r=>r.replace(/#/g,(c,i)=>([d=r.search`
`,-d,++d,-d,++d,-d,1,-1].map((d,j)=>r[i+d]==c&&(--n,s+=j&2?1:Math.SQRT2),n=1),n||(v=w,w=i)),w=s=0)&&s/2/Math.hypot(v%--d-w%d,~(v/d)-~(w/d))

कम गोल्फ वाला

r=>(
  r.replace(/#/g, // exec the following for each '#' in the string
    (c,i) => // c: current char (=#), i: current position
    ( // check in 8 directions
      // note: d starts as the offset to next row, prev x position
      // and is incremented up to offset to next row, succ x position
      // note 2: there are 2 diagonal offsets, then 2 orthogonal offsets
      //         then other 2 diagonal, then 2 more orthogonal
      [d=r.search`\n`,-d, ++d,-d, ++d,-d, 1,-1].map( // for each offset
        (d,j) => // d: current offset, j: array position (0 to 7)
        r[i+d] == c && // if find a '#' at current offset ...
          ( 
            --n, // decrement n to check for 2 neighbors or just 1
            s += j & 2 ? 1 : Math.SQRT2 // add the right distance to s
          ),
      n = 1), // n starts at 1, will be -1 if 2 neighbors found, else 0
      // if n==0 we have found a start or end position, record it in v and w
      n || (v=w, w=i)
   ),
  w=s=0), // init s and w, no need to init v
  // at the end 
  // d is the length of a line + 1
  // s is twice the total length of the river
  // v and w can be used to find the x,y position of start and end
  s/2/Math.hypot(v%--d-w%d,~(v/d)-~(w/d))
)

परीक्षा

F=
r=>r.replace(/#/g,(c,i)=>([d=r.search`\n`,-d,++d,-d,++d,-d,1,-1].map((d,j)=>r[i+d]==c&&(--n,s+=j&2?1:Math.SQRT2),n=1),n||(v=w,w=i)),w=s=0)&&s/2/Math.hypot(v%--d-w%d,~(v/d)-~(w/d))

Yellow=`        ### ####           
       #   #    #          
       #       #          #
       #       #         # 
       #       #        #  
      #         #      #   
##   #          # #####    
  ##  #          #         
    ##                     `

Nile=`         #     
         #     
          #    
           #   
           #   
          #    
         #     
        #      
        #  #   
        # # #  
         #  #  
            #  
          ##   
         #     
         #     
        #      
        #      
       #       
       #       
       #       
       #       
   #  #        
  # ##         
  #            
  #            
   #           
    #          
     #         
     #         
      #        
     #         
    #          
     #         
      #        `

Missi=` ###            
#   #           
     #          
     #          
    #           
   #            
  #             
  #             
  #             
   #            
    #           
     #          
      #         
       #        
        #       
        #       
        #       
         #      
          #     
           #    
          #     
       ###      
      #         
       #        
      #         
     #          
    #           
    #           
    #           
    #           
     #          
      ##        
        #       
        #       
         ##     
           ##   
             ## 
               #
              # 
             #  
            #   
           #    
          #     
         #      
        #       
        #       
        #       
        #       
        #       
       #        
      #         
     #          
      #         
       #        
        ####    
            #   
             #  `
console.log('Yellow River',F(Yellow))
console.log('Nile River',F(Nile))
console.log('Mississippi River',F(Missi))

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

— edc65
स्रोत