Đôi khi, khi tôi thực sự chán ( thực sự chán), tôi thích vẽ một đoạn thẳng và vẽ điểm trên đó.

Đầu tiên, tôi vẽ một đoạn đường có kích thước nhất định, đó là 2 ^ N cho một số giá trị của N. Dòng sẽ được biểu thị bằng một loạt các .ký tự.

................

Sau đó, tôi vẽ một điểm ở cuối bên trái. Điểm sẽ được đại diện bởi các Xnhân vật.

X...............

Sau đó, tôi theo một mô hình. Bắt đầu từ điểm được vẽ gần đây nhất (mà tôi sẽ gọi là A), tôi tiến tới điểm được vẽ tiếp theo (B) trên dòng (bao quanh là cần thiết). Sau đó, tôi tiến tới điểm được vẽ tiếp theo trên dòng (C). Sau đó, tôi vẽ một điểm mới nửa chừng ở giữa điểm thứ ba này (C) và điểm tiếp theo đã được vẽ (D).

Bất cứ khi nào bạn quấn quanh dòng, "giữa" được xác định theo cách gói. Điểm mới được vẽ luôn nằm ở bên phải của C.

Hãy nói rằng dòng sau đây là dòng hiện tại của tôi. Đây là cách tôi sẽ vẽ hai điểm tiếp theo. Trong ví dụ này, tôi sẽ dán nhãn cho mỗi điểm quan trọng bằng một chữ cái.

X...A...X.X...X.
    ^

X...A...B.X...X.
        ^

X...A...B.C...X.
          ^

X...A...B.C...D.
            ^

X...X...X.X.A.X.
            ^

X...X...X.X.A.B.
              ^

C...X...X.X.A.B.
^

C...D...X.X.A.B.
  ^

X.A.X...X.X.X.X.
  ^

Quay trở lại ví dụ trước, điểm tiếp theo sẽ được vẽ ở giữa dòng.

X.......X.......

Đây có lẽ là một chút của một trường hợp đặc biệt: tiến tới điểm tiếp theo chỉ đơn giản là để bạn ở nơi bạn bắt đầu. Điểm giữa chừng hữu ích duy nhất là điểm nửa "chu kỳ" (điểm giữa đường trên đường), trái ngược với âm mưu một điểm trên chính nó.

Dưới đây là một loạt các điểm mà tôi sẽ vẽ trên dòng từ đây đến cuối.

X.......X.......
X.......X...X...
X.......X.X.X...
X...X...X.X.X...
X...X...X.XXX...
X.X.X...X.XXX...
X.X.X...XXXXX...

Không còn chỗ nào để vẽ điểm tiếp theo, vì nó sẽ phải được đặt giữa hai điểm liền kề, vì vậy tôi đã đạt được độ sâu tối đa cho giá trị đã cho là N = 4. Dòng cuối cùng trong danh sách trên là "hoàn thành . "

Các thách thức

Mục tiêu là viết chương trình / hàm được đặt tên ngắn nhất sẽ in / trả về dòng đã hoàn thành với giá trị đã cho là N. Trên đây cho thấy N = 4.

Đầu vào

Đầu vào sẽ là một số nguyên không âm duy nhất N. Độ dài của dòng được tạo sau đó sẽ là 2 ^ N.

Đầu ra

Đầu ra sẽ là dòng hoàn thành có độ dài 2 ^ N, được hình thành bởi .và các Xký tự. Một dòng mới không quan trọng.

Ví dụ I / O

0
X

1
XX

2
X.XX

3
X.X.XXX.

4
X.X.X...XXXXX...

5
X.X.X...X...X...X.XXX.XXX.......

Con trăn 2, 137

n=input()
l=[0]*2**n;i=0
while~i%2:i=i/2%2**n;l[i]=1;i=sum([k for k,v in enumerate(l*4)if(k>i)*v][1:3])
print''.join(['.X'[x]for x in l])

Khá đơn giản.

Bình dương, 49

Nhiều hay ít một bản dịch. Sự khác biệt chính là tôi không sử dụng danh sách đại diện cho dòng, tôi sử dụng một chuỗi.

J*\.^2QW!%Z2K%/Z2lJ=JXJK\X=Zs<tf&q\X@JT>TKU*4J2)J

Hãy thử trực tuyến .

                         Q=input(); Z=0 #implicit
J*\.^2Q                  J = "."*(2^Q)
W!%Z2                    while !(Z%2):
  K%/Z2lJ                  K=(Z/2)%(len(J))
  =JXJK\X                  change J, the point at index K is changed to a "X"
       f          U*4J     filter all elements T in [0, 1, 2, ..., 4*len(J)-1]:
        &q\X@JT>TK           where J[T]=='X' and T>K
     <t               2    only us the second and third element
  =Zs                      and store the sum to Z
)J                       end while and print J

Clip , 95

[z?zF#2(z*2*:(#2(z'.'X]'X]]n[Fa[b[q[j[r?=rirFrsrb'X]b]][t[u+*<ut*Blb/+tu2]]g+2jqg+3jq]#qa]%b'X}

GolfScript (61 byte)

~2\?,[]0{.@|$4*.@?2+1$>2<.+~<!4$,*++.2/\1&!}do;`{&!'X.'1/=}+%

Số lần lặp lại yêu cầu dường như là A061419 , nhưng vòng lặp do ngắn hơn tính toán đó. Một divmod sẽ lưu một char trong vòng lặp do. Phần cảm thấy lãng phí nhất là chuyển đổi đầu ra, nhưng tôi không thấy cách cải thiện nó.

CJam, 55 53 51 50 byte

2ri#:N'.*0aN{):U+__Nf++$_U#))>2<1bNe|2/N%|}*{'Xt}/

Một cái gì đó để bắt đầu với.

Dùng thử trực tuyến tại đây

Java, 209 207 195 191 byte

Tôi ngạc nhiên tôi đã có thể có được nó ngắn. Có lẽ vẫn còn chỗ để cải thiện. Như thường lệ, các đề xuất sẽ được đánh giá cao :)

Điều này trả về a char[]. Gọi bằng cách sử dụng a(n).

char[]a;int b,c,d,e=2;char[]a(int f){java.util.Arrays.fill(a=new char[b=1<<f],'.');for(a[0]=88;d+1<e;c=(d+e)/2,a[c%b]=88)e=b(d=b(b(c)));return a;}int b(int f){for(;;)if(a[++f%b]>87)return f;}

Thụt lề:

char[] a;
int b, c, d, e = 2;

char[] a(int f){
    java.util.Arrays.fill(
            a = new char[
                    b = 1 << f
                    ]
            , '.'
    );
    for(
            a[0] = 88;
            d + 1 < e;
                c = (d + e) / 2,
                a[c % b] = 88
        )
        e = b(
                d = b(
                        b(c)
                )
        );
    return a;
}

int b(int f){
    for (;;)
        if (a[++f % b] > 87)
            return f;
}

12 byte nhờ Peter :)
4 byte nhờ TNT;)

Haskell, 182 byte

(a:b)%(c:d)|a<c=a:b%(c:d)|1<2=c:(a:b)%d
f i=putStr$map(!(0:g[0,n..]))[0..n-1]where n=2^i;e!l|e`elem`l='X'|1<2='.';g(_:_:c:d:r)|m==c=[]|1<2=mod m n:g((d:r)%[m,m+n..])where m=div(c+d)2

Cách sử dụng : f 5. Đầu ra : X.X.X...X...X...X.XXX.XXX........

Thật không may, Haskell không có chức năng hợp nhất trong các thư viện tiêu chuẩn, vì vậy tôi phải cung cấp (-> %) của riêng mình . May mắn thay, tôi chỉ phải hợp nhất các danh sách vô hạn, vì vậy tôi không phải bao gồm các trường hợp cơ bản, tức là các danh sách trống. Nó vẫn có giá 40 byte.

Cách thức hoạt động: thay vì đặt Xs trực tiếp trong một mảng, tôi giữ một danh sách các vị trí chúng đang ở. Hơn nữa, tôi không bao bọc xung quanh 2^Nmà tiếp tục tăng các vị trí về phía vô cực (ví dụ: đối với N = 2 với một Xở phía trước, danh sách vị trí trông như thế [0,4,8,12,16,20,…]). Tôi lấy phần tử thứ 3 và thứ 4 ( cvà d), tính toán vị trí mới (c+d)/2, giữ nó cho danh sách đầu ra, hợp nhất danh sách vị trí cũ từ vị trí 4 (d ) với một vị trí mới bắt đầu (c+d)/2và tái diễn. Tôi dừng lại khi (c+d)/2bằng nhau c. Cuối cùng tôi thêm một 0vào danh sách đầu ra và in Xs tại các vị trí nhất định và .các nơi khác.

step by step example, N=2

step  position list       (c+d)/2  output     lists to merge (pos. list for next round)
                                   list       old list from d on / new list from (c+d)/2

  #1  [0,4,8,12,16,…]       10     [10]          [12,16,20,24,…] / [10,14,18,22,…]
  #2  [10,12,14,16,18,…]    15     [10,15]       [16,18,20,22,…] / [15,19,23,27,…]
  #3  [15,16,18,19,20,…]    18

stop here, because c equals (c+d)/2

add 0 to the output list: [0,10,15]
take all elements modulo 2^N: [0,2,3]
print X at position 0, 2 and 3 

Toán học, 110 102 112 108

a=Array["."&,n=2^Input[]];a[[Mod[Round@{n/2,n}//.{x_,y_,z___}/;y-x>1:>{z,x+n,(x+y)/2+n,y+n},n]+1]]="X";""<>a