Yalnızca ASCII yazdırılabilir karakterler içeren ve *-string olarak adlandırılan başka bir dizeden tek bir dize çekmek için aşağıdaki kuralları kullandığımızı varsayalım . Dize, işlem durmadan önce biterse, bu bir hatadır ve bu durumda işlemin sonucu tanımsızdır:

1. İle başla d=1, s=""
2. A ile karşılaştığınızda *, 2 ile çarpın d. Başka bir karakterle karşılaştığınızda, karakteri sonuna kadar bitirin sve 1'den çıkartın d. Şimdi d=0ise durun ve geri dönüns

Tanımlanmış Örnekler :

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

Tanımsız Örnekler : (boş dizenin de bunlardan biri olacağını unutmayın)

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

İşiniz bir dize alıp *o dizeyi üreten en kısa dizeyi döndürmektir .

Program Örnekleri :

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

Programınız en az bir karakter ve yalnızca *ASCII olmayan yazdırılabilir karakterler içeren tüm dizeleri işlemelidir. İşlemin tanımsız olduğu dizeleri asla döndüremezsiniz, çünkü tanım gereği HERHANGİ dizge üretemezler.

Standart boşluklar ve G / Ç kuralları geçerlidir.

Pyth ( 36 27 bayt)

9 baytlık iyileştirme için Jakube'a teşekkürler! Şu anda çamur balıklarının cevabı kadar iyi değil , her neyse

KlzJ1VzWgKyJp\*=yJ)pN=tK=tJ

Test odası

Python'un çevirisi:

                            | 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 bayt

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

Aşağıdakileri yapan özyinelemeli işlev:

• Eğer dKalan dize uzunluğunun 2'ye eşit veya daha küçük olması :

  Çıktıya ekle *ve çarpd 2

• Başka:

  Dizgiyi kaydırın ve çıktıya ekleyin, 1'den çıkarın d.

Eylem halinde görün:

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 (Kırık fark edildi) 27 26 25 bayt

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

Gelmek için açıklama.

Test odası

C, 125 bayt

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

Bu, doğru kodlamayı çıkarmak için çok düzenli yıldız pozisyonu modelinden yararlanır. Başlangıçta bir bruteforce özyinelemeli çözüm denedim, ancak geriye bakıldığında daha basit bir matematiksel çözüm olduğu açık olmalıdır.

Aslında her zaman 2^floor(log_2(length)) , çıktınızın başlangıcında yıldızlara ve 2^ceil(log_2(length)) - lengthkarakterlerden sonra son bir yıldıza sahip olursunuz (eğer en az 1 karaktere çıkarsa).

(Hafifçe) çözülmemiş versiyon aşağıdaki gibidir

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 bayt

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)

İlk başta bunun olması abcdegerektiğini düşündüm *a**bcdeama ortaya çıktı**abc*de işe yarıyor. Bu, çıktının zemin (log₂ (s.length)) ön yıldızları ve uzunluğu iki güç olmayan dizeler için ek bir yıldız kullanılarak kolayca oluşturulduğu anlamına gelir.

Düzenleme: Önde gelen yıldız sayısını özyineli olarak hesaplayarak 8 bayt kaydedildi. Uzunluğu 1 olan özel kasa dizeleri ile 3 bayt daha kaydetti, böylece uzunluğu 2 olan bir diziyi ekstra lider bir yıldıza sahip olarak ele alabilirim.

Haskell, 68 bayt

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

Diğer cevaplarla aynı, gerçekten. EOF ise, boş bir dize çıktısı alın. Kalan uzunluk iki kattan fazlaysa d, bir yıldız ve iki kat verin d. Aksi takdirde, bir sonraki karakteri çıktılayın ve bir karakteri çıkarın d.

Ungolfed:

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