16

Fibonacci domino fayansından esinlenen bu sorun, başka bir ünlü kombinasyonel diziyi temsil eden ASCII sanatı üretmekle ilgilidir.

Bir n adımlı dağ diyagramı , tam olarak n '/' ve n '\' karakterlerini kullanan bir dağ aralığının çizimidir, böylece karakterler başlangıçtaki "irtifasının" altına asla düşmeyen sürekli bir eğri çizer. Örneğin,

   /\/\
/\/    \

ve

   /\
/\/  \/\

her ikisi de 4 adımlı dağ diyagramlarıdır, ancak

/\  /\/\
  \/

değil.

Giriş

Program stdin'den n tamsayısını veya fonksiyona parametre olarak kabul etmelidir .

Çıktı

Tüm n- adım dağ diyagramlarını stdout'a yazdırın . Diyagramlar herhangi bir sırada olabilir, ancak bir tür boşlukla ayrılmalıdır. Farklı diyagramların yatay mı, dikey olarak mı çıkarılacağına karar verebilirsiniz.

Domino döşeme probleminde olduğu gibi, istediğiniz boşluğu kullanabilirsiniz. Bu, yazdırılan çıktıdan önce veya sonra ekstra yeni satırlar içerir.

Misal

N = 3 için bazı örnek geçerli çıktılar :

Geçerli çıkış A:

                                        /\
         /\             /\             /  \    /\/\
/\/\/\  /  \/\       /\/  \           /    \  /    \

Geçerli çıkış B:

   /\
/\/  \

 /\/\
/    \

/\/\/\   

  /\
 /  \
/    \

 /\
/  \/\

Geçerli çıkış C:

  /\
 /  \       /\
/    \   /\/  \
                  /\/\
 /\              /    \
/  \/\   /\/\/\

Bu kod golf; en kısa program (bayt cinsinden) kazanır.

code-golf ascii-art combinatorics

— Matt Noonan
kaynak

"Farklı diyagramların yatay mı, dikey olarak mı çıkılacağına karar verebilirsiniz" derseniz, dağ sıraları yanlara doğru olabilir mi?

— xnor

Dağ sıraları yanlara doğru olmamalıdır. Tepeler arasındaki boş gökyüzü meydan okumaya katkıda bulunuyor.

— Matt Noonan

Bazı aralıklar bir kereden fazla görünebilir mi?

— gururlu haskeller

@MattNoonan Haklısın, dağ sıralarını yatay olarak basmak kesinlikle zor oldu.

— xnor

@ proud-haskeller Her biri bir kez olmalıdır.

— Matt Noonan

10

Python 2: 151 karakter

N=2*input()
for i in range(2**N):
 L=[];c=1;exec"b=i%2;c+=2*b-1;L+=[[' ']*N];L[-1][b-c]='\/'[b];i=i/2*(c>0);"*N
 for x in(c==1)*zip(*L):print"".join(x)

#Output for n=3:




  /\  
 /  \ 
/    \




 /\/\ 
/    \




   /\ 
/\/  \




 /\   
/  \/\





/\/\/\

Vay be, bu bir karmaşa.

İlk fikir, sayıları bitlerindeki yukarı ve aşağı hareketlerin 0 to 2**N-1tüm dizilerini kodlamak için kullanmaktır N. Bu bitleri teker teker tekrarlar %2ve /2bir execdöngü içinde yineleyerek okuruz .

Koşmakta olan dağ silsilesini yan yana dizilmiş transpoze bir listede saklıyoruz L. Her zaman, biz boşlukların yeni bir satır ile yeni bir satırda bir boşluk yerini olan oluşturmak /ya da \bir yukarı veya aşağı hareket-hareket oldu bağlı olarak.

Bu alanın endeksi c, uçtan itibaren c, çalışma yüksekliğinin olduğu boşluklardır . Önden yapmak dağları baş aşağı yapar. Ayrıca byukarı ve aşağı hareketleri hizalamak için değiştiririz [b-c]. c0 yerine 1'den başlamak , bir kerelik bir hatayı düzeltir.

Davaları ortadan kaldırmak için cbaşlangıç değerinin altına düşmeleri 1, bu olduğunda, biz ayarlamak iiçin 0yapım diğer tüm hamle aşağı olmasına neden olur ki, chaline daha negatif. Ardından, bitiş tarihinin csona erdiğini kontrol ettiğimizde 1, caltına düşüp düşmediğini de kontrol ederiz . Biz sadece printeğer dağ colduğunu 1.

Yazdırmak için, zip(*L)aralığı dikeyden yataya geçiririz ve birleştirilen her dizeyi yazdırırız. Bu cevapta bir çok sorun Python'dan dizeleri değişmez olarak ele alıyor, bu yüzden onlarla karakter listeleri olarak çalıştık ve sadece baskı için dizelere kattık.

Yardım ve geliştirmeler için @flornquake'e teşekkürler.

— XNOR
kaynak

Eğer kullanmak istiyorsanız döngü ' 'yerine kullanmak " "zorundasınız exec. :) Btw, ters eğik çizgiden kaçmanıza gerek yok.

— flornquake

@flornquake Yazmayı unuttum, kullandım ' 've dizeyi bunun için bir değişkenle tırnak işaretleri ile değiştirmeyi denedim. Bu hala aralık dışı endeksi verdi:for _ in[0]*N:exec("b=i%2;c+=2*b-1;L+=[[" "]*N];L[-1][b-c]='\\/'[b];i=i//2*(c>0);")

— xnor

Demek istediğim, yazmanız gerekiyor exec("b=i%2;c+=2*b-1;L+=[[' ']*N];L[-1][b-c]='\\/'[b];i=i//2*(c>0);"), yani iç alıntılar dış olanlardan farklı olmalı.

— flornquake

Wow aptal gibi hissediyorum, bir çift tırnak değiştirdim ama diğerini değiştirmedim. Teşekkürler!

— xnor

7

APL (88)

{{⍉↑'\/'[1+⍵=1]/⍨¨¯1+2×K=⊂⌽⍳⌈/K←(⍵≠1)++\⍵}¨Z/⍨{(0=+/⍵)∧∧/0≤+\⍵}¨Z←↓⍉¯1+2×(N/2)⊤⍳2*N←2×⍵}

Çıktı n=3:

      {{⍉↑'\/'[1+⍵=1]/⍨¨¯1+2×K=⊂⌽⍳⌈/K←(⍵≠1)++\⍵}¨Z/⍨{(0=+/⍵)∧∧/0≤+\⍵}¨Z←↓⍉¯1+2×(N/2)⊤⍳2*N←2×⍵}3
 /\/\/\     /\    /\      /\/\     /\   
         /\/  \  /  \/\  /    \   /  \  
                                 /    \

Açıklama:

(N/2)⊤⍳2*N←2×⍵: Her sayı için bir bit maskesini almak 0için 2^⍵.
Z←↓⍉¯1+2×: 1yukarı ve -1aşağı vererek, 2 ile çarpın ve 1 çıkarın . Vektörlerin bir vektörünü saklayın, her vektör bir sayı için temsili içerir Z.
{... }¨Z: her bir öğesi için Z:
- ∧/0≤+\⍵: toplam tutarın asla altına düşmediğini kontrol edin 0(zemin seviyesinin altına düşmez ),
- (0=+/⍵): ve toplamın toplamı 0(zemin seviyesinde sonlanır).
{... }¨Z/⍨: Zbunun için doğru olan öğeleri seçin . Her biri için:
- K←(⍵≠1)++\⍵: her karakterin yüksekliğini bulup depolayın K. Her \birini bir tane yukarı kaldırın , böylece /s ile doğru bir şekilde hizalayın. Bu yer yüksekliğini yapar 1.
- ¯1+2×K=⊂⌽⍳⌈/K: her sütun için bir liste yapın [1..max(K)]ve bu sütundaki karakterin konumunu 1ve geri kalanını olarak işaretleyin -1. (-1 ile çoğaltma, bu konumu bir boşlukla doldurur.)
- '\/'[1+⍵=1]/⍨¨: her sütun için doğru karakteri bulun ve o sütunun listesiyle çoğaltın.
- ⍉↑: sonucu bir matrise dönüştürün ve sağ tarafı yukarı gelecek şekilde yerleştirin

— marinus
kaynak

Tamam, yatay olan!

— Matt Noonan

2

Python, 261 241 236 karakter

import itertools as I
n=input()
S={}
for q in I.permutations((-1,1)*n):
 s=0;B=[[' ']*n*2 for _ in range(n+2)];o=0
 for i in q:
    B[n-s+(i==-1)][o]=' /\\'[i];s+=i;o+=1
    if s<0:break
 else:
    for l in (B,[])[q in S]:print''.join(l)
 S[q]=1

Biraz zaman almaya başlıyor n=5...

$ echo 1 | py mountrange.py

/\



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 2 | py mountrange.py


/\/\



 /\
/  \



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 3 | py mountrange.py



/\/\/\




   /\
/\/  \




 /\
/  \/\




 /\/\
/    \



  /\
 /  \
/    \



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 4 | py mountrange.py




/\/\/\/\





     /\
/\/\/  \





   /\
/\/  \/\





   /\/\
/\/    \




    /\
   /  \
/\/    \





 /\
/  \/\/\





 /\  /\
/  \/  \





 /\/\
/    \/\





 /\/\/\
/      \




    /\
 /\/  \
/      \




  /\
 /  \
/    \/\




  /\
 /  \/\
/      \




  /\/\
 /    \
/      \



   /\
  /  \
 /    \
/      \

— Claudiu
kaynak

2

JavaScript (ES6) 159 163

Tıpkı Fibonacci Domino Tiling için cevabım gibi, n + n bitlerinin tüm dizilerini inceliyorum, 1 '/' işaretli ve 0 '' 'işaretli (sadece çıktı için, daha sonra yeni satır işaretlemek için' 2 'ekleniyor) . Ascii desenini oluştururken dengeyi kontrol ediyorum - aynı 0 ve 1 sayıları ve asla başlangıç taban çizgisinin altına inmiyorum - ve kurallara uyduklarını çıktı.

Çıktı 'uyarı' ile yapılır, bu JS kodgolf için standart ama oldukça can sıkıcı ve belki de kurallara aykırı. Console.log kullanarak karakter sayısı 165'e çıkar.

F=n=>{
  for(i=0;++i<1<<n+n;l||alert((o+'').replace(/,\d?/g,r=>'\\/\n '[r[1]||3])))
    for(p=l=o=[],j=i;l+1&&p++-n-n;j/=2)
      b=j&1,
      l-=1-b-b,
      (o[k=b+n-l]=o[k]||[2])[p]=b;
}

Daha az golf

F=n=>{
  m = n+n
  outer:
  for (i=1; i < 1<<m; i+=2)
  {
    o=[]
    l=0;
    p=1;
    for (j = 1; j <1<<m; j+=j,p++)
    {
      if (i&j)
      {
        q=o[n-l]||[]
        q[p]=1;
        o[n-l]=q
        ++l;
      }
      else
      {
        --l;
        if (l<0) continue outer;
        q=o[n-l]||[]
        q[p]=0;
        o[n-l]=q
      }
    }
    if (l==0) console.log(o.join('\n').replace(/,\d?/g,r=>'\\/'[r[1]]||' '));
  }
}

FireFox / FireBug konsolunda test edin .

F(4)

Çıktı

   /\
  /  \
 /    \
/      \ 

  /\/\
 /    \
/      \ 

    /\
 /\/  \
/      \ 

    /\
   /  \
/\/    \ 

  /\
 /  \/\
/      \ 

 /\/\/\
/      \ 

   /\/\
/\/    \ 

 /\  /\
/  \/  \ 

     /\
/\/\/  \ 

  /\
 /  \
/    \/\ 

 /\/\
/    \/\ 

   /\
/\/  \/\ 

 /\
/  \/\/\ 

/\/\/\/\

— edc65
kaynak

Herhangi bir yazdığınız sebebi varsa Meraklı -b-bve -n-nyerine -2*b?

— Steve Bennett

@SteveBennett bir sebep yok. Bazen bu desen daha kısa, ancak bu sefer değil (örneğin: 2*b+1-> b-~b)

— edc65

1

CJam, 84 bayt

q~:Q{Q[XW]*mr1\{\_@+}%_{*}*{(\{_Q\-)S*@2$m0<" /""\\"?+QS*+Q)<\}%);z{N\++}*o}{;}?1}g

Bu programın dağları sonsuz bir döngü halinde yazdırdığını, böylece çevrimiçi tercümanın size yardımcı olmayacağını unutmayın; komut satırını kullanarak çağır

java -jar cjam-0.6.2.jar mountain.cjam <<< 5

veya çevrimiçi kullanımı denemek için

q~:Q{Q[XW]*mr1\{\_@+}%_{*}*{(\{_Q\-)S*@2$m0<" /""\\"?+QS*+Q)<\}%);z{N\++}*o}{;}?}fZ

ve art arda birkaç kez çalıştır düğmesine basın ve çıktının bitiştirildiğini hayal edin.

Temel fikir, her bir yukarı ve aşağı geçişte Q boyutunda bir dağ aralığının Q olduğunu biliyoruz.

 Q[XW]*mr                                   #shuffled list of Q 1s and -1s
1        {\_@+}%                            #height map after each transition
                _{*}*                       #if it passes through 0 it's invalid

Sonra geçerliyse yazdırırız, değilse yığından çıkarırız, böylece taşmaz.

Baskı yönlendirmesi temel olarak her sütunu Q yüksekliği boşlukları, ardından sembolü, ardından Q + 1 toplam karakterlerini vurmak için yeterli boşluk oluşturur ve aralarında satırsonu olan satırları değiştirir ve yazdırırız.

z{N\++}*o                                   #transpose, insert newlines, print

— paradigmsort
kaynak

Ben bu konu üzerinde çalışırken soru, dağların her biri bir kez basılmasını zorunlu kıldı. Bu, yeniden düşünmek ve muhtemelen daha fazla karakter gerektirecektir: /

— paradigmsort

0

Cı, 179

gereksiz boşluklar hariç.

EDC65 ile benzer bir strateji. = 1 ve = 0 n*2dikkate alınarak tüm -bit ikili değerleri üzerinden çalışıyorum ./\

nHer n*3karakteri satır sonu içeren tek bir dize biçimlendiriyorum . Yazıldığı gibi dize 1000 karakter içerir, bu nedenle dağdan sonra genellikle çok fazla boşluk basılır. (Bu daha s[n*n*3]=0önce ekleyerek düzeltilebilir puts.) Her neyse, bu tüm dağın tek bir çıkışla çıkmasını sağlıyorputs kurallara uyup uymadığını kontrol ettikten sonra .

Bir işleve dönüştürmeyi ve fordaha sonra tek bir döngüye indirmeyi deneyeceğim .

i,n,x,y,q,r;
main(){
  scanf("%d",&n);
  for(i=1<<n*2;i--;){                              //run though all n*2-digit binary numbers
    char s[]={[0 ...999]=32};                      //fill an array with spaces. This syntax is allowed by GCC
    y=n;                                           //start y one square below the grid (note: r is initialised to 0 by default.)
    for(x=n*2;x--;)                                //for each digit of i
      q=i>>x&1,
      y+=q+r-1,                                    //move up if the current and last digit are 0, down if they are 1, and stay on the same line if they are different.
      y<n?s[y*n*3]=10,s[y*n*3+x+1]=92-45*q:(x=0),  //if y is within the grid, put a newline (ASCII 10)at the beginning of the row and write \ or / (ASCII 92 or 47) to the correct square. Otherwise abort the x loop.
      r=q;                                         //store the current bit of i to r as it will be needed on the next iteration 
    n-1-y||puts(s);                                //if y is on the bottom row of the grid, output the mountain 
  }
}

Çıktı (sağdaki büyük boşluk miktarına dikkat edin)

— Level Nehri St
kaynak

0

Haskell, 140 bayt

Birkaç denemenin golf oynaması başarısız olduktan sonra bu Haskell uygulamasıyla sonuçlandım. APL çözümünün 2 faktörü içinde olduğum için mutluyum!

Golf çözümü:

e=' ':e
m=[[]]:[[('/':e):map(' ':)x++('\\':e):y|k<-[0..n],x<-m!!(n-k),y<-m!!k]|n<-[0..]]
f n=putStr$unlines[map(!!(n-k))a|a<-m!!n,k<-[1..n]]

Ungolfed ve yorum yaptı:

Program özyineli olarak n- adım dağ diyagramları kümesini oluşturur . Her diyagram, yana doğru çizilen dağı ve ardından sonsuzluğa uzanan boşlukları temsil eden sonsuz uzunlukta dizelerin bir listesi ile temsil edilir. Bu, tüm diyagramların aynı yüksekliğe sahip olmasını sağlar, bu da özyinelemeyi kolaylaştırır. Dağ yazıcısı, yüksekliği sonlu bir değere bağlayan bir parametreyi kabul eder.

import Data.List (transpose)

-- Elementary picture slices, extending to infinity.
empty = ' ' : empty
up    = '/' : empty
down  = '\\': empty

-- A function which draws a mountain picture to stdout, clipping
-- its height to n.
printMtn n = putStr . unlines . reverse . take n . transpose 

{-- Combine mountain pictures x and y by

              x
 x # y  ==   / \y

--}
x # y = up : raised x ++ down : y
    where raised = map (' ':)

-- Given two sets X,Y of mountain pictures, compute the set X <> Y of all
-- combined pictures x#y for x in X, y in Y.
xs <> ys = [ x # y | x <- xs, y <- ys ]

-- Compute the (++,<>)-convolution of a list with itself, e.g.:
--   autoConvolve [x0,x1,x2] == (x2 <> x0) ++ (x1 <> x1) ++ (x0 <> x2)
autoConvolve xs = concat $ zipWith (<>) (reverse xs) xs

{--
    mtns is a list whose nth entry is the list of all n-step mountain diagrams.
    It is defined recursively by:
        --  The only 0-step mountain diagram is empty.
        --  Each (n+1)-step diagram can be uniquely drawn as x#y for
            some k-step diagram x and (n-k)-step diagram y.
--}
mtns = [[]] : [autoConvolve (prefix n) | n <- [1..]]
    where prefix n = take n mtns

-- The driver function: apply the height n mountain printer to each
-- n-step mountain diagram.  Whitespace is guaranteed by the order
-- in which the diagrams appear.
test n = mapM_ (printMtn n) $ mtns!!n

Örnek kullanım:

$ ghci mtn3.hs
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( mtn3.hs, interpreted )
Ok, modules loaded: Main.
λ> f 3
  /\  
 /  \ 
/    \

 /\/\ 
/    \

 /\   
/  \/\

   /\ 
/\/  \


/\/\/\
λ>

— Matt Noonan
kaynak

0

GolfScript 103 ( demo )

2*:§2\?,{2base.,§\-[0]*\+:a 1\{.2*@(.@+@@+}%:l$)\;),-1%{a,,{.l=2$=\a=1$+*' \\/'= }%\;n+}%\1=*l$(\;0>*}/

Program, 0 - 2 ^ (n-1) arasındaki sayıların tüm ikili gösterimlerini dağlar olarak oluşturmaya çalışan bir tamsayı parametresi alır. Geçersiz kombinasyonlar oluşturmaz (ör: 0 seviyesinin altına inenler).

— Cristian Lupascu
kaynak

Bir dizi dağ sırası çizin

Python 2: 151 karakter

APL (88)

Python, 261 241 236 karakter

JavaScript (ES6) 159 163

CJam, 84 bayt

Cı, 179

Haskell, 140 bayt

GolfScript 103 ( demo )