Reto:

Dada una cadena que solo contiene letras mayúsculas y / o minúsculas (lo que prefiera), coloque tapehorizontalmente para arreglarlo. Hacemos esto mediante la comprobación de la diferencia de dos letras adyacentes en el alfabeto (ignorando envolvente y sólo en el futuro), y llenando el espacio con tanto TAPE/ tapecomo sería necesario.

Ejemplo:

Entrada: abcmnnnopstzra
Salida:abcTAPETAPETmnnnopTAstTAPETzra

¿Por qué?

• Entre cy mdebe ser defghijkl(longitud 9), así que llenamos esto con TAPETAPET;
• Entre py sdebe ser qr(longitud 2), así que llenamos esto con TA;
• Entre ty zdebe ser uvwxy(longitud 5), así que llenamos esto con TAPET.

Reglas de desafío:

• La diferencia solo se aplica hacia adelante, por lo que no hay cinta entre ellos zra.
• Es posible tener múltiples de las mismas letras adyacentes como nnn.
• Se le permite tomar la entrada en cualquier formato razonable. Puede ser una sola cadena, cadena-matriz / lista, serie de caracteres / lista, etc. La salida tiene la misma flexibilidad.
• Puede usar minúsculas y / o mayúsculas de la forma que desee. Esto se aplica tanto a la entrada, salida y TAPE.
• Es posible que no TAPEsea ​​necesario, en cuyo caso la entrada permanece sin cambios.

Reglas generales:

• Este es el código de golf , por lo que gana la respuesta más corta en bytes.
  No permita que los lenguajes de código de golf lo desalienten de publicar respuestas con idiomas que no sean de codegolf. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados y programas completos de tipo retorno. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace a una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

Input:  "abcmnnnopstzra"
Output: "abcTAPETAPETmnnnopTAstTAPETzra"

Input:  "aza"
Output: "aTAPETAPETAPETAPETAPETAPEza"

Input:  "ghijk"
Output: "ghijk"

Input:  "aabbddeeffiiacek"
Output: "aabbTddeeffTAiiaTcTeTAPETk"

Input:  "zyxxccba"
Output: "zyxxccba"

Input:  "abccxxyz"
Output: "abccTAPETAPETAPETAPETAPExxyz"

Input:  "abtapegh"
Output: "abTAPETAPETAPETAPETtaTAPETAPETAPETApeTgh"

Input:  "tape"
Output: "taTAPETAPETAPETApe"

05AB1E , 14 12 bytes

'¡ÉIÇ¥<∍‚ζJJ

Pruébalo en línea!

Explicación

'¡É            # push the string "tape"
   I           # push input
    Ç          # convert to a list of character codes
     ¥         # calculate deltas
      <        # decrement
       ∍       # extend the string "tape" to each of these sizes
               # results in an empty string for sizes smaller than zero
        ‚ζ     # zip with input (results in a list of pairs)
          JJ   # join to a list of strings and then to a string

Jalea , 13 bytes

OI’“¡ʂƁ»ṁ$€ż@

Pruébalo en línea!

Explicación

OI '“¡ʂƁ» ṁ $ € ż @ - Programa completo. Tome una cadena como argumento de línea de comando.
O - Ordinal. Obtenga los valores ASCII de cada personaje.
 I '- Obtiene los incrementos (deltas) y resta 1 de cada uno.
          € - Por cada diferencia yo ...
   “¡ꟅƁ» ṁ $ - Moldea la "cinta" de cadena comprimida de acuerdo con estos valores.
                Básicamente extiende / acorta la "cinta" a la longitud necesaria.
           ż @ - Intercalar con la entrada.

Haskell , 58 bytes

f(x:y:r)=x:take(length[x..y]-2)(cycle"TAPE")++f(y:r)
f s=s

Pruébalo en línea! La función se frepite sobre la cadena y mira caracteres consecutivos xy y. cycle"TAPE"produce la cadena infinita "TAPETAPETAPE...". [x..y]obtiene el rango de caracteres a partir xde yincluido, así que tenemos que restar dos de la longitud. En caso de que xocurra más tarde en el alfabeto yo ambos sean del mismo carácter, obtenemos un número negativo después de restar, pero afortunadamente los takeacepta también y simplemente no toma nada.

Perl 5 , -F46 bytes

#/usr/bin/perl -F
use 5.10.0;
say map{((P,E,T,A)x7)[2..-$^H+($^H=ord)],$_}@F

Pruébalo en línea!

Python 2 , 96 87 80 bytes

lambda s:''.join(c+(C>c)*('TAPE'*6)[:ord(C)+~ord(c)]for c,C in zip(s,s[1:]+' '))

Pruébalo en línea!

Haskell , 64 bytes

t="TAPE"++t
e=fromEnum
f(x:y:z)=x:take(e y-e x-1)t++f(y:z)
f x=x

Maneja cadenas de letras mayúsculas o minúsculas, pero no ambas.

Pruébalo en línea!

C, 84 bytes

i,l;f(char*s){for(;*s;)for(putchar(l=*s++),l=s[i=0]+~l;i<l;)putchar("TAPE"[i++%4]);}

Pruébalo en línea!

C (ejecutar en el símbolo del sistema de Windows), 81 bytes

i,l;f(char*s){for(;putchar(l=*s++);)for(l=s[i=0]+~l;i<l;)putchar("TAPE"[i++%4]);}

Salida:

Python 3 , 98 bytes

lambda a:"".join(sum(zip(a,[("TAPE"*9)[:y>x and~ord(x)+ord(y)]for x,y in zip(a,a[1:])]),()))+a[-1]

Pruébalo en línea!

-1 byte gracias a Asone Tuhid

Scala , 66 bytes

(s:String)=>s./:("z"){(o,c)=>o+("TAPE"*6).take(c-o.last-1)+c}.tail

Pruébalo en línea!

Explicación

/: foldLeft over the string
("z") starting with a non-empty string to we don't have to handle the first iteration in a special way
"TAPE"*6 generate a long enough string of TAPETAPETA...
.take(c-o.last-1) take the difference between this character and the previous (now the last char in the output so far) characters from the TAPETAPETA... string. o.last will always be safe because we start with a non-empty string.
o+...+c append it to the output so far ... and add this character to the end
.tail get rid of the leading z we added

PHP , 85 bytes

$s=str_split($argv[1]);foreach($s as$l)echo str_pad($l,ord(next($s))-ord($l),'TAPE');

Pruébalo en línea!

Explicación

$s = str_split($argv[1]);   // convert the parameter string to an array
foreach($s as $l)           // loop the array
echo str_pad(               // print
  $l,                       // the letter
  ord(next($s)) - ord($l),  // calculate the distance to the next letter using ASCII values
  'TAPE'                    // padding string
);                          // profit!

Javascript, 131127 bytes

4 bytes guardados gracias a Rick Hitchcock.

z=(a=>[...a].reduce((x,y)=>x+[...Array((f=y[c='charCodeAt']()-x.slice(-1)[c]())>1?f-1:0)].reduce((e,r,t)=>e+"TAPE"[t%4],"")+y))

Desenrollado

z = a => [... a] .reduce (
  (x, y) =>
    x + [... Array (
      (f = y.charCodeAt () - (x.slice (-1) .charCodeAt ()))> 1? (f-1): 0
    )].reducir(
      (e, r, t) => 
        e + "CINTA" [t% 4], "") + y
);

Mi problema aquí es que Javascript no tenía una forma limpia de obtener la distancia entre los caracteres a y b.

<script>
  z=(a=>[...a].reduce((x,y)=>x+[...Array((f=y[c='charCodeAt']()-x.slice(-1)[c]())>1?f-1:0)].reduce((e,r,t)=>e+"TAPE"[t%4],"")+y))
</script>

<main>
  <input id="input-box" type="text">
  <pre id=output>output</pre>
</main>

<script>
  inputBox = document.getElementById("input-box");
  inputBox.addEventListener("keyup", function(e){
    output.innerText = z(inputBox.value);
  });
</script>

Python 2/3 , 70 69 bytes

f=lambda s,*t:t and s+('TAPE'*6)[:max(ord(t[0])+~ord(s),0)]+f(*t)or s

Pruébalo en línea!

Carbón de leña , 20 bytes

⭆θ⁺…TAPE∧κ⊖⁻℅ι℅§θ⊖κι

Pruébalo en línea! Explicación:

 θ              θ       Input string
⭆                       Map over characters
                  κ     Current index
                 ⊖      Decremented
               §        Index into string
             ι          Current character
            ℅ ℅         Ordinal
           ⁻            Subtract
          ⊖             Decremented
         κ              Current index
        ∧               Logical and
    TAPE                Literal string
   …                    Mold to length
                   ι    Current character
  ⁺                     Concatenate
                        Implicitly print

Pip , 29 bytes

O@a{"TAPE"@<MX[0v-$-Ag]}.BMPa

Toma la entrada como un argumento de línea de comandos (en mayúsculas o minúsculas, no importa). Pruébalo en línea!

Explicación

O@a{"TAPE"@<MX[0v-$-Ag]}.BMPa
                               a is 1st cmdline arg; v is -1 (implicit)
O                              Output without newline
 @a                            the first character of a
                          MPa  Map this function to pairs of successive characters of a:
                    Ag          Get the ASCII codes of the two characters
                  $-            Fold on subtraction (i.e. asc(first)-asc(second))
                v-              -1 minus the above (i.e. asc(second)-asc(first)-1)
              [0      ]         A list containing 0 and the above
            MX                  Max of the list
          @<                    The first ^ characters (with cyclic indexing)
    "TAPE"                      of this string
   {                   }.B      Concatenate the second character

JavaScript (ES6), 80 78 bytes

f=([s,...S],t=S[0])=>t?s.padEnd((t>s)*(parseInt(s+t,36)-370)%37,'TAPE')+f(S):s

La distancia entre dos caracteres se puede determinar convirtiendo su concatenación en la base 36, restando 370, módulo 37.

Por ejemplo, (parseInt('cy',36)-370)%37 == 22.

Luego podemos usar padEndpara rellenar los huecos y la recursión para manejar el bucle.

Casos de prueba:

f=([s,...S],t=S[0])=>t?s.padEnd((t>s)*(parseInt(s+t,36)-370)%37,'TAPE')+f(S):s

console.log(f('abcmnnnopstzra'));
console.log(f('aza'));
console.log(f('ghijk'));
console.log(f('aabbddeeffiiacek'));
console.log(f('zyxxccba'));
console.log(f('abccxxyz'));
console.log(f('abtapegh'));
console.log(f('tape'));

K4 , 48 bytes

Solución:

{,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}

Ejemplos:

q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"abcmnnnopstzra"
"abcTAPETAPETmnnnopTAstTAPETzra"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"aza"
"aTAPETAPETAPETAPETAPETAPEza"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"zyxxccba"
"zyxxccba"
q)k){,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"}"aabbddeeffiiacek"
"aabbTddeeffTAiiaTcTeTAPETk"

Explicación:

Solución bastante simple, pero un alto conteo de bytes ... Encuentra los deltas, toma de la cadena "TAPE", únete al corte de cadena original donde los deltas son> 1.

{,/_[w;x],',[1_d w:&0<d:-1+-':"j"$x;0]#\:"TAPE"} / the solution
{                                              } / lambda
                                         "TAPE"  / the string TAPE
                                      #\:        / take each-left
           ,[                      ; ]           / join (,)
                                   0             / zero (ie append zero)           
                              "j"$x              / cast input to int
                           -':                   / deltas
                        -1+                      / subtract 1
                      d:                         / assign to d
                    0<                           / delta greater than 0?
                   &                             / indices where true
                 w:                              / assign to w
               d                                 / index into deltas at w
             1_                                  / drop first
         ,'                                      / join each-both
   _[w;x]                                        / cut input x at indices w
 ,/                                              / flatten

Excel VBA, 106 bytes

Una función de ventana inmediata anónima de VBE que toma la entrada como una cadena en mayúscula a través de la celda A1y las salidas a la ventana inmediata de VBE.

a=90:For i=1To[Len(A1)]:c=Mid([A1],i,1):b=Asc(c):For j=2To b-a:?Mid("peta",j Mod 4+1,1);:Next:?c;:a=b:Next

Ruby , 59 53 bytes

->s{s.reduce{|x,y|x+y.rjust(y.ord-x[-1].ord,"TAPE")}}

Pruébalo en línea!

En realidad, esto es bastante sencillo: tomamos la entrada al dividir nuestra cadena en una serie de caracteres (gracias a Asone Tuhid por señalar esto) y aplicamos la operación de reducción, donde justificamos cada carácter a la longitud requerida usando "TAPE" como cadena de relleno.

K (oK) , 33 bytes

{,/((0|-1+0,1_-':x)#\:"TAPE"),'x}

Pruébalo en línea!

{ } función anónima con argumento x

-':x reste cada anterior (use un 0 imaginario antes del primer elemento)

1_ soltar el primer elemento

0, anteponer un 0

-1+ agregar -1

0| max (0, ...)

(... )#\:"TAPE"remodelar la cadena "TAPE"a cada elemento de la lista de la izquierda

(... ),'xagregue el carácter correspondiente xa cada cadena reformada

,/ concatenar todo

Ruby , 78 77 64 62 bytes

-1 byte gracias a Kevin Cruijssen

f=->s,*t{t[0]?s+('TAPE'*6)[0,[0,t[0].ord+~s.ord].max]+f[*t]:s}

Pruébalo en línea!

Java (JDK) , 91 bytes

s->{var p='z';for(var c:s)System.out.print("ETAP".repeat(9).substring(1,c>p?c-p:1)+(p=c));}

Pruébalo en línea!

Explicación

s->{                       // char[]-accepting lambda consumer, printing a String
 var p='z';                //  store the previous character
 for(var c:s){             //  for each character of the string
  System.out.print(        //   print...
   "ETAP".repeat(9)        //    "ETAP" repeated 9 times (to go above 26 chars)
    .substring(1,          //     of which, we substring c-p -1 characters
     c>p?c-p:1             //
    )                      //
   +(p=c)                  //    and append c, while also storing the previous character
  );

Créditos

• -2 bytes gracias a RM
• -4 bytes gracias a ceilingcat , actualizando a Java 10+ y cambiando los tipos avar
• -3 bytes gracias a Kevin Cruijssen , imprimiendo el resultado de mi (anteriormente) versión alternativa en lugar de devolverlo

C # (.NET Core) , 122 111 bytes

Guardado 11 bytes gracias a @KevinCruijssen

s=>{var r=""+s[0];for(int i=1,e,d;i<s.Length;r+=s[i++])for(e=d=s[i]-s[i-1];d-->1;)r+="ETAP"[(e-d)%4];return r;}

Pruébalo en línea!

Explicación:

s => 
{
    var r = "" + s[0];                  //Declare string for the result and initialize with the first character from the input.
    for (                               //Loop over the input,
        int i = 1, e, d;                //starting with the second character, also declare helper variables.
        i < s.Length;                   //Loop until the end of the input is reached.
        r += s[i++])                    //Add the current character to the result and increase the counter.
        for (                           //Loop for adding the TAPE.
            e = d = s[i] - s[i - 1];    //Calculate the differnce between the current and the previous character.
            d-- > 1;)                   //Loop until the difference is 1.
            r += "ETAP"[(e - d) % 4];   //Add a character from the TAPE to the result.
    return r;                           //Return the result.
}

Yabasic , 119 bytes

Una función anónima que toma la entrada como una cadena en mayúscula y las salidas a STDOUT.

Input""s$
a=90
For i=1To Len(s$)
c$=Mid$(s$,i,1)
b=Asc(c$)
For j=2To b-a
?Mid$("peta",Mod(j,4)+1,1);
Next
?c$;
a=b
Next

Pruébalo en línea!

Python 3, 90 bytes

p,o=' ',''
for t in input():y=(ord(t)-ord(p)-1)*(p!=' ');o+=('TAPE'*y)[0:y]+t;p=t
print(o)

Pruébalo en línea

Clojure, 139 119 bytes

#(reduce-kv(fn[r x c](let[a(cycle "TAPE")i int d(-(i(nth(cycle %)(inc x)))(i c))](str r(if(> d 1)(apply str c(take(dec d)a))c))))""(vec %))

Función anónima que toma la cadena y devuelve la grabada. Como siempre, Clojure no parece funcionar demasiado bien. Lo que realmente no pude resolver es buscar el siguiente personaje de una manera corta. En el último personaje obtendría una OutOfBoundsExceptionrazón obvia. Así que lo puse a su cyclealrededor. Quizás haya una solución más elegante.

Sin golf

#(reduce-kv
  (fn [r x c]
    (let [a (cycle "TAPE")
          i int
          d (-
             (i (nth (cycle %) (inc x)))
             (i c))]
      (str r
           (if (> d 1)
             (apply str c (take (dec d) a))
             c))))
  ""
  (vec %))

Actualizar

Se las arregló para eliminar algunos bytes. Se deshizo de la molesta ifdeclaración al disminuir la diferencia. takeproduce una lista vacía si el número es 0 o menos, lo que a su vez da como resultado una cadena vacía.

#(reduce-kv(fn[r x c](let[d(-(int(nth(cycle %)(inc x)))(int c)1)](str r c(apply str(take d(cycle "TAPE"))))))""(vec %))

Sin golf

#(reduce-kv
  (fn [r x c]
    (let [d (-
             (int (nth (cycle %) (inc x)))
             (int c)
             1)]
      (str
       r
       c
       (apply
        str
        (take
         d
         (cycle "TAPE"))))))
  ""
  (vec %))

APL (Dyalog Classic) , 30 bytes

{∊⍵,¨⍨⍴∘'TAPE'¨0,0⌈-1+2-/⎕a⍳⍵}

Pruébalo en línea!

{ } función anónima con argumento ⍵

⎕a⍳⍵ encontrar índices de sus caracteres en el alfabeto

2-/ diferencias por pares (anterior menos siguiente)

1+ agregar 1

- negar

0⌈ max (0, ...)

0, anteponer un 0

⍴∘'TAPE'¨remodelar cíclicamente la cadena 'TAPE'a cada

⍵,¨⍨ agregue cada carácter del argumento a la cadena reformada correspondiente

∊ aplanar

CJam , 27 25 bytes

q_:i2ew.{:-~0e>_"TAPE"*<}

Pruébalo en línea!

Lejos, lejos de los otros idiomas de golf, pero de todos modos estoy orgulloso de este golf.

Explicación

q                            Read the input
     ew                      And take windows of size
    2                          2
   i                           from the code points
  :                            of each of its characters.
        {               }    For each of these windows:
         :                     Reduce with
          -                      subtraction.
                                 Since there are only 2 elements, this just subtracts them.
             e>                Take the maximum
           ~                     of this difference's bitwise negation
            0                    and zero.
                                 This returns -n-1 if n is negative, and 0 otherwise.
                                 Call this new value m.
                      *        Repeat
                "TAPE"           the string "TAPE" m times.
               _       <       And then take the first m elements.
                             The result of this will be an array of strings which consist of
                             the string "TAPE" repeated the proper amount of times.
       .                     Zip this array with the original input.
                             Since the original input is one element longer than this array,
                             the nothing is pushed after the final character.
                             Implicitly print everything.

Casco , 26 25 bytes

ΣSoż+C1(moo↑¢¨tȦ9¨>0←Ẋ-mc

Pruébalo en línea!

PowerShell , 72 bytes

-join($args|% t*y|%{for(;$p*(++$p-lt$_)){'TAPE'[$i++%4]}$i=0;$p=+$_;$_})

Pruébalo en línea!

Java, 213 166 153 bytes

i->{String o="";for(int a=0,l=i.length;++a<=l;){char u=i[a-1],n;o+=u;if(a<l){n=i[a];o+="TAPETAPETAPETAPETAPETAPET".substring(0,n-u>0?n+~u:0);}}return o;}

pruébalo en línea

    String o = "";
    for (int a = 0, l = i.length; ++a <= l; ) {              // for each character
        char u = i[a - 1];                                    //  current character
        o += u;                                               //  add current character to output string 
        if (a < l) {                                          //  if it's not the last one
            char n = i[a];                                    //  next character
            o += "TAPETAPETAPETAPETAPETAPET".substring(0, n - u > 0 ? n +~ u : 0); // fill with enough tape but only forward
        }
    }
    return o;

Por favor, ayúdame a mejorarlo.

Gracias a @cairdcoinheringaahing por el consejo sobre espacios en blanco. Gracias a @RM por el consejo sobre la cinta. Gracias a @KevinCruijssen por los consejos lambda y expresiones.