Doğal Pi # 2 - Nehir

Hedef

Bir karma dizesi olan bir dize verildiğinde, toplam uzunluğunu hesaplayın ve başlangıçtan bitişe kadar olan mesafeye bölün.

Simülasyon

Neyi simüle ediyoruz? Bu makaleye göre , bir nehrin uzunluğunun başlangıç ve bitiş arasındaki mesafeye oranı yaklaşık Pi! (Bu ampirik olarak onaylanmamış olabilir, ancak verileri bulabilirim ve bu meydan okuma için bunun doğru olduğunu varsayacağız).

Bunu nasıl simüle ediyoruz?

Boşluk ve karma karakterlerin dize girişini alma
Her karmanın yanında iki tane daha olacak
- Sadece olacak ilk ve son karma hariç 1
Her karakter bir kafes noktasında bulunur (x, y)
x karakterin satırındaki dizini
- örneğin c, 4. karakter0123c567
y karakterin satır numarası
- örneğin c3. satırda:

      0line
      1line
      2line
      3c...

Bitişik karmalar arasındaki mesafeleri toplayın, arayın S
İlk ve son karmalar arasındaki mesafeyi alın, arayın D
Dönüş S/D

Şartname

Giriş
- Esnek, standart yollardan herhangi birinde (örn. İşlev parametresi, STDIN) ve herhangi bir standart biçimde (örn. String, Binary) girdi alın
Çıktı
- Esnek, standart yollardan herhangi biriyle çıktı verin (örneğin iade, baskı)
- Beyaz boşluk, sondaki ve önde gelen beyaz boşluk kabul edilebilir
- Doğruluk, lütfen en az 4 ondalık doğruluk yeri sağlayın (yani 3.1416)
puanlama
- En kısa kod kazanır!

Test Durumları

Bunlar benim nehirler hakkındaki tahminlerim. Yaklaşımlarım kötü olabilir veya bunlar nehir popülasyonunun kötü örneğidir. Ayrıca, bu hesaplamaları elle yaptım; Ben hesaplanmış özledim olabilir.

Sarı Nehir

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

1.6519

Nil Nehri

1.5498

Mississippi Nehri

1.5257

TL; DR

Bu zorluklar Pi'ye yaklaşık olarak sadece doğa ve beyninizi (ve belki de bazı yeniden kullanılabilir kaynakları) gerektiren algoritmaların simülasyonlarıdır. Zombi kıyameti sırasında Pi'ye gerçekten ihtiyacınız varsa, bu yöntemler cephaneyi boşa harcamaz ! Orada dokuz zorluklar toplam.

— NonlinearFruit
kaynak

Bunlara kendi başlarına karma denir. "Hashtag", yalnızca ile gösterilen satır içi etiketin #<tag>

— terimidir

Mesafenin Pisagor teoremi kullanılarak hesaplanması gerektiğini düşünüyorum. Bu doğru mu?

— Loovjo

Ayrıca, girdiyi satır listesi olarak alabilir miyiz?

— Loovjo

@Loovjo ^^ Öyle olabilir, Öklid geometrisidir, ancak hesaplamak istediğinizde iyidir. ^ Evet, giriş esnektir.

— NonlinearFruit

@NonlinearFruit Teşekkürler. O zaman muhtemelen ASCII sürümleri yeterince kıvrımlı değil :)

— Luis Mendo

Yanıtlar:

MATL , 48 44 42 37 33 bayt

Rahnema1'in iki kıvrımı bire bölme fikri sayesinde oldukça az bayt tasarruf edildi

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

Bu, girdiyi ;satır ayırıcı olarak bir ikili matris olarak alır . 1karmaya ve 0uzaya karşılık gelir .

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

İşte girişleri 2D karakter dizileri olarak (yine ;ayırıcı olarak) alan ve karşılık gelen ikili matrislerin dize temsillerini üreten bir format dönüştürücü .

açıklama

Bu komikti! Kod , her biri farklı bir amaç için üç iki 2D kıvrım kullanır :

Mesafeye katkıda bulunan dikey ve yatay komşuları tespit etmek 1için gerekli maske
```
0 1 0
1 0 1
0 1 0
```
Ancak her bir komşu çiftin sadece bir kez tespit edilmesini istiyoruz . Bu yüzden maskenin yarısını alıyoruz (ve son sıfır sırası kaldırılabilir):
```
0 1 0
1 0 0
```
Benzer şekilde, mesafeye katkıda bulunan diyagonal komşuları tespit etmek sqrt(2)için maske
```
1 0 1
0 0 0
1 0 1
```
ama yukarıdaki ile aynı akıl yürütme ile
```
1 0 1
0 0 0
```
Bu maske ile çarpılır sqrt(2)ve birinciye eklenirse, iki kıvrım, kombine maske ile bir kıvrım ile değiştirilebilir
```
sqrt(2) 1  sqrt(2)
1       0        0
```
Başlangıç ve bitiş noktaları, tanım gereği, sadece bir komşusu olan noktalardır. Onları tespit etmek için
```
1 1 1
1 0 1
1 1 1
```
ve hangi noktaların 1sonuç verdiğine bakın .

Madde 1'in kombine maskesini üretmek için karesini oluşturmak ve daha sonra kare kökünü almak daha kısadır. 2. maddedeki maske, önceden tanımlanmış bir değişmez değerdir.

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

— Luis Mendo
kaynak

Bazı insanlar, evrimin başarının anahtarı olduğunu söylerdi !

— flawr

Oktav, 99 bayt

@(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 cevabı ile hemen hemen aynı yöntem, ancak burada kıvrımlar çekirdeği

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

bu sqrt(2) =1.41diyagonal komşular içindir ve 1 doğrudan komşular içindir, dolayısıyla nehrin üzerindeki sonucun değerlerini topladığımızda gerçek mesafenin iki katını elde ederiz.
ungolfed sürümü :

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

Octave Online'da yapıştırmayı deneyin (yapıştırın)

— rahnema1
kaynak

İlk iki kıvrımı bir araya getirme fikriniz beni birkaç bayt kurtardı :)

— Luis Mendo

{[x y]=find(c<2&c>0),pdist([x y])}{2}çok zeki !!!

— flawr

iyi bir haber MATLAB kısıtlamaları yok!

— rahnema1

@flawr Kabul etti. Bu Octave golf ipuçları gitmek gerekir !

— Luis Mendo

@LuisMendo bazı girişler ipuçlarına dahil

— rahnema1

JavaScript (ES6), 178

Dikdörtgen biçiminde satırsonu içeren bir dize olarak girin : her satır aynı uzunlukta boşluklarla doldurulmuş (örneklerde olduğu gibi)

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))

Daha az golf

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))
)

Ölçek

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))

Snippet'i genişlet

— edc65
kaynak