Kim tự tháp dây đứt


10

Cho một chuỗi n, tạo một hình chóp của chuỗi chia thành các phần so với hàng hiện tại.

Hàng đầu tiên chứa chuỗi không thay đổi.

Hàng thứ hai chứa chuỗi được tách thành hai nửa bằng một đường ống.

Hàng thứ ba phân tách nó bằng một phần ba ...

Và như thế. Độ dài của mỗi chuỗi con, trong đó l là độ dài của chuỗi n bằng

sàn (l / n)

Các ký tự còn lại được đặt trong chuỗi con riêng của họ. Hàng cuối cùng được sử dụng là hàng đầu tiên trong đó các chuỗi con có chiều dài 2.

Các trường hợp thử nghiệm:

Đầu vào: Xin chào, thế giới.

Đầu ra:

Hello, world.

Hello,| world|.

Hell|o, w|orld|.

Hel|lo,| wo|rld|.

He|ll|o,| w|or|ld|.

Đầu vào: abcdefghij

Đầu ra:

abcdefghij

abcde|fghij

abc|def|ghi|j

ab|cd|ef|gh|ij

Đầu vào: 01234567890abcdef

Đầu ra:

01234567890abcdef

01234567|890abcde|f

01234|56789|0abcd|ef

0123|4567|890a|bcde|f

012|345|678|90a|bcd|ef

01|23|45|67|89|0a|bc|de|f

Quy tắc bổ sung:

  • Bạn có thể viết một chương trình đầy đủ hoặc một hàm, tùy theo cái nào sử dụng ít mã hơn.

  • Đầu vào sẽ luôn có ít nhất 4 ký tự.

  • Bạn PHẢI sử dụng ngắt dòng nếu ngôn ngữ của bạn hỗ trợ chúng. Nếu không thể, thay thế ngắt dòng bằng:

  • Đầu vào sẽ luôn có thể in ASCII.

  • Trừ 100% nếu chương trình của bạn giải quyết P so với NP.


Bảng xếp hạng:


0 byte:return: false
Gabriel Benamy

3
Thử thách đầu tiên tốt đẹp! Một vài câu hỏi làm rõ - là đầu vào chỉ có thể in ASCII (tôi thực sự đề nghị "có")? "Ngắt dòng là cần thiết khi có thể" nghĩa là gì?
admBorkBork

3
Đó là một trò đùa. P vs NP là một vấn đề chưa được giải quyết trong điện toán. Trò đùa là nếu bạn có thể giải quyết nó, tôi sẽ ngừng quan tâm đến thực tế chương trình của bạn không giải quyết được thử thách.
Julian Lachniet

3
Vấn đề thực sự chưa được giải quyết trong điện toán là "các tab hoặc khoảng trắng" ...
FlipTack

3
Không, vấn đề thực sự là Internet Explorer.
Julian Lachniet

Câu trả lời:


0

JavaScript (ES6), 103 101 91 84 byte

Đã sửa lỗi để tôn trọng các yêu cầu thách thức

f=(s,n=0,p=s.length/++n|0)=>p>1?s.match(eval('/.{1,'+p+'}/g')).join`|`+'\n'+f(s,n):''

Lambda flấy chuỗi đầu vào làm tham số đầu tiên svà in đệ quy để điều khiển chuỗi phân tách. Khá đơn giản: miễn là độ dài chuỗi con p, trên 1, in chuỗi được chia bởi một '|' mỗi pký tự, sau đó tiến hành nối thêm cấp độ sau. Điều này sau đó gọi hàm một lần nữa pkhi được t / nthả nổi, trong đó tđộ dài chuỗi gốc và nlà một bộ chia tăng dần.


Tôi không nghĩ chia ncho 2 lần là đúng.
Neil

@Neil bạn đúng, lỗi về phía tôi. Tôi đã sửa lỗi và lưu 2 byte trong tiến trình.
XavCo7

@ETHproductions Tôi đã nghĩ về điều đó, nhưng tôi không biết liệu điều đó có được tính là STDOUT không ... Tôi đoán tôi sẽ cần phải làm alert(f(s))ngay sau đó phải không?
XavCo7

4

Perl, 46 + 1 = 47 byte

Chạy với -ncờ

say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2

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

Sự cố mã

-n                                              #Reads input into the $_ variable
say s/.{$=}(?=.)/$&|/gr while($==y///c/++$,)-2
                                 y///c          #Transliteration.  Implicitly operates on $_, replacing every character with itself and counting replacements
                                                #y///c effectively returns the length of $_
                                      /++$,     #Increments $, (which starts off at 0) and divides the length of $_ by $,
                              $==               #Stores the result of this division into $=
                                                #$= forces its contents to be an integer, so it truncates any decimal
                             (             )-2  #Returns 0 if $= is equal to 2
                        while                   #Evaluates its RHS as the condition.  If truthy, evaluates its LHS.
    s/          /   /gr                         #Substitution.  Implicitly operates on $_.
                                                #Searches for its first argument and replaces it with its second argument, repeating until it's done, and returns the new string.  $_ is not modified.
      .{$=}                                     #Looks for a string of $= characters...
           (?=.)                                #...that is followed by at least one non-newline character, but does not include this character in the match...
                 $&|                            #...and replaces it with itself followed by a pipe character.
say                                             #Output the result of the substitution.

Điều này dường như không hoạt động cho đầu vào lâu hơn.
Neil

2

Bình thường, 16 byte

Vh/lQ3j\|cQ/lQhN

V                # For N in range(1, \/ )
 h/lQ3           # 1+lenght(input)/3
      j\|        # join with '|'
         cQ      # chop input in
           /lQhN # lenght(input)/(N+1) pieces

thử ở đây


1
Điều này có thể hoạt động cho các trường hợp thử nghiệm nhưng tôi không nghĩ rằng nó hoạt động cho đầu vào lâu hơn.
Neil

2

C, 145 131 128 125 byte

l,n,i=1,j;f(char*s){l=strlen(s);puts(s);do{n=l/++i;for(j=0;j<l;)j&&(j%n||putchar('|')),putchar(s[j++]);puts("");}while(n>2);}

Đây là một hàm lấy một chuỗi làm đối số của nó và in đầu ra thành STDOUT.

l,n,i=1,j;       // declare some variables
f(char*s){       // declare the function
l=strlen(s);     // get the length of the string
puts(s);         // output the initial version, with trailing newline
do{n=l/++i;      // n is the number of characters per "section",
                 //  and we'll do-while n>2 to stop at the right time
for(j=0;j<l;)    // loop through the characters of the string
j&&(             // if j != 0,
j%n||            // and j % n == 0,
putchar('|')),   // insert a | before this character
putchar(s[j++]); // print the character
puts("");        // print a newline after the loop
}while(n>2);}

Làm thế nào để làm việc này một lần i*i>l? Có vẻ như nó sẽ bắt đầu lặp lại các phần.
Neil

@Neil Tôi không chắc ý của bạn là gì. Bạn có thể cho một ví dụ?
Doorknob

@Neil Ah, đừng bận tâm, tôi thấy những gì bạn đang nói. Điều đó dường như là một lỗ hổng trong đặc tả, trong đó nêu rõ rằng độ dài của mỗi chuỗi con là floor(l/n); Tôi không chắc hành vi dự định là gì đối với đầu vào dài hơn hoặc nếu OP dự đoán điều đó.
Doorknob

1

Bình thường, 17 byte

jmj\|cQ/lQdSh/lQ3

Giải trình

     cQ/lQ         Divide into equal pieces (with the last shorter)
  j\|              Join with pipes
 m        d        Map to each row index...
           Sh/lQ3  ... up to the first row with substrings of length 2
j                  Join with newlines

1

Javascript, 98 byte

a=>{for(b=1;2<=a.length/b;)eval("console.log(a.match(/.{1,"+(a.length/b|0)+"}/g).join('|'))"),b++}

Chức năng x(a). Gọi bằng

console.log(x("ABCDEF"))



0

Python 3, 123 byte

f=lambda s:print(*['|'.join(s[i:i+n]for i in range(0,len(s),n))for n in[len(s)//i for i in range(1,len(s)//2+1)]],sep='\n')

Ở các chuỗi dài hơn, một số phần sẽ được lặp lại, vì công thức cho độ dài của chuỗi con là floor(l/n). Ví dụ: với chuỗi dài 13 ký tự, chuỗi được chia thành 5 sẽ giống như chuỗi được chia thành 6 giây như floor(13/5)==floor(13/6). Tôi không chắc liệu OP có mong đợi điều này hay nếu đó là một sự giám sát.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.