Giả sử chúng ta sử dụng các quy tắc sau để kéo một chuỗi từ một chuỗi khác, một chuỗi chỉ chứa các ký tự có thể in ASCII và được gọi là một *chuỗi. Nếu chuỗi hết trước khi quá trình tạm dừng, đó là một lỗi và kết quả của quá trình không được xác định trong trường hợp đó:

1. Bắt đầu với d=1, s=""
2. Bất cứ khi nào bạn gặp a *, nhân dvới 2. Bất cứ khi nào bạn gặp một nhân vật khác, hãy ghép nó vào cuối svà trừ 1 từ d. Nếu bây giờ d=0, dừng lại và trở lạis

Ví dụ được xác định :

d->d
769->7
abcd56->a
*abcd56->ab
**abcd56->abcd
*7*690->769
***abcdefghij->abcdefgh

Ví dụ không xác định : (lưu ý rằng chuỗi trống cũng sẽ là một trong số này)

*7
**769
*7*
*a*b
*

Công việc của bạn là lấy một chuỗi và trả về chuỗi ngắn nhất *tạo ra chuỗi đó.

Ví dụ chương trình :

7->7
a->a
ab->*ab
abcd->**abcd
769->*7*69

Chương trình của bạn sẽ xử lý bất kỳ chuỗi nào chứa ít nhất một ký tự và chỉ các *ký tự không thể in ASCII. Bạn không bao giờ có thể trả về các chuỗi mà quá trình không được xác định, vì theo định nghĩa, chúng không thể tạo ra bất kỳ chuỗi nào.

Lỗ hổng tiêu chuẩn và quy tắc I / O được áp dụng.

Pyth ( 36 27 byte)

Cảm ơn Jakube vì đã cải thiện 9 byte! Hiện tại không tốt như câu trả lời của bùn , nhưng bất cứ điều gì

KlzJ1VzWgKyJp\*=yJ)pN=tK=tJ

Phòng thử nghiệm

Dịch sang trăn:

                            | z=input() #occurs by default
Klz                         | K=len(z)
   J1                       | J=1
     Vz                     | for N in z:
       WgKyJ                |   while K >= J*2:
            p\*             |     print("*", end="")
               =yJ          |     J=J*2
                  )         |     #end inside while
                   pN       |   print(N, end="")
                     =tK    |   K=K-1
                        =tJ |   J=J-1

JavaScript (ES6), 61 byte

f=(s,d=2)=>s?d>s.length?s[0]+f(s.slice(1),d-2):'*'+f(s,d*2):s

Hàm đệ quy thực hiện như sau:

• Nếu dnhỏ hơn hoặc bằng độ dài chuỗi còn lại chia cho 2:

  Nối *vào đầu ra và nhân dvới 2

• Khác:

  Chuyển chuỗi và nối vào đầu ra, trừ 1 từ d.

Xem nó trong hành động:

f=(s,d=2)=>s?d>s.length?s[0]+f(s.slice(1),d-2):'*'+f(s,d*2):s

input.oninput = e => output.innerHTML = f(input.value);

<input id="input" type="text"/>
<p id="output"></p>

Pyth, 29 27 (Thông báo bị hỏng) 27 26 25 byte

+*\*sKllzXJ-^2.EKlzz?J\*k

Giải thích sắp tới.

Phòng thử nghiệm

C, 125 byte

main(int q,char**v){++v;int i=1,n=strlen(*v);while(n>(i*=2))putchar(42);for(i-=n;**v;--i,++*v)!i&&putchar(42),putchar(**v);}

Điều này tận dụng mô hình rất thường xuyên của các vị trí sao để xuất mã hóa chính xác. Ban đầu tôi đã thử một giải pháp đệ quy bruteforce, nhưng nhìn lại, rõ ràng là có một giải pháp toán học đơn giản hơn.

Về cơ bản, bạn sẽ luôn có các 2^floor(log_2(length))ngôi sao khi bắt đầu xuất và một ngôi sao cuối cùng sau các 2^ceil(log_2(length)) - lengthký tự (nếu nó hoạt động ít nhất 1 ký tự).

Phiên bản (hơi) không có bản quyền như sau

main(int q,char**v){
   ++v;                         // refer to the first command line argument
   int i=1, n=strlen(*v);       // set up iteration variables

   while(n > (i*=2))            // print the first floor(log2(n)) '*'s
      putchar(42);

   for(i-=n;  **v;  --i, ++*v)  // print the string, and the final '*'
      !i&&putchar(42),putchar(**v);
}

JavaScript (ES6), 88 77 byte

f=(s,l=s.length,p=2)=>l<2?s:p<l?"*"+f(s,l,p*2):s.slice(0,p-=l)+"*"+s.slice(p)

Lúc đầu, tôi nghĩ rằng nó abcdephải như vậy *a**bcdenhưng hóa ra nó cũng **abc*dehoạt động tốt. Điều này có nghĩa là đầu ra được xây dựng dễ dàng bằng cách sử dụng các ngôi sao hàng đầu sàn (log (s.length)), cộng với một ngôi sao bổ sung cho các chuỗi có độ dài không phải là hai lũy thừa.

Chỉnh sửa: Đã lưu 8 byte bằng cách tính toán đệ quy các ngôi sao hàng đầu. Đã lưu thêm 3 byte bằng các chuỗi có độ dài đặc biệt có độ dài 1, để tôi có thể coi các chuỗi có độ dài bằng 2 là có thêm một ngôi sao hàng đầu.

Haskell, 68 byte

f d[]=""
f d xs|length xs>=d*2='*':f(d*2)xs
f d(x:xs)=x:f(d-1)xs

Giống như các câu trả lời khác, thực sự. Nếu EOF, xuất ra một chuỗi trống. Nếu chiều dài còn lại nhiều hơn hai lần d, xuất ra một ngôi sao và gấp đôi d. Nếu không, xuất ký tự tiếp theo và trừ đi một ký tự d.

Ung dung:

f d (  [])                    = ""
f d (  xs) | length xs >= d*2 = '*' : f (d*2) xs
f d (x:xs)                    =  x  : f (d-1) xs