16

แรงบันดาลใจจากฟีโบนัชชีโดมิโนปูกระเบื้องปัญหานี้เป็นเรื่องเกี่ยวกับการสร้างงานศิลปะ ASCII ที่เป็นตัวแทนลำดับ combinatorial ที่มีชื่อเสียงอื่น

แผนภาพ n ขั้นตอนภูเขาเป็นภาพวาดของเทือกเขาโดยใช้ว่าn '/' และn '\' ตัวละครเช่นว่าตัวละครวาดเส้นโค้งต่อเนื่องซึ่งไม่เคย dips ด้านล่างของ "ความสูง" เริ่มต้น ตัวอย่างเช่น,

   /\/\
/\/    \

และ

   /\
/\/  \/\

เป็นไดอะแกรมภูเขา 4 ขั้นตอน แต่

/\  /\/\
  \/

ไม่ใช่.

อินพุต

โปรแกรมควรยอมรับจำนวนเต็มnจาก stdin หรือเป็นพารามิเตอร์ไปยังฟังก์ชัน

เอาท์พุต

พิมพ์แผนภาพภูเขาn -step ทั้งหมดไปยัง stdout แผนภาพสามารถอยู่ในลำดับใดก็ได้ แต่ควรคั่นด้วยช่องว่างบางประเภท คุณสามารถตัดสินใจว่าไดอะแกรมที่แตกต่างกันจะถูกส่งออกในแนวนอนแนวตั้ง ฯลฯ

เช่นเดียวกับปัญหาการเรียงหน้าโดมิโนคุณสามารถใช้ช่องว่างใดก็ได้ที่คุณต้องการ ซึ่งรวมถึงการขึ้นบรรทัดใหม่พิเศษก่อนหรือหลังเอาต์พุตที่พิมพ์

ตัวอย่าง

ตัวอย่างผลลัพธ์ที่ใช้ได้สำหรับn = 3:

ผลลัพธ์ที่ถูกต้อง A:

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

เอาต์พุตที่ถูกต้อง B:

   /\
/\/  \

 /\/\
/    \

/\/\/\   

  /\
 /  \
/    \

 /\
/  \/\

เอาต์พุตที่ถูกต้อง C:

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

นี่คือรหัสกอล์ฟ โปรแกรมที่สั้นที่สุด (เป็นไบต์) ชนะ

code-golf ascii-art combinatorics

— แมตต์นูนัน
แหล่งที่มา

เมื่อคุณพูดว่า "คุณสามารถตัดสินใจได้ว่าแผนภาพที่แตกต่างกันจะถูกส่งออกในแนวนอนแนวตั้งและอื่น ๆ " เทือกเขาสามารถอยู่ข้างตัวเองได้หรือไม่?

— xnor

เทือกเขาไม่ควรอยู่ข้างตัว ฉันคิดว่าท้องฟ้าว่างเปล่าระหว่างยอดเขาเพิ่มความท้าทาย

— Matt Noonan

บางช่วงสามารถปรากฏมากกว่าหนึ่งครั้งได้หรือไม่

— ภูมิใจ haskeller

@MattNoonan คุณพูดถูกการพิมพ์แนวเทือกเขาในแนวนอนนั้นค่อนข้างยุ่งยาก

— xnor

@ proud-haskeller มันควรจะเป็นหนึ่งครั้ง

— Matt Noonan

10

Python 2: 151 ตัวอักษร

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:




  /\  
 /  \ 
/    \




 /\/\ 
/    \




   /\ 
/\/  \




 /\   
/  \/\





/\/\/\

ว้าวนี่เป็นระเบียบ

แนวคิดแรกคือการใช้ตัวเลข0 to 2**N-1เพื่อเข้ารหัสลำดับทั้งหมดของNการเลื่อนขึ้นและลงในบิตของพวกเขา เราอ่านออกบิตเหล่านี้โดยหนึ่งโดยการทำซ้ำ%2และ/2, ซ้ำในexecวง

เราจัดเก็บแนววิ่งของภูเขาในรายการสตริงที่Lถูกย้าย ทุกครั้งที่เราสร้างแถวของพื้นที่ใหม่จะแทนที่หนึ่งช่องว่างในแถวใหม่ด้วย/หรือ\ขึ้นอยู่กับว่ามีการเลื่อนขึ้นหรือลง

ดัชนีของพื้นที่นั้นคือcช่องว่างจากจุดสิ้นสุดโดยที่cความสูงที่ใช้งานอยู่ การทำจากด้านหน้าจะทำให้ภูเขาคว่ำ เรายังเปลี่ยนได้โดยการที่จะปรับตัวสูงขึ้นและย้ายลงรับb [b-c]เริ่มต้นcที่ 1 แทนที่จะเป็น 0 แก้ไขข้อผิดพลาดแบบออฟไลน์

เพื่อขจัดกรณีที่cลดลงต่ำกว่าค่าเริ่มต้น1เมื่อเกิดเหตุการณ์นี้เราตั้งiไป0ซึ่งทำให้เกิดการเคลื่อนย้ายเพิ่มเติมทั้งหมดที่จะลดลงทำให้cกลายเป็นลบมากขึ้น จากนั้นเมื่อเราตรวจสอบว่าcสิ้นสุดที่1เรายังตรวจสอบว่าcเคยลงมาด้านล่าง เราprintเทือกเขาถ้าเป็นc1

ในการพิมพ์เราจะzip(*L)ทำการเปลี่ยนช่วงจากแนวตั้งเป็นแนวนอนและพิมพ์แต่ละสตริงที่เข้าร่วม ปัญหามากมายในคำตอบนี้มาจาก Python ถือว่าสตริงไม่เปลี่ยนรูปดังนั้นเราจึงทำงานร่วมกับพวกเขาเป็นรายการของตัวละครและรวมเข้ากับสายอักขระสำหรับการพิมพ์เท่านั้น

ขอบคุณ @flornquake สำหรับความช่วยเหลือและการปรับปรุง

— XNOR
แหล่งที่มา

คุณจะต้องใช้' 'แทนถ้าคุณต้องการที่จะใช้ห่วง" " exec:) Btw คุณไม่จำเป็นต้องหลบหนีจากแบ็กสแลช

— flornquake

@flornquake ฉันลืมที่จะเขียนฉันใช้' 'และพยายามแทนที่สตริงด้วยเครื่องหมายคำพูดพร้อมตัวแปรสำหรับมัน สิ่งนี้ยังคงให้ดัชนีอยู่นอกช่วง: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

ฉันหมายถึงคุณต้องเขียนexec("b=i%2;c+=2*b-1;L+=[[' ']*N];L[-1][b-c]='\\/'[b];i=i//2*(c>0);")นั่นคือคำพูดด้านในจะต้องแตกต่างจากคำพูดภายนอก

— flornquake

@flornquake ฉันรู้สึกว่างี่เง่าฉันเปลี่ยนคู่ราคา แต่ไม่ใช่อีกคู่ ขอบคุณ!

— xnor

7

APL (88)

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

เอาท์พุทสำหรับn=3:

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

คำอธิบาย:

(N/2)⊤⍳2*N←2×⍵: ได้รับ bitfield สำหรับหมายเลขจากกันไป02^⍵
Z←↓⍉¯1+2×: คูณด้วย 2 และลบ 1 ให้1เพิ่มขึ้นและ-1ลง Zเก็บเวกเตอร์ของเวกเตอร์เวกเตอร์แต่ละที่มีตัวแทนจำนวนหนึ่งใน
{... }¨Z: สำหรับแต่ละองค์ประกอบของZ:
- ∧/0≤+\⍵: ตรวจสอบว่าผลรวมการรันไม่เคยต่ำกว่า0(ไม่ไปต่ำกว่าระดับพื้นดิน)
- (0=+/⍵): และผลรวมทั้งหมดคือ0(จบลงที่ระดับพื้นดิน)
{... }¨Z/⍨: เลือกองค์ประกอบเหล่านั้นจากZที่เป็นจริง สำหรับแต่ละคน:
- K←(⍵≠1)++\⍵: Kพบความสูงสำหรับตัวละครแต่ละตัวและเก็บไว้ใน ยกขึ้นแต่ละ\คนเพื่อให้พวกเขาสอดคล้องกับ/s อย่างถูกต้อง 1นี้จะทำให้ความสูงของพื้นดิน
- ¯1+2×K=⊂⌽⍳⌈/Kเพราะแต่ละคอลัมน์ทำรายการ[1..max(K)]และทำเครื่องหมายตำแหน่งของตัวละครในคอลัมน์ว่าด้วยและส่วนที่เหลือเป็น1 -1(การทำซ้ำโดย -1 เติมตำแหน่งนั้นด้วยช่องว่าง)
- '\/'[1+⍵=1]/⍨¨: ค้นหาอักขระที่ถูกต้องสำหรับแต่ละคอลัมน์และทำซ้ำโดยรายการสำหรับคอลัมน์นั้น
- ⍉↑: เปลี่ยนผลลัพธ์เป็นเมทริกซ์และวางด้านขวาขึ้น

— marinus
แหล่งที่มา

เอาล่ะแนวนอน!

— Matt Noonan

2

Python 261 241 236 ตัวอักษร

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

มันใช้เวลาสักพักนาน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
แหล่งที่มา

2

JavaScript (ES6) 159 163

เช่นเดียวกับคำตอบของฉันสำหรับ Fibonacci Domino Tiling ฉันตรวจสอบลำดับทั้งหมดของบิต n + n โดยมี 1 การทำเครื่องหมาย '/' และ 0 การทำเครื่องหมาย '\' (สำหรับผลลัพธ์จะเพิ่ม '2' ในภายหลังเพื่อทำเครื่องหมายบรรทัดใหม่) . ในขณะที่สร้างรูปแบบ tha ascii ฉันจะตรวจสอบยอดคงเหลือ - ตัวเลขเดียวกันคือ 0 และ 1 และไม่เคยลงไปด้านล่างบรรทัดฐานเริ่มต้น - และส่งออกสิ่งที่ปฏิบัติตามกฎ

เอาต์พุตทำด้วย 'alert' ซึ่งเป็นมาตรฐานสำหรับ codegolf JS แต่ค่อนข้างน่ารำคาญและอาจขัดกับกฎ ใช้ console.log จำนวนตัวอักษรไปที่ 165

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;
}

น้อย golfed

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

F(4)

เอาท์พุต

   /\
  /  \
 /    \
/      \ 

  /\/\
 /    \
/      \ 

    /\
 /\/  \
/      \ 

    /\
   /  \
/\/    \ 

  /\
 /  \/\
/      \ 

 /\/\/\
/      \ 

   /\/\
/\/    \ 

 /\  /\
/  \/  \ 

     /\
/\/\/  \ 

  /\
 /  \
/    \/\ 

 /\/\
/    \/\ 

   /\
/\/  \/\ 

 /\
/  \/\/\ 

/\/\/\/\

— edc65
แหล่งที่มา

อยากรู้ว่ามีเหตุผลใดที่คุณเขียน-b-bและ-n-nแทนที่จะเป็น-2*b?

— Steve Bennett

@SteveBennett ไม่มีเหตุผล บางครั้งรูปแบบนี้จะสั้นกว่า แต่ไม่ใช่ในเวลานี้ (ตัวอย่างเช่น: 2*b+1-> b-~b)

— edc65

1

CJam, 84 ไบต์

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

โปรดทราบว่าโปรแกรมนี้พิมพ์ภูเขาในวงวนไม่ จำกัด ดังนั้นล่ามออนไลน์จะไม่ช่วยคุณ เรียกใช้ที่บรรทัดคำสั่งโดยใช้

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

หรือลองใช้ออนไลน์

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

และเพียงกดปุ่มรันหลายครั้งติดต่อกันและจินตนาการว่าผลลัพธ์ถูกตัดแบ่งออก

แนวคิดพื้นฐานคือเรารู้ว่าเทือกเขาขนาด Q มีคิวของการเปลี่ยนขึ้นและลงแต่ละอัน

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

ถ้ามันถูกต้องเราพิมพ์ออกมาถ้าไม่ใช่เราจะนำมันออกมาจากกองเพื่อไม่ให้ล้น

การกำหนดเส้นทางการพิมพ์โดยทั่วไปจะสร้างแต่ละคอลัมน์เป็นช่องว่างความสูง Q แล้วตามด้วยสัญลักษณ์จากนั้นมีช่องว่างมากพอที่จะกดตัวอักษรทั้งหมด Q + 1 แล้วเราจะแปลงและพิมพ์บรรทัดที่มีการขึ้นบรรทัดใหม่ระหว่างกัน

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

— paradigmsort
แหล่งที่มา

ในขณะที่ฉันกำลังทำคำถามนี้ได้รับการชี้แจงเพื่อกำหนดให้ภูเขาพิมพ์ครั้งละครั้ง ที่จะต้องมีการคิดใหม่และอาจจะเป็นตัวละครมากขึ้น: /

— กระบวนทัศน์

0

C 179

ไม่รวมช่องว่างที่ไม่จำเป็น

กลยุทธ์ที่คล้ายกันกับ edc65 ฉันวิ่งผ่านn*2ค่าไบนารีบิตทั้งหมดโดยพิจารณา/= 1 และ\ = 0

ฉันจัดรูปแบบสายอักขระเดียวที่มีnlinebreaks ทุกn*3อักขระ ตามที่เขียนไว้สตริงมี 1,000 ตัวอักษรดังนั้นมักจะมีช่องว่างจำนวนมากที่พิมพ์หลังจากภูเขา (สิ่งนี้สามารถแก้ไขได้โดยการเพิ่มs[n*n*3]=0ก่อนหน้าputs) อย่างไรก็ตามสิ่งนี้ทำให้ฉันสามารถเอาท์พุททั้งภูเขาเพียงอันเดียวputsตรวจสอบว่าสอดคล้องกับกฎ

ฉันจะลองแปลงเป็นฟังก์ชั่นและลดการforวนซ้ำในภายหลัง

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

เอาท์พุท (บันทึกช่องว่างทางด้านขวาจำนวนมาก)

— ระดับแม่น้ำเซนต์
แหล่งที่มา

0

Haskell, 140 ไบต์

หลังจากความพยายามหลายครั้งล้มเหลวที่จะเล่นกอล์ฟได้ฉันก็ลงเอยด้วยการใช้ Haskell นี้ ฉันมีความสุขที่ได้เป็นหนึ่งในสองของโซลูชั่น APL!

สารละลายกอล์ฟ:

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 และแสดงความคิดเห็น:

โปรแกรมสร้างชุดของแผนภาพภูเขาn -step ซ้ำ แต่ละไดอะแกรมแสดงรายการของสตริงที่ยาวไม่สิ้นสุดซึ่งแสดงถึงภูเขาที่ลากไปด้านข้างตามด้วยช่องว่างที่ขยายไปถึงอินฟินิตี้ สิ่งนี้ทำให้มั่นใจได้ว่าไดอะแกรมทั้งหมดมีความสูงเท่ากันซึ่งทำให้การเรียกซ้ำง่ายขึ้น เครื่องพิมพ์ภูเขายอมรับพารามิเตอร์ที่คลิปความสูงเป็นค่า จำกัด

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

ตัวอย่างการใช้งาน:

$ 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
  /\  
 /  \ 
/    \

 /\/\ 
/    \

 /\   
/  \/\

   /\ 
/\/  \


/\/\/\
λ>

— แมตต์นูนัน
แหล่งที่มา

0

GolfScript 103 ( สาธิต )

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

โปรแกรมจะใช้พารามิเตอร์จำนวนเต็มพยายามที่จะแสดงเป็นภูเขาตัวแทนไบนารีทั้งหมดของตัวเลขจาก 0 ถึง 2 ^ (n-1) ไม่แสดงชุดค่าผสมที่ไม่ถูกต้อง (เช่นชุดที่อยู่ต่ำกว่าระดับ 0)

— Cristian Lupascu
แหล่งที่มา

วาดช่วงของภูเขา

Python 2: 151 ตัวอักษร

APL (88)

Python 261 241 236 ตัวอักษร

JavaScript (ES6) 159 163

CJam, 84 ไบต์

C 179

Haskell, 140 ไบต์

GolfScript 103 ( สาธิต )