Desafio:

Dada uma sequência contendo apenas letras maiúsculas e / ou minúsculas (o que você preferir), coloque tapehorizontalmente para corrigi-la. Fazemos isso verificando a diferença de duas letras adjacentes no alfabeto (ignorando o contorno e apenas avançando) e preenchendo o espaço com o máximo TAPE/ tapenecessário.

Exemplo:

Entrada: abcmnnnopstzra
Saída:abcTAPETAPETmnnnopTAstTAPETzra

Por quê?

• Entre ce mdeve ser defghijkl(comprimento 9), então preenchemos isso com TAPETAPET;
• Entre pe sdeve ser qr(comprimento 2), então preenchemos isso com TA;
• Entre te zdeve ser uvwxy(comprimento 5), por isso preenchemos isso TAPET.

Regras do desafio:

• A diferença se aplica apenas a frente, portanto, não há fita entre elas zra.
• É possível ter várias das mesmas letras adjacentes como nnn.
• Você tem permissão para receber a entrada em qualquer formato razoável. Pode ser uma única string, string-array / lista, caractere-array / lista, etc. A saída tem a mesma flexibilidade.
• Você tem permissão para usar letras minúsculas e / ou maiúsculas da maneira que desejar. Isso se aplica à entrada, saída e TAPE.
• É possível que não TAPEseja necessário; nesse caso, a entrada permanece inalterada.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados e programas completos do tipo retorno. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link para um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

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

Experimente online!

Explicação

'¡É            # 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

Gelatina , 13 bytes

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

Experimente online!

Explicação

OI '' ¡ṁ $ € ż @ - Programa completo. Pegue uma string como argumento de linha de comando.
O - Ordinal. Obtenha os valores ASCII de cada caractere.
 I '- obtenha os incrementos (deltas) e subtraia 1 de cada um.
          € - Para cada diferença eu ...
   “¡ꟅƁ» ṁ $ - Molda a fita "string" compactada de acordo com esses valores.
                Estende / reduz basicamente a "fita" para o comprimento necessário.
           ż @ - intercalar com a entrada.

Haskell , 58 bytes

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

Experimente online! A função se frepete sobre a string e examina caracteres consecutivos xe y. cycle"TAPE"produz a sequência infinita "TAPETAPETAPE...". [x..y]recebe o intervalo de caracteres a partir xde yInclusive, portanto, precisa subtrair dois do comprimento. No caso de xocorrer mais tarde no alfabeto, então you ambos são do mesmo caractere, obtemos um número negativo após a subtração, mas felizmente os takeaceita também e simplesmente não aceita 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

Experimente online!

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:]+' '))

Experimente online!

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

Manipula cadeias de letras maiúsculas ou minúsculas, mas não as duas.

Experimente online!

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

Experimente online!

C (executado no prompt de comando do Windows), 81 bytes

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

Saída:

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]

Experimente online!

-1 byte graças a Asone Tuhid

Scala , 66 bytes

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

Experimente online!

Explicação

/: 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');

Experimente online!

Explicação

$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, 131 127 bytes

4 bytes economizados graças 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))

Desenrolado

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

Meu problema aqui é que o Javascript não tinha uma maneira limpa de obter a distância entre os caracteres aeb.

<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

Experimente online!

Carvão , 20 bytes

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

Experimente online! Explicação:

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

Recebe a entrada como argumento da linha de comando (maiúsculas ou minúsculas, não importa). Experimente online!

Explicação

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

A distância entre dois caracteres pode ser determinada convertendo sua concatenação na base 36, subtraindo 370, módulo 37.

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

Podemos então usar padEndpara preencher as lacunas e recursão para lidar com o loop.

Casos de teste:

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

Solução:

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

Exemplos:

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"

Explicação:

Solução bastante simples, mas com uma contagem alta de bytes ... Encontre os deltas, retire da string "TAPE"e junte-se ao corte original da string onde os deltas são> 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

Uma função de janela imediata anônima do VBE que recebe entrada como uma seqüência de caracteres em maiúsculas via célula A1e envia para a janela imediata do 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")}}

Experimente online!

Na verdade, isso é bastante direto - nós pegamos a entrada como dividimos nossa string em uma matriz de caracteres (agradecemos a Asone Tuhid por apontar isso) e aplicamos a operação de redução, onde justificamos cada caractere com o comprimento necessário usando "TAPE" como string de preenchimento.

K (oK) , 33 bytes

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

Experimente online!

{ } função anônima com argumento x

-':x subtraia cada anterior (use um 0 imaginário antes do primeiro item)

1_ largar primeiro item

0, preceder um 0

-1+ add -1

0| máx (0, ...)

(... )#\:"TAPE"remodelar a string "TAPE"de cada item da lista à esquerda

(... ),'xacrescenta o caractere correspondente xa cada sequência remodelada

,/ concatenar tudo

Ruby , 78 77 64 62 bytes

-1 byte graças a Kevin Cruijssen

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

Experimente online!

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

Experimente online!

Explicação

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 graças ao RM
• -4 bytes graças ao ceilingcat , atualizando para Java 10+ e alternando tipos paravar
• -3 bytes graças a Kevin Cruijssen , imprimindo o resultado da minha versão alternativa (anteriormente) em vez de devolvê-la

C # (.NET Core) , 122 111 bytes

Guardado 11 bytes graças 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;}

Experimente online!

Explicação:

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

Uma função anônima que recebe entrada como uma seqüência de caracteres em maiúsculas e gera saída para 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

Experimente online!

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)

Experimente Online

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 %))

Função anônima que pega a string e retorna a gravada. Como sempre, Clojure não parece ter um desempenho muito bom. O que eu realmente não consegui descobrir é buscar o próximo caractere de uma maneira curta. No último char, eu teria uma OutOfBoundsExceptionrazão óbvia. Então eu coloquei uma cyclevolta. Talvez haja uma solução mais elegante.

Ungolfed

#(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 %))

Atualizar

Conseguiu eliminar alguns bytes. Livre-se da ifdeclaração traquina , diminuindo a diferença. takeproduz uma lista vazia se o número for 0 ou menos, o que resulta em uma sequência vazia.

#(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 %))

Ungolfed

#(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⍳⍵}

Experimente online!

{ } função anônima com argumento ⍵

⎕a⍳⍵ encontre índices de seus caracteres no alfabeto

2-/ diferenças aos pares (anterior menos próximo)

1+ add 1

- negar

0⌈ máx (0, ...)

0, preceder um 0

⍴∘'TAPE'¨remodelar ciclicamente a cadeia 'TAPE'de caracteres para cada

⍵,¨⍨ anexa cada caractere do argumento à string remodelada correspondente

∊ aplainar

CJam , 27 25 bytes

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

Experimente online!

Longe, longe das outras línguas do golfe, mas de qualquer forma estou orgulhoso desse golfe.

Explicação

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.

Casca , 26 25 bytes

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

Experimente online!

PowerShell , 72 bytes

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

Experimente online!

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

experimente online

    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 me ajude a melhorar.

Obrigado a @cairdcoinheringaahing pela dica sobre espaços em branco. Obrigado a @RM pela dica sobre a sequência de fitas. Obrigado a @KevinCruijssen pelas dicas sobre lambda e expressões.