Después de pasar un tiempo en este sitio, he llegado a disfrutar de que las cosas sean lo más cortas posible. Esa puede ser la razón por la que recientemente me ofenden las cadenas que contienen los mismos caracteres más de una vez. Su trabajo es escribir una función o programa que condense una cadena dada de acuerdo con las siguientes reglas:

• Comience con una condensación 0 , es decir, busque el primer par (más a la izquierda) de los mismos caracteres con otros 0 caracteres entre ellos. Si se encuentra dicho par, elimine uno de los dos caracteres y reinicie el algoritmo realizando otra condensación 0 . Si no se encuentra dicho par, continúe con el siguiente paso. Ejemplos:
  programming-C0-> programing
aabbcc-C0-> abbcc
test-C0->test

• Luego realice una 1 condensación , es decir, busque el primer par de mismos caracteres con 1 otro personaje entre ellos. Si se encuentra dicho par, elimine uno de ellos y todos los caracteres entre ellos y reinicie con una condensación 0 . Si no se encuentra dicho par, continúe con el siguiente paso. Ejemplos:
  abacac-C1-> acac
java-C1->ja

• Continúe con una 2-condensación y así sucesivamente hasta una n-condensación con n siendo la longitud de la cadena original, reiniciando cada vez después de que una condensación elimine algunas letras. Ejemplos:
  programing-C2-> praming
abcdafg-C3->afg

La cadena resultante se llama condensada y contiene cada carácter como máximo una vez.

Entrada:

Una cadena en minúscula de caracteres ascii imprimibles.

Salida:

La cadena condensada de acuerdo con las reglas anteriores.

Ejemplos:

examples     -> es
programming  -> praming
puzzles      -> puzles
codegolf     -> colf
andromeda    -> a
abcbaccbabcb -> acb
if(x==1):x++ -> if(x+
fnabnfun     -> fun
abcdefae     -> abcde

Ejemplos detallados para aclarar cómo funciona el algoritmo:

fnabnfun -C0-> fnabnfun -C1-> fnabnfun -C2-> fnfun -C0-> fnfun -C1-> fun -C0-> fun 
 -C1-> fun -C2-> ... -C8-> fun

abcbaccbabcb -C0-> abcbacbabcb -C0-> abcbacbabcb -C1-> abacbabcb -C0-> abacbabcb 
 -C1-> acbabcb -C0-> acbabcb -C1-> acbcb -C0-> acbcb -C1-> acb -C0-> acb 
 -C1-> ... -C12-> acb

Su enfoque no tiene que implementar el algoritmo desde arriba siempre que su solución y el algoritmo devuelvan la misma salida para todas las entradas permitidas. Este es un desafío de código de golf .

¡Gracias a @Linus por los útiles comentarios de sandbox!

JavaScript (ES6), 74 bytes

f=
(s,n=0,m=s.match(`(.).{${n}}\\1`))=>s[n]?m?f(s.replace(...m)):f(s,n+1):s
;

<input oninput=o.textContent=f(this.value)><pre id=o>

Perl, 38 31 30 29 bytes

Esto debería dejar atrás los idiomas ajenos al golf ...

-1 por $-[0]gracias a Riley

-1 por @{-}gracias a Dada

Incluye +1 para -p

Dar entrada sobre STDIN

condense.pl:

#!/usr/bin/perl -p
s/(.)\K.{@{-}}\1// while/./g

Esta versión de 27 bytes debería funcionar, pero no porque Perl no se interpola @-en una expresión regular (consulte /programming/39521060/why-are-etc-not-interpolated-in-strings )

#!/usr/bin/perl -p
s/(.)\K.{@-}\1// while/./g

CJam , 35 bytes

rL{_,{{(_@_@#I={I)>]sj}*}h]s}fI}j

Pruébalo en línea!

rL{                            }j   | run recursion on input
   _,{                      }fI     | for I from 0 to length(input)
      {                 }h]s        | one pass & clean up
       (_@                          | slice and store leading element A
          _@#I={      }*            | if next A is I steps away
                I)>                 | slice off I+1 element
                   ]sj              | clean up & recursion

Puede ver las condensaciones individuales insertandoed

Python 2, 117 104 101 bytes

Recursivamente hacer los reemplazos necesarios. Construyo la expresión regular dinámicamente.

import re
def f(s,i=0):t=re.sub(r"(.)%s\1"%("."*i),r"\1",s);e=s==t;return i>len(t)and t or f(t,i*e+e)

Pruébalo en línea

Perl 53 52

Incluye +1 para -p

for($i=0;$i<length;){$i=(s/(.).{$i}\1/\1/)?0:$i+1;}

Pruébalo con ideone .

Mathematica, 101 bytes

NestWhile[i=0;StringReplace[#,a_~~_~RepeatedNull~i++~~a_:>a,1]&,#,SameQ,2,ByteCount@#]&~FixedPoint~#&

Debería haber una manera de hacer esto más corto ...

PHP, 90 bytes

for($s=$argv[$c=1];$s[$i=++$i*!$c];)$s=preg_replace("#(.).{{$i}}\\1#","$1",$s,1,$c);echo$s;

o 92 bytes

for($s=$argv[1];$s[$i];$i=++$i*!$c)$s=preg_replace("#(.).{".+$i."}\\1#","$1",$s,1,$c);echo$s;   

Ruby, 75 64 57 bytes

(56 bytes de código + popción de línea de comando).

Usar interpolación de cadenas dentro de una expresión regular para controlar la longitud de las coincidencias que se reemplazan

i=0
~/(.).{#{i}}\1/?sub($&,$1)&&i=0: i+=1while i<$_.size

Prueba:

$ ruby -p condense.rb <<< fnabnfun
fun

Haskell , 97 88 bytes

(0?)
(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s<m=s|a<-s!drop m s=sum[m+1|a==s]?a

Pruébalo en línea!

Versión antigua de 97 bytes:

(a:s)!(b:t)|a==b=a:t|1<3=a:s!t
s!_=s
m?s|length s==m=s|a<-s!drop m s=(last$0:[m+1|a==s])?a
c=(0?)

Pruébalo con ideone .

Explicación:

(a:s)!(b:t)|a==b = a:t         --perform condensation
           |1<3  = a:s!t       --recursively compare further
 s   ! _         = s           --no condensation performed

La (!)función realiza una n-condensación cuando se le da una cadena una vez completa y una vez con los primeros n caracteres eliminados, por ejemplo, abcdbey cdbepara una 2-condensación, comparando recursivamente los dos caracteres iniciales.

m?s|length s==m   = s         --stop before performing length-s-condensation
   |a <- s!drop m s           --a is the m-condensation of s
    = (last$0:[m+1|a==s])?a   --disguised conditional:
                              -- if a==s       if the m-condensation did not change s
                              -- then (m+1)?a  then perform m+1-condensation
                              -- else 0?a      else restart with a 0-condensation

c=(0?)                        -- main function, initialise m with 0