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

1. เริ่มกับ d=1, s=""
2. เมื่อใดก็ตามที่คุณพบ*คูณdโดย 2. เมื่อใดก็ตามที่คุณพบตัวละครอื่นเชื่อมไปยังจุดสิ้นสุดของและลบจากs 1 dหากตอนนี้d=0หยุดและกลับมาs

ตัวอย่างที่กำหนด :

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

ตัวอย่างที่ไม่ได้กำหนด : (โปรดทราบว่าสตริงว่างจะเป็นหนึ่งในสิ่งเหล่านี้เช่นกัน)

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

งานของคุณคือรับสตริงและคืนค่า*-string ที่สั้นที่สุดที่สร้างสตริงนั้น

ตัวอย่างโปรแกรม :

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

โปรแกรมของคุณควรจัดการกับสตริงใด ๆ ที่มีอักขระอย่างน้อยหนึ่งตัวและ*อักขระที่พิมพ์ไม่ได้ASCII เท่านั้น คุณไม่สามารถส่งคืนสตริงที่กระบวนการไม่ได้กำหนดได้เนื่องจากตามนิยามแล้วพวกเขาไม่สามารถสร้างสตริงใด ๆ ได้

มีช่องโหว่มาตรฐานและกฎ I / O

Pyth ( 36 27 ไบต์)

ขอบคุณ Jakube สำหรับการปรับปรุง 9 ไบต์! ปัจจุบันยังไม่ดีเท่าคำตอบของ muddyfishแต่อย่างใด

KlzJ1VzWgKyJp\*=yJ)pN=tK=tJ

ชุดทดสอบ

การแปลเป็นงูหลาม:

                            | 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 ไบต์

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

ฟังก์ชันเวียนเกิดที่ทำสิ่งต่อไปนี้:

• ถ้าdน้อยกว่าหรือเท่ากับความยาวสตริงที่เหลือหารด้วย 2:

  ผนวก*กับเอาต์พุตและคูณdด้วย 2

• อื่น:

  เปลี่ยนสตริงและผนวกกับการส่งออกลบ 1 dจาก

ดูการทำงาน:

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 (สังเกตเห็นเสียหาย) 27 26 25 ไบต์

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

คำอธิบายที่จะมา

ชุดทดสอบ

C, 125 ไบต์

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

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

โดยพื้นฐานแล้วคุณจะมี2^floor(log_2(length))ดาวที่จุดเริ่มต้นของการส่งออกของคุณและเป็นดาวสุดท้ายหลังจาก2^ceil(log_2(length)) - lengthตัวละคร (ถ้ามีตัวละครอย่างน้อย 1 ตัว)

รุ่น ungolfed (เล็กน้อย) มีดังนี้

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 ไบต์

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)

ตอนแรกฉันคิดว่า abcdeต้องเป็น*a**bcdeแต่มันกลับกลายเป็นว่า**abc*deใช้ได้ดีเช่นกัน ซึ่งหมายความว่าผลผลิตถูกสร้างขึ้นอย่างง่ายดายโดยใช้ดาวชั้นนำ (log₂ (s.length)) บวกกับดาวเพิ่มเติมสำหรับสตริงที่ความยาวไม่ใช่พลังของสอง

แก้ไข: บันทึก 8 ไบต์โดยการคำนวณจำนวนดาวนำซ้ำ บันทึกอีก 3 ไบต์ด้วยสายอักขระพิเศษที่มีความยาว 1 เส้นดังนั้นฉันจึงสามารถใช้สายที่มีความยาวเท่ากับ 2 ซึ่งมีดาวชั้นนำพิเศษ

Haskell, 68 ไบต์

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

เหมือนกับคำตอบอื่น ๆ จริงๆ ถ้า EOF ให้ส่งออกสตริงว่าง ถ้าความยาวที่เหลือเป็นมากกว่าสองเท่าของการส่งออกเป็นดาวและดับเบิลd dมิฉะนั้นเอาท์พุทอักขระถัดไปและลบหนึ่งdมิฉะนั้นการส่งออกตัวอักษรถัดไปและลบออกจาก

Ungolfed:

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