The Devil's Staircaseเป็นฟังก์ชั่นเศษส่วนที่เกี่ยวข้องกับชุดคันทอร์

งานของคุณคือการทำซ้ำฟังก์ชั่นขี้ขลาดนี้ - ในรูปแบบ ASCII!

อินพุต

จำนวนเต็มเดียวที่n >= 0ระบุขนาดของเอาต์พุต อินพุตอาจถูกกำหนดผ่าน STDIN, อาร์กิวเมนต์ของฟังก์ชันหรืออาร์กิวเมนต์บรรทัดคำสั่ง

เอาท์พุต

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

สำหรับขนาด0เอาต์พุตเป็นเพียง:

x

(หากคุณต้องการคุณสามารถใช้อักขระ ASCII ที่พิมพ์ได้อื่น ๆ นอกจากเว้นวรรคแทนx)

สำหรับขนาดn > 0เรา:

• ใช้ขนาดเอาต์พุตn-1และยืดแต่ละแถวออกเป็นสามส่วน
• ระลอกคลื่นระหว่างแถวของxs เดี่ยว
• เลื่อนแถวไปทางขวาเพื่อให้มีหนึ่งเดียวxในแต่ละคอลัมน์และตำแหน่งของแถวแรกxมีค่าน้อยที่สุดขณะที่ลดลงด้วยแถว

ตัวอย่างเช่นผลลัพธ์สำหรับn = 1คือ:

    x
 xxx
x

เพื่อให้ได้ผลลัพธ์n = 2เรายืดแต่ละแถวออกเป็นสามส่วน:

            xxx
   xxxxxxxxx
xxx

ระลอกคลื่นน้อยระหว่างแถวของซิงเกิลx:

x
            xxx
x
   xxxxxxxxx
x
xxx
x

เลื่อนไปทางขวา:

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

เป็นอีกหนึ่งตัวอย่างที่นี่n = 3คือ

เกณฑ์การให้คะแนน

นี่คือรหัสกอล์ฟดังนั้นการแก้ปัญหาในไบต์ที่น้อยที่สุดชนะ

Pyth, 30

jb_u+G+*leGd*HNu+N+^3hTNUQ]1]k

นี่คือโปรแกรมที่รับอินพุตจาก STDIN และใช้วิธีการของ grc ในการค้นหาชุดคันทอร์ ใช้อักขระ "เพื่อแสดงเส้นโค้ง

ลองออนไลน์ได้ที่นี่

คำอธิบาย:

ฉันจะอธิบายรหัสในสองส่วนก่อนการสร้างชุดต้นเสียง:

u+N+^3hTNUQ]1
u        UQ]1         : reduce( ... , over range(input), starting with [1])
 +N                   : lambda N,T: N + ...
   +^3hTN             : 3 ** (T+1) + N   (int + list in pyth is interpreted as [int] + list)

และการจัดรูปแบบผลลัพธ์:

jb_u+G+*leGd*HN    ]k
jb_                    : "\n".join(reversed(...)
   u               ]k  : reduce(lambda G,H: ... , over cantor set, starting with [""])
    +G+*leGd           : G + len(G[-1]) * " " + ...
            *HN        : H * '"'

โปรดทราบว่าใน pyth N = '"' โดยค่าเริ่มต้น

J ( 73 68 58 41 39 38 35 34 ตัวอักษร)

หลังจากคิดเกี่ยวกับปัญหาบางครั้งฉันพบวิธีที่แตกต่างอย่างสิ้นเชิงในการสร้างรูปแบบบันไดปีศาจ คำตอบเก่ารวมถึงคำอธิบายถูกลบแล้วคุณสามารถตรวจสอบการแก้ไขของคำตอบนี้เพื่อหาว่ามันเป็นอย่างไร

คำตอบนี้ส่งคืนอาร์เรย์ของช่องว่างและความคมชัดซึ่งแสดงถึงบันไดของมาร

' #'{~1(]|.@=@#~[:,3^q:)2}.@i.@^>:

นี่คือคำตอบที่แบ่งออกเป็นสองส่วนในรูปแบบที่ชัดเจน:

f =: 3 : '|. = (, 3 ^ 1 q: y) # y'
g =: 3 : '(f }. i. 2 ^ >: y) { '' #'''

คำอธิบาย

วิธีการนั้นแตกต่างกันเล็กน้อยดังนั้นให้สังเกตและประหลาดใจ

1. >: 3 - เพิ่มขึ้นสามครั้งนั่นคือ

   4
   

2. 2 ^ >: 3 - สองถึงพลังของการเพิ่มขึ้นสามครั้งนั่นคือ

   16
   

3. i. 2 ^ >: 3- 2 ^ >: 3จำนวนเต็มแรกนั่นคือ

   0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
   

4. }. i. 2 ^ 4- 2 ^ >: 3จำนวนเต็มแรกที่ตัดหัวนั่นคือ

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
   

   มาเรียกลำดับนี้sกัน เราเข้ามาfตอนนี้

5. 1 q: s- เลขยกกำลัง 2 sในการสลายตัวที่สำคัญของรายการของแต่ละคน โดยทั่วไปแล้วx q: yผลตอบแทนถัวเฉลี่ยตารางของเลขชี้กำลังสำหรับครั้งแรกช่วงเวลาในการย่อยสลายที่สำคัญของx yอัตราผลตอบแทนนี้:

   0
   1
   0
   2
   0
   1
   0
   3
   0
   1
   0
   2
   0
   1
   0
   

6. 3 ^ 1 q: s - สามถึงพลังของเลขชี้กำลังเหล่านี้นั่นคือ

    1
    3
    1
    9
    1
    3
    1
   27
    1
    3
    1
    9
    1
    3
    1
   

7. , 3 ^ 1 q: s- ravel (นั่นคืออาร์กิวเมนต์ที่มีโครงสร้างยุบลงในเวกเตอร์) ของผลลัพธ์ก่อนหน้า สิ่งนี้จำเป็นเพราะq:มีการแนะนำแกนต่อท้ายที่ไม่ต้องการ อัตราผลตอบแทนนี้

    1 3 1 9 1 3 1 27 1 3 1 9 1 3 1
   

8. (, 3 ^ 1 q: s) # s - แต่ละรายการของ sทำซ้ำบ่อยครั้งเท่ากับรายการที่เกี่ยวข้องในผลลัพธ์ก่อนหน้านั่นคือ

   1 2 2 2 3 4 4 4 4 4 4 4 4 4 5 6 6 6 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 10 10 10 11 12 12 12 12 12 12 12 12 12 13 14 14 14 15
   

9. = (, 3 ^ 1 q: s) # s - การจัดหมวดหมู่ตนเองของผลลัพธ์ก่อนหน้านี้คือเมทริกซ์ที่แต่ละแถวแสดงถึงหนึ่งในรายการที่ไม่ซ้ำกันของการโต้แย้งแต่ละคอลัมน์แสดงรายการที่สอดคล้องกันของการโต้แย้งและแต่ละเซลล์แสดงให้เห็นว่ารายการของแถวและคอลัมน์เท่ากัน นั่นคือ,

   1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 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 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0
   0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
   

10. |. = (, 3 ^ 1 q: s) # s - ผลลัพธ์ก่อนหน้าพลิกไปตามแกนตั้ง

11. (|. = (, 3 ^ 1 q: s) # s) { ' #'- รายการของผลลัพธ์ก่อนหน้านี้ที่ใช้เป็นดัชนีในอาร์เรย์' #'จึง0ถูกแทนที่ด้วย และ1ถูกแทนที่ด้วย#นั่นคือ

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

    ผลลัพธ์ที่เราต้องการ

Hexagony , 217 ไบต์

มันสนุกมาก ขอบคุณสำหรับการโพสต์ความท้าทายนี้

การเปิดเผยแบบเต็ม: ภาษา (Hexagony) ไม่มีอยู่ในขณะที่มีการโพสต์ความท้าทายนี้ อย่างไรก็ตามฉันไม่ได้ประดิษฐ์และภาษาไม่ได้ถูกออกแบบมาสำหรับความท้าทายนี้ (หรือความท้าทายเฉพาะอื่น ๆ )

){_2"_{\"{{""}"{'2//_.\><*\"\/_><[\]/3\'\_;|#__/(\2\'3_'}(#:|{$#{>_\//(#={/;01*&"\\_|[##={|}$_#></)]$_##|){*_.>.(/?#//~-="{}<_"=#/\}.>"%<.{#{x\"<#_/=&{./1#_#>__<_'\/"#|@_|/{=/'|\"".{/>}]#]>(_<\'{\&#|>=&{{(\=/\{*'"]<$_

วางหกเหลี่ยม:

        ) { _ 2 " _ { \ "
       { { " " } " { ' 2 /
      / _ . \ > < * \ " \ /
     _ > < [ \ ] / 3 \ ' \ _
    ; | # _ _ / ( \ 2 \ ' 3 _
   ' } ( # : | { $ # { > _ \ /
  / ( # = { / ; 0 1 * & " \ \ _
 | [ # # = { | } $ _ # > < / ) ]
$ _ # # | ) { * _ . > . ( / ? # /
 / ~ - = " { } < _ " = # / \ } .
  > " % < . { # { x \ " < # _ /
   = & { . / 1 # _ # > _ _ < _
    ' \ / " # | @ _ | / { = /
     ' | \ " " . { / > } ] #
      ] > ( _ < \ ' { \ & #
       | > = & { { ( \ = /
        \ { * ' " ] < $ _

โปรแกรมไม่ได้ใช้#คำสั่งดังนั้นฉันจึงใช้ตัวอักษรนั้นเพื่อแสดงว่าเซลล์ใดที่ไม่ได้ใช้จริง

โปรแกรมนี้ทำงานอย่างไร ขึ้นอยู่กับว่า คุณต้องการเวอร์ชั่นสั้นหรือยาวหรือไม่?

คำอธิบายสั้น ๆ

หากต้องการแสดงสิ่งที่ฉันหมายถึงโดย "บรรทัด" และ "ส่วน" ในคำอธิบายต่อไปนี้ให้พิจารณาการแยกส่วนของผลลัพธ์ที่ต้องการ

segments →
 │   │ │         │ │   │x   lines
─┼───┼─┼─────────┼─┼───┼─     ↓
 │   │ │         │ │xxx│
─┼───┼─┼─────────┼─┼───┘
 │   │ │         │x│
─┼───┼─┼─────────┼─┘
 │   │ │xxxxxxxxx│
─┼───┼─┼─────────┘
 │   │x│
─┼───┼─┘
 │xxx│
─┼───┘
x│

เมื่ออธิบายแล้วโปรแกรมจะสอดคล้องกับรหัสเทียมต่อไปนี้

n = get integer from stdin

# Calculate the number of lines we need to output.
line = pow(2, n+1)

while line > 0:
    line = line - 1

    # For all segments except the last, the character to use is spaces.
    ch = ' ' (space, ASCII 32)

    # The number of segments in each line is
    # equal to the line number, counting down.
    seg = line

    while seg > 0:
        seg = seg - 1

        # For the last segment, use x’s.
        if seg = 0:
            ch = 'x' (ASCII 120)

        # Calculate the actual segment number, where the leftmost is 1
        n = line - seg

        # Output the segment
        i = pow(3, number of times n can be divided by 2)
        i times: output ch

    output '\n' (newline, ASCII 10)

end program

คำอธิบายยาว ๆ

โปรดดูแผนภาพเส้นทางของรหัสสีนี้

การดำเนินการเริ่มต้นที่มุมซ้ายบน ลำดับของคำสั่ง){2'"''3''"2}?)ถูกดำเนินการ (รวมถึงการยกเลิกซ้ำซ้อนสองสามอย่างเช่น"{อื่น ๆ ) โดยดำเนินการตามเส้นทางที่ซับซ้อน เราเริ่มต้นด้วย Instruction Pointer # 0 เน้นด้วยสีแดงเข้ม ผ่านไปครึ่งทางเราสลับไปที่ # 1 เริ่มต้นที่มุมขวาบนและทาสีด้วยสีเขียวของป่าไม้ เมื่อ IP # 2 เริ่มทำงานในคอร์นฟลาวเวอร์สีน้ำเงิน (กลางขวา) โครงร่างหน่วยความจำคือ:

ตลอดทั้งโปรแกรมขอบที่มีเครื่องหมาย2aและ2bจะมีค่าเสมอ2(เราใช้เพื่อคำนวณ2ⁿ⁺¹และหารด้วย 2 ตามลำดับ) และขอบที่มีป้ายกำกับ3จะเป็น3 (เราใช้สิ่งนั้นในการคำนวณ 3.)

เราเข้าสู่ธุรกิจเมื่อเราเข้าสู่วงแรกของเราเน้นด้วยดอกไม้ชนิดหนึ่งสีน้ำเงิน การวนซ้ำนี้ประมวลผลคำแนะนำ(}*{=&}{=ในการคำนวณค่า2ⁿ⁺¹ เมื่อออกจากวงทางเดินสีน้ำตาลของอานจะถูกนำไปที่ Instruction Pointer # 3 ทรัพย์สินทางปัญญานี้แค่จับตามขอบด้านล่างไปทางทิศตะวันตกด้วยสีเหลืองทองและจะผ่านการควบคุมไปยังหมายเลข IP 4 ในไม่ช้า

เส้นทางสีแดงม่วงบ่งบอกว่า IP # 4 เริ่มต้นในด้านล่างซ้ายรายได้อย่างรวดเร็วจะลดลงเส้นชุดCHไป32(อักขระช่องว่าง) และsegไป (ค่าใหม่ของ) บรรทัด มันเป็นเพราะการลดลงในช่วงต้นที่เราเริ่มต้นด้วย2ⁿ⁺¹ − 1 และในที่สุดก็พบกับการวนซ้ำครั้งสุดท้ายด้วยค่า 0 จากนั้นเราป้อนที่ซ้อนกันแรกห่วง

เราหันความสนใจของเราไปยังครามที่แตกต่างกันซึ่งหลังจากที่มีการลดลงของsegสั้น ๆเราจะเห็นการปรับปรุงchเพื่อxถ้าsegเป็นศูนย์ หลังจากนั้นnถูกตั้งค่าเป็นเส้น - segเพื่อกำหนดจำนวนจริงของกลุ่มที่เราเข้ามาทันทีที่เราเข้าไปในวงอื่นคราวนี้เป็นสีที่ยุติธรรมของมะเขือเทศ

ที่นี่เราคิดออกกี่ครั้งn (หมายเลขเซกเมนต์ปัจจุบัน) สามารถหารด้วย 2 ได้ตราบใดที่โมดูโลทำให้เราเป็นศูนย์เราจะเพิ่มiและหารnด้วย 2 เมื่อเราพอใจแล้วnจะหารไม่ได้อีกต่อไป เราแยกออกเป็นสีเทาแบบกระดานชนวนซึ่งมีสองลูป: อันดับแรกมันยก 3 ถึงพลังของi ที่เราคำนวณแล้วมันก็ส่งออกchหลาย ๆ ครั้ง สังเกตว่าลูปแรกของเหล่านี้มี[คำสั่งซึ่งเปลี่ยนการควบคุมเป็น IP # 3 - ขั้นตอนเดียวที่ทำตามขั้นตอนทารกไปตามขอบด้านล่างก่อนหน้านี้ ร่างกายของลูป (คูณด้วย 3 และลดลง) ดำเนินการโดย IP ที่อ้างว้าง 3 ซึ่งถูกขังอยู่ในวงจรสีเขียวมะกอกเข้มที่ไม่รู้จบตามขอบด้านล่างของรหัส ในทำนองเดียวกันที่สองของลูปสีเทากระดานชนวนเหล่านี้มี]คำสั่งซึ่งเปิดใช้งาน IP # 5 เพื่อส่งออกchและการลดลงแสดงที่นี่ในอินเดียแดงเข้ม ในทั้งสองกรณีพอยน์เตอร์คำสั่งเหล่านั้นที่ติดอยู่ในความเป็นทาสเชื่อฟังดำเนินการหนึ่งครั้งและทำซ้ำการควบคุมกลับไปที่ IP # 4 เพียงเพื่อรอเวลาที่จะได้รับการบริการอีกครั้ง กระดานชนวนสีเทาในขณะที่เข้าร่วมกับสีแดงม่วงและสีครามพี่น้อง

เมื่อseg เข้าใกล้ศูนย์อย่างหลีกเลี่ยงไม่ได้ห่วงสีครามจะเข้าสู่เส้นทางสีเขียวของสนามหญ้าซึ่งจะแสดงเฉพาะอักขระขึ้นบรรทัดใหม่และจะรวมกลับเข้าไปในบานเย็นทันทีเพื่อให้เกิดการวนซ้ำของเส้นต่อไป นอกเหนือจากการย้ำสุดท้ายของสายห่วงอยู่เส้นทาง Ebon สั้นสีดำของยกเลิกโปรแกรมที่ดีที่สุด

Python 2, 78

L=[1]
i=3
exec"L+=[i]+L;i*=3;"*input()
while L:x=L.pop();print' '*sum(L)+'x'*x

เริ่มต้นด้วยการรายการL=[1]เราซ้ำและแทรกอำนาจต่อไปของ 3 [1, 3, 1]ที่อยู่ตรงกลางที่เกิดใน นี่คือnเวลาซ้ำแล้วซ้ำอีกเพื่อให้เรามีความยาวแถวสำหรับบันไดปีศาจ จากนั้นเราพิมพ์แต่ละแถวที่มีช่องว่าง

APL, 38

⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1

ตัวอย่าง:

      ⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1
⎕:
      2
                  x
               xxx 
              x    
     xxxxxxxxx     
    x              
 xxx               
x   

คำอธิบาย:

⊖↑'x'/⍨¨D,⍨¨0,¯1↓-+\D←{1,⍨∊1,⍪3×⍵}⍣⎕,1

                                     ⎕       ⍝ read a number from the keyboard
                       {           }⍣ ,1      ⍝ apply this function N times to [1]
                               3×⍵           ⍝ multiply each value by 3
                           ∊1,⍪               ⍝ add an 1 in front of each value
                        1,⍨                  ⍝ add an 1 to the end
                     D←                      ⍝ store values in D (lengths of rows)
                   +\                        ⍝ get running sum of D
                  -                          ⍝ negate (negative values on / give spaces)
             0,¯1↓                           ⍝ remove last item and add a 0 to the beginning
                                             ⍝ (each row needs offset of total length of preceding rows)   
         D,⍨¨                                ⍝ join each offset with each row length
   'x'/⍨¨                                    ⍝ get the right number of x-es and spaces for each row
 ↑                                           ⍝ make a matrix out of the rows
⊖                                            ⍝ mirror horizontally 

GNU sed, 142

ไม่ใช่คำตอบที่สั้นที่สุด แต่แฝงไปด้วย:

s/$/:/
:l
s/x/xxx/g
s/:/:x:/g
tb
:b
s/^1//
tl
s/:x/X/g
s/^/:/
:m
s/.*:([Xx]+)Xx*:$/&\1:/
tm
:n
s/([ :])[Xx](x*Xx*)/\1 \2/g
tn
s/:/\n/g
s/X/x/g

เพราะนี่เป็น sed (ไม่เลขคณิตพื้นเมือง) ฉันสละเสรีภาพกับกฎ"เป็นจำนวนเต็มเดียว n> = 0 แสดงให้เห็นขนาดของการส่งออก" ในกรณีนี้จำนวนเต็มอินพุทต้องเป็นสตริงของ1s ซึ่งความยาวคือ n ฉันคิดว่านี่คือ"ระบุ"ขนาดของเอาต์พุตแม้ว่าจะไม่เท่ากับตัวเลขโดยตรงกับ n ดังนั้นสำหรับ n = 2 สตริงอินพุตจะเป็น11:

$ echo 11 | sed -rf devils-staircase.sed

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

$ 

สิ่งนี้ดูเหมือนว่าจะเสร็จสมบูรณ์ด้วยความซับซ้อนของเวลาแบบเอ็กซ์โพเนนเชียลของ O (c ⁿ ) โดยที่ c ประมาณ 17 n = 8 ใช้เวลาประมาณ 45 นาทีสำหรับฉัน

อีกทางเลือกหนึ่งหากจำเป็นต้องให้ป้อนตัวเลข n ทุกประการเราสามารถทำสิ่งนี้:

sed, 274 ไบต์

s/[0-9]/<&/g
s/9/8Z/g
s/8/7Z/g
s/7/6Z/g
s/6/5Z/g
s/5/4Z/g
s/4/3Z/g
s/3/2Z/g
s/2/1Z/g
s/1/Z/g
s/0//g
:t
s/Z</<ZZZZZZZZZZ/g
tt
s/<//g
s/$/:/
:l
s/x/xxx/g
s/:/:x:/g
tb
:b
s/^Z//
tl
s/:x/X/g
s/^/:/
:m
s/.*:([Xx]+)Xx*:$/&\1:/
tm
:n
s/([ :])[Xx](x*Xx*)/\1 \2/g
tn
s/:/\n/g
s/X/x/g

เอาท์พุท:

$ echo 2 | sed -rf devils-staircase.sed

                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

$ 

Python 2, 81

def f(n,i=1,s=0):
 if i<2<<n:q=3**len(bin(i&-i))/27;f(n,i+1,s+q);print' '*s+'x'*q

รุ่นของโปรแกรม (88)

def f(n,s=0):
 if n:q=3**len(bin(n&-n))/27;f(n-1,s+q);print' '*s+'x'*q
f((2<<input())-1)

จำนวนของ x ในแถวที่n1 ที่จัดทำดัชนีไว้คือ 3 ถึงกำลังของ (ดัชนีของชุดบิตแรกในnเริ่มต้นจาก lsb)

Python 2, 74

def f(n,s=0):
 if~n:B=3**n;A=s+B-2**n;f(n-1,A+B);print' '*A+'x'*B;f(n-1,s)

แนวทางแบบเรียกซ้ำ บันไดขนาด $ n $ ปีศาจแบ่งออกเป็นสามส่วน

• สาขาแบบเรียกซ้ำซ้ายเป็นบันไดขนาด n-1ที่มีความยาว3**n - 2**n
• เส้นกลางของ x ', ความยาว3**n
• สาขาแบบเรียกซ้ำขวาเป็นบันไดขนาด n-1ที่มีความยาว3**n - 2**n

โปรดทราบว่าความยาวทั้งหมดของสามส่วนคือ 3*(3**n) - 2*(2**n)หรือ3**(n+1) - 2**(n+1)ซึ่งยืนยันการเหนี่ยวนำ

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

CJam, 36 35 33 ไบต์

นี่เป็นอีกวิธีหนึ่งของ CJam (ฉันไม่ได้ดูรหัสของเครื่องมือเพิ่มประสิทธิภาพดังนั้นฉันไม่ทราบว่าจริง ๆ แล้วมันแตกต่างกันมาก):

L0sl~{{3*0s}%0s\+}*{1$,S*\+}%W%N*

สิ่งนี้ใช้0สำหรับเส้นโค้ง อีกทางหนึ่ง (ใช้เคล็ดลับของ GRC)

LLl~){3\#a1$++}/{1$,S*\'x*+}%W%N*

xซึ่งการใช้งาน

ทดสอบที่นี่

คำอธิบาย

แนวคิดพื้นฐานคือการสร้างอาร์เรย์ด้วยแถวเช่นแรก

["0" "000" "0" "000000000" "0" "000" "0"]

จากนั้นเพื่อผ่านรายการนี้การเติมช่องว่างในปริมาณที่เหมาะสม

L0sl~{{3*0s}%0s\+}*{1$,S*\+}%W%N*
L                                 "Push an empty string for later.";
 0s                               "Push the array containing '0. This is the base case.";
   l~                             "Read and evaluate input.";
     {           }*               "Repeat the block that many times.";
      {    }%                     "Map this block onto the array.";
       3*                         "Triple the current string.";
         0s                       "Push a new zero string.";
             0s\+                 "Prepend another zero string.";
                   {       }%     "Map this block onto the result.";
                    1$            "Copy the last line.";
                      ,S*         "Get its length and make a string with that many spaces.";
                         \+       "Prepend the spaces to the current row.";
                             W%   "Reverse the rows.";
                               N* "Join them with newlines.";

รุ่นอื่น ๆ ทำงานคล้ายกัน แต่สร้างอาร์เรย์ของความยาวเช่น

[1 3 1 9 1 3 1]

แล้วเปลี่ยนมันเป็นสตริงของxs ในแผนที่สุดท้าย

Dyalog APL, 34 ตัวอักษร

ใช้วิธีการโดย grc วาดบันไดด้วย⌹อักขระ (โดมิโน) และรับอินพุตจาก stdin ⎕IO←0วิธีการแก้ปัญหานี้จะถือว่า

' ⌹'[(∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕]

• ⎕ - รับอินพุตจาก stdin
• ⌽⍳1+⎕- ลำดับของตัวเลขจาก⎕ลงมาที่ 0 (เช่น3 2 1 0)
• 3*⌽⍳1+⎕- สามต่ออำนาจของสิ่งนั้น (เช่น27 9 3 1)
• (⊢,,)/3*⌽⍳1+⎕- ผลลัพธ์ก่อนหน้านี้ถูกพับจากด้านขวาโดยฟังก์ชัน tacit ⊢,,ซึ่งเท่ากับ dfn ที่{⍵,⍺,⍵}ให้ความยาวขั้นตอนของบันไดปีศาจตามแนวทางของ grc
• {⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕ ความยาวขั้นตอนแปลงเป็นขั้นตอน
• (∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕ที่ตัวเองจัดในขณะที่ฉันแก้ปัญหา J สังเกตว่า⊖พลิกผลอย่างถูกต้องแล้ว
• ' ⌹'[(∪∘.=⊖){⍵/⍳≢⍵}⊃(⊢,,)/3*⌽⍳1+⎕] ตัวเลขที่ถูกแทนที่ด้วยช่องว่างและแต้ม

ทับทิม, 99

คำตอบที่ต่างไปจากคำตอบของฉันที่ได้รับแรงบันดาลใจจากคำตอบของ FUZxxl

FUZxxl ตั้งข้อสังเกตว่าตัวเลขของ x สอดคล้องกับจำนวนปัจจัย 2 ของดัชนี เช่น n = 2 เรามีตัวประกอบต่อไปนี้:

1 =1
2 =1 * 2
3 =3
4 =1 * 2 * 2
5 =5
6 =3 * 2
7 =7

ฉันใช้วิธีที่ค่อนข้างตรงไปตรงมามากขึ้นในการดึงพลังเหล่านี้ที่ 2: i=m&-mซึ่งให้ลำดับ1 2 1 4 1 2 1ฯลฯ ซึ่งทำงานดังนี้:

m-1เหมือนกับmบิตที่สำคัญที่สุด แต่บิตที่มีนัยสำคัญน้อยที่สุดจะกลายเป็นศูนย์และศูนย์ทั้งหมดทางขวากลายเป็น 1

เพื่อให้สามารถและสิ่งนี้กับต้นฉบับเราต้องพลิกบิต มีหลายวิธีในการทำเช่นนี้ -1วิธีหนึ่งคือการลบได้จาก

สูตรโดยรวมนั้นm& (-1 -(m-1)) ง่ายขึ้นm&(-m)

ตัวอย่าง:

          100   01100100
100-1=     99   01100011
-1-99=   -100   10011100
100&-100=   4   00000100

นี่คือรหัส: มีการนับบรรทัดใหม่การเยื้องไม่จำเป็นและไม่นับตามคำตอบอื่น ๆ ของฉัน มันยาวกว่าคำตอบอื่น ๆ เล็กน้อยของฉันเนื่องจากการแปลงซุ่มซ่ามจากฐาน 2: 1 2 1 4 1 2 1 etcถึงฐาน 3: 1 3 1 9 1 3 1 etc(มีวิธีหลีกเลี่ยงMath::หรือไม่)

def s(n)
  a=[]
  t=0
  1.upto(2*2**n-1){|m|i=3**Math::log(m&-m,2)
    a.unshift" "*t+"x"*i 
    t+=i}
  puts a
end

ทับทิม, 140 99

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

อินพุตคือโดยการเรียกใช้ฟังก์ชัน เอาท์พุทเป็นอาร์เรย์ของสตริงซึ่งทับทิมในทำเลที่สะดวกทิ้งไป stdout putsเป็นรายการขึ้นบรรทัดใหม่คั่นด้วยเดียว

อัลกอริทึมเป็นเพียงnew iteration= previous iteration+ +extra row of n**3 x's previous iterationอย่างไรก็ตามมีจำนวนมากพอ สมควรของรหัสที่เพียงเพื่อให้ได้ช่องว่างนำในผลลัพธ์ถูกต้อง

def s(n)
  a=["x"]
  1.upto(n){|m|t=" "*a[0].length
    a=a.map{|i|t+" "*3**m+i}+[t+"x"*3**m]+a}
  puts a
end

แก้ไข: Ruby, 97

สิ่งนี้ใช้วิธีที่คล้ายกัน แต่แตกต่างกันในการสร้างตารางตัวเลขของจำนวนทั้งหมดของ x ที่จำเป็นในอาร์เรย์aในลักษณะที่อธิบายไว้ข้างต้น แต่จากนั้นจึงสร้างตารางของสตริงหลังจากนั้น ตารางของสายอักขระถูกสร้างขึ้นด้านหลังในอาร์เรย์cโดยใช้unshiftวิธีการที่มีชื่อค่อนข้างแปลกในการต่อเติมอาเรย์ที่มีอยู่

ขณะนี้วิธีนี้ดูดีกว่า - เพียง 2 ไบต์เท่านั้น :-)

def s(n)
  a=c=[]
  (n+1).times{|m|a=a+[3**m]+a}
  t=0
  a.each{|i|c.unshift" "*t+"x"*i
    t+=i}
  puts c
end

Haskell, 99 ตัวอักษร

d=q.((iterate((1:).(>>=(:[1]).(*3)))[1])!!)
q[]=[];q(a:r)=sum r&' '++a&'x'++'\n':q r
(&)=replicate

ฟังก์ชั่นคือd:

λ: putStr $ d 3
                                                                x
                                                             xxx
                                                            x
                                                   xxxxxxxxx
                                                  x
                                               xxx
                                              x
                   xxxxxxxxxxxxxxxxxxxxxxxxxxx
                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

PHP - 137 ไบต์

function f($n){for($a=[];$i<=$n;array_push($a,3**$i++,...$a))$r=str_repeat;foreach($a as$v){$o=$r(' ',$s).$r(x,$v)."
$o";$s+=$v;}echo$o;}

ฉันใช้ที่นี่เคล็ดลับเช่นเดียวกับGRC นี่คือรุ่นที่ไม่ได้แต่งแต้ม:

function staircase($n)
{
    $lengthsList = [];
    for ($i = 0; $i <= $n; ++$i) {
        array_push($lengthsList, 3 ** $i, ...$lengthsList);
    }

    $output = '';
    $cumulatedLength = 0;
    foreach ($lengthsList as $length)
    {
        $output = str_repeat(' ', $cumulatedLength) . str_repeat('x', $length) . "\n" . $output;
        $cumulatedLength += $length;
    }

    echo $output;
}

C, 165

#define W while
f(n){int i=n+1,j=1<<i,k=1,l,r,s,t;W(i--)k*=3;l=k-j;W(--j){r=j,s=1;W(!(r%2))r/=2,s*=3;l-=s;t=l;W(t--)putchar(32);W(++t<s)putchar(88);putchar('\n');}}

นี่คือรหัสเดียวกันที่แกะกล่องและทำความสะอาดขึ้นเล็กน้อย:

int f(int n) {
    int i=n+1, j=1<<i, k=1;
    while (i--) k*=3;
    int l=k-j;
    while (--j) {
        int r=j,s=1;
        while (!(r%2))
            r/=2, s*=3;
        l-=s;
        int t=l;
        while (t--) putchar(' ');
        while (++t<s) putchar('X');
        putchar('\n');
    }
}

สิ่งนี้ขึ้นอยู่กับแนวคิดเดียวกันกับวิธีการแก้ปัญหาของ FUZxxl ในการใช้รูปแบบที่ชัดเจนมากกว่าที่จะบอกเป็นนัยสำหรับแถว การประกาศของ j ตั้งค่าเป็น 2 ^ (n + 1) และครั้งแรกในขณะที่ loop คำนวณ k = 3 ^ (n + 1) ดังนั้น l = 3 ^ (n + 1) -2 ^ (n + 1) คือความกว้างทั้งหมดของบันได (ซึ่งไม่ยากที่จะพิสูจน์) จากนั้นเราไปถึงตัวเลขทั้งหมด r จาก 1 ถึง 2 ^ (n + 1) -1; สำหรับแต่ละคนถ้ามันหารด้วย (^) 2 ^ n ดังนั้นเราวางแผนที่จะพิมพ์ s = 3 ^ n 'X l ถูกปรับเพื่อให้แน่ใจว่าเราเริ่มต้นจากจุดที่ถูกต้อง: เราเขียนช่องว่างและ s 'X's แล้วขึ้นบรรทัดใหม่

CJam, 46 43 41 39 36 35 ไบต์

L0ri),(a*+_W%(;+{3\#'x*+_,S*}%$1>N*

อัปเดตโดยใช้วิธีการอื่นในขณะนี้

วิธีเก่า:

]ri){3f*_,)"x"a*\]z:+}*_s,f{1$,U+:U-S*\N}

ไร้เดียงสาสวยและยาว แต่สิ่งที่จะเริ่มต้น

จะเพิ่มคำอธิบายเมื่อฉันเล่นกอล์ฟ

ลองออนไลน์ได้ที่นี่

Java, 271 269 ​​ไบต์

ใช้วิธีการของ GRC

import java.util.*;String a(int a){List<Integer>b=new ArrayList<>();int c=-1,d=1;for(;c++<a;b.add(d),b.addAll(b),b.remove(b.size()-1),d*=3);String f="";for(;b.size()>0;f+="\n"){d=b.remove(b.size()-1);for(int g:b)for(c=0;c<g;c++)f+=' ';for(c=0;c<d;c++)f+='x';}return f;}

เยื้อง:

import java.util.*;
String a(int a){
    List<Integer>b=new ArrayList<>();
    int c=-1,d=1;
    for(;c++<a;b.add(d),b.addAll(b),b.remove(b.size()-1),d*=3);
    String f="";
    for(;b.size()>0;f+="\n"){
        d=b.remove(b.size()-1);
        for(int g:b)
            for(c=0;c<g;c++)
                f+=' ';
        for(c=0;c<d;c++)
            f+='x';
    }
    return f;
}

ข้อเสนอแนะใด ๆ ยินดีต้อนรับ

2 ไบต์ขอบคุณ mbomb007

Perl, 62

#!perl -p
eval's/x+/$&$&$&
x/g,s/\d*/x
/;'x++$_;s/x+/$"x$'=~y!x!!.$&/ge

ก่อนอื่นคำนวณผลลัพธ์ซ้ำโดยไม่มีช่องว่างนำหน้า จากนั้นเพิ่มพวกเขาก่อนแต่ละบรรทัดตามจำนวนxตัวอักษรในส่วนที่เหลือของสตริง

JavaScript (ES6) 104 106 118

แก้ไขลบฟังก์ชั่นวนซ้ำรายการ '*' สำหรับแต่ละบรรทัดจะได้รับซ้ำ ๆ เล่นกับบิตและพลังของ 3 (เหมือนคำตอบอื่น ๆ )
ภายในวงสตริงหลายบรรทัดจะถูกสร้างขึ้นจากล่างขึ้นบน ของช่องว่างนำหน้าเพื่อเพิ่มในแต่ละบรรทัด

F=n=>{
  for(i=a=s='';++i<2<<n;a=s+'*'.repeat(t)+'\n'+a,s+=' '.repeat(t))
    for(t=u=1;~i&u;u*=2)t*=3;
  return a
}

ก่อนอื่นให้ลองลบออก

ฟังก์ชัน R แบบเรียกซ้ำสร้างอาเรย์ด้วยจำนวน '*' สำหรับแต่ละบรรทัด ตัวอย่างเช่น R (2) คือ[1, 3, 1, 9, 1, 3, 1]
อาเรย์นี้ถูกสแกนเพื่อสร้างสตริงหลายบรรทัดจากด้านล่างขึ้นไปทำให้นับจำนวนช่องว่างนำหน้าเพื่อเพิ่มในแต่ละบรรทัด

F=n=>
(R=n=>[1].concat(...n?R(n-1).map(n=>[n*3,1]):[]))(n)
.map(n=>a=' '.repeat(s,s-=-n)+'*'.repeat(n)+'\n'+a,a=s='')
&&a 

ทดสอบในคอนโซล Firefox / FireBug

F(3)

เอาท์พุต

                                                                *
                                                             ***
                                                            *
                                                   *********
                                                  *
                                               ***
                                              *
                   ***************************
                  *
               ***
              *
     *********
    *
 ***
*

R - 111 ตัวอักษร

การนำไปปฏิบัติอย่างตรงไปตรงมาสร้างอาร์เรย์อย่างซ้ำ ๆ และทำลายมันอย่างช้าๆ

n=scan()
a=1
if(n)for(x in 1:n)a=c(a,3^x,a)
for(A in a){cat(rep(' ',sum(a)-A),rep('x',A),'\n',sep='');a=a[-1]}

การใช้งาน:

> source('devil.r')
1: 2
2: 
Read 1 item
                  x
               xxx
              x
     xxxxxxxxx
    x
 xxx
x

ทับทิม, 93

f=->n{s,p,k=[1],1;n.times{s=s+[p=p*3]+s};k=s.dup;k.each{m=s.pop;puts' '*s.reduce(0,:+)+?x*m}}

วิธีนี้ใช้วิธีเดียวกับ grc