Supponiamo di usare le seguenti regole per estrarre una singola stringa da un'altra stringa, una contenente solo caratteri stampabili ASCII e chiamata *stringa-. Se la stringa si esaurisce prima che il processo si interrompa, si tratta di un errore e il risultato del processo non è definito in quel caso:

1. Iniziare con d=1, s=""
2. Ogni volta che incontri un *, moltiplica dper 2. Ogni volta che incontri un altro personaggio, concatenalo fino alla fine di se sottrai 1 da d. Se ora d=0, fermati e ritornas

Esempi definiti :

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

Esempi indefiniti : (nota che anche la stringa vuota sarebbe una di queste)

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

Il tuo compito è prendere una stringa e restituire la stringa più *corta che produce quella stringa.

Esempi di programma :

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

Il programma dovrebbe gestire qualsiasi stringa contenente almeno un carattere e solo *caratteri stampabili non ASCII. Non è mai possibile restituire stringhe per le quali il processo non è definito, poiché per definizione non possono produrre QUALSIASI stringa.

Si applicano scappatoie standard e regole di I / O.

Pyth ( 36 27 byte)

Grazie a Jakube per un miglioramento di 9 byte! Attualmente non è buono come la risposta del pesce fangoso , ma qualunque cosa

KlzJ1VzWgKyJp\*=yJ)pN=tK=tJ

Test Suite

Traduzione di Python:

                            | 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

Funzione ricorsiva che procede come segue:

• Se dè inferiore o uguale alla lunghezza della stringa rimanente divisa per 2:

  Aggiungi *all'output e moltiplica dper 2

• Altro:

  Sposta la stringa e aggiungi all'output, sottrai 1 da d.

Guardalo in azione:

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 (notato non funzionante) 27 26 25 byte

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

Spiegazione a venire.

Test Suite

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

Questo sfrutta il modello molto regolare di posizioni delle stelle per produrre la codifica corretta. Inizialmente ho provato una soluzione ricorsiva bruteforce, ma a posteriori avrebbe dovuto essere ovvio che esisteva una soluzione matematica più semplice.

Fondamentalmente avrai sempre delle 2^floor(log_2(length))stelle all'inizio del tuo output e una stella finale dopo i 2^ceil(log_2(length)) - lengthpersonaggi (se funziona almeno 1 carattere).

La versione (leggermente) non rigata è la seguente

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)

All'inizio ho pensato che abcdedovesse essere così *a**bcdema si scopre che **abc*defunziona altrettanto bene. Ciò significa che l'output viene prontamente costruito utilizzando le stelle iniziali floor (log₂ (lunghezza s)), più una stella aggiuntiva per stringhe la cui lunghezza non è una potenza di due.

Modifica: salvato 8 byte calcolando il numero di stelle principali in modo ricorsivo. Ho salvato altri 3 byte con stringhe con involucro speciale di lunghezza 1, in modo che io possa trattare stringhe la cui lunghezza è una potenza di 2 come avere una stella in più.

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

Come le altre risposte, davvero. Se EOF, genera una stringa vuota. Se la lunghezza rimanente è più di due volted , genera una stella e una doppia d. Altrimenti, emetti il ​​carattere successivo e sottrai uno da d.

Ungolfed:

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