Défi:

Avec une chaîne contenant uniquement des lettres majuscules et / ou minuscules (celle que vous préférez), mettez-la tapehorizontalement pour la corriger. Nous faisons cela en vérifiant la différence de deux lettres adjacentes dans l'alphabet ( en ignorant wrap-around et seulement aller de l' avant), et remplissant l'espace avec autant TAPE/ tapeque nous aurions besoin.

Exemple:

Entrée: abcmnnnopstzra
sortie:abcTAPETAPETmnnnopTAstTAPETzra

Pourquoi?

• Entre cet mdevrait être defghijkl(longueur 9), nous remplissons donc ceci avec TAPETAPET;
• Entre pet sdevrait être qr(longueur 2), nous remplissons donc ceci avec TA;
• Entre tet zdevrait être uvwxy(longueur 5), nous remplissons donc ceci avec TAPET.

Règles du challenge:

• La différence ne s'applique que vers l'avant, donc pas de bande entre zra.
• Il est possible d’avoir plusieurs lettres identiques identiques nnn.
• Vous êtes autorisé à saisir les données dans n'importe quel format raisonnable. Peut être une chaîne unique, un tableau / une chaîne, un tableau / une liste, etc. La sortie offre la même flexibilité.
• Vous êtes autorisé à utiliser des minuscules et / ou des majuscules comme vous le souhaitez. Ceci s’applique à la fois à l’entrée, à la sortie et à TAPE.
• Il est possible que cela ne TAPEsoit pas nécessaire, auquel cas l'entrée reste inchangée.

Règles générales:

• C'est du code-golf , donc la réponse la plus courte en octets est gagnante.
  Ne laissez pas les langues de code-golf vous décourager de poster des réponses avec des langues autres que le code de golf. Essayez de trouver une réponse aussi courte que possible à n'importe quel langage de programmation.
• Les règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, fonctions / méthode avec les paramètres appropriés et des programmes complets de type de retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien vers un test pour votre code.
• Ajoutez également une explication si nécessaire.

Cas de test:

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 octets

'¡ÉIÇ¥<∍‚ζJJ

Essayez-le en ligne!

Explication

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

Gelée , 13 octets

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

Essayez-le en ligne!

Explication

OI '“¡” ṁ $ € ż @ - Programme complet. Prenons une chaîne comme argument de ligne de commande.
O - Ordinal. Obtenez les valeurs ASCII de chaque caractère.
 I '- Obtenez les incréments (deltas) et soustrayez 1 de chacun.
          € - Pour chaque différence je ...
   “¡ꟅƁ» ṁ $ - Mouler la chaîne compressée "bande" en fonction de ces valeurs.
                En gros, étend / raccourcit le "ruban" à la longueur nécessaire.
           ż @ - Entrelacez avec l'entrée.

Haskell , 58 octets

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

Essayez-le en ligne! La fonction frevient sur la chaîne et examine les caractères consécutifs xet y. cycle"TAPE"donne la chaîne infinie "TAPETAPETAPE...". [x..y]obtient la plage de caractères de xà yinclus, nous devons donc soustraire deux de la longueur. Au cas où cela xse produirait plus tard dans l’alphabet, les ydeux caractères étant identiques, nous obtenons un nombre négatif après soustraction, mais heureusement, nous les acceptons également et nous ne prenons takerien.

Perl 5 , -F46 octets

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

Essayez-le en ligne!

Python 2 , 96 87 80 octets

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

Essayez-le en ligne!

Haskell , 64 octets

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

Gère les chaînes de lettres majuscules ou minuscules, mais pas les deux.

Essayez-le en ligne!

C, 84 octets

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

Essayez-le en ligne!

C (exécuté à l'invite de commande Windows), 81 octets

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

Sortie:

Python 3 , 98 octets

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]

Essayez-le en ligne!

-1 octet grâce à Asone Tuhid

Scala , 66 octets

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

Essayez-le en ligne!

Explication

/: 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 octets

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

Essayez-le en ligne!

Explication

$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 octets

4 octets économisés grâce à 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))

Déroulé

z = a => [... a] .reduce (
  (x, y) =>
    x + [... Tableau (
      (f = y.charCodeAt () - (x.slice (-1) .charCodeAt ()))> 1? (f-1): 0
    )].réduire(
      (e, r, t) => 
        e + "CASSETTE" [t% 4], "") + y
)

Mon problème ici est que Javascript n’a aucun moyen propre d’obtenir la distance entre les personnages a et 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 octets

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

Essayez-le en ligne!

Charbon de bois , 20 octets

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

Essayez-le en ligne! Explication:

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

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

Prend l'entrée en tant qu'argument de ligne de commande (minuscule ou majuscule, peu importe). Essayez-le en ligne!

Explication

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 octets

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

La distance entre deux caractères peut être déterminée en convertissant leur concaténation en base 36, soustraction 370, module 37.

Par exemple, (parseInt('cy',36)-370)%37 == 22.

Nous pouvons ensuite utiliser padEndpour combler les lacunes et la récursion pour gérer la boucle.

Cas de test:

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 octets

Solution:

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

Exemples:

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"

Explication:

Solution assez simple, mais un nombre d'octets élevé ... Recherchez les deltas, prenez-les dans la chaîne "TAPE", joignez-les à la chaîne d'origine coupée où les deltas sont> 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 octets

Une fonction de fenêtre immédiate VBE anonyme qui prend une entrée sous forme de chaîne de caractères majuscule via une cellule A1et est transmise à la fenêtre immédiate 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 octets

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

Essayez-le en ligne!

C’est en fait assez simple: nous prenons l’entrée comme division de notre chaîne de caractères en un tableau de caractères (grâce à Asone Tuhid pour l'avoir signalé) et appliquons l'opération de réduction, où nous justifions chaque caractère à la longueur requise en utilisant "TAPE" comme chaîne de remplissage.

K (oK) , 33 octets

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

Essayez-le en ligne!

{ } fonction anonyme avec argument x

-':x soustrayez chaque avant (utilisez un 0 imaginaire avant le premier item)

1_ déposer le premier élément

0, ajouter un 0

-1+ ajouter -1

0| max (0, ...)

(... )#\:"TAPE"remodeler la chaîne"TAPE" en chaque élément de la liste de gauche

(... ),'xajouter le caractère correspondant dex à chaque chaîne remodelée

,/ tout concaténer

Ruby , 78 77 64 62 octets

-1 octet grâce à Kevin Cruijssen

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

Essayez-le en ligne!

Java (JDK) , 91 octets

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

Essayez-le en ligne!

Explication

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édits

• -2 octets grâce à RM
• -4 octets grâce à ceilingcat , en passant à Java 10+ et en basculant les types versvar
• -3 octets grâce à Kevin Cruijssen , en imprimant le résultat de ma version (précédemment) alternative au lieu de le renvoyer

C # (.NET Core) , 122 111 octets

11 octets sauvés grâce à @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;}

Essayez-le en ligne!

Explication:

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 octets

Une fonction anonyme qui prend une entrée en tant que chaîne en majuscule et une sortie vers 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

Essayez-le en ligne!

Python 3, 90 octets

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

Essayez-le en ligne

Clojure, 139 119 octets

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

Fonction anonyme qui prend la chaîne et retourne celle enregistrée. Comme toujours, Clojure ne semble pas très performant. Ce que je ne pouvais pas vraiment comprendre, c'est chercher le prochain personnage de manière courte. Sur le dernier personnage, j'aurais unOutOfBoundsException raison évidente. Alors je mets un cycleautour. Peut-être y a-t-il une solution plus élégante.

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

Mise à jour

Réussi à supprimer quelques octets. Se débarrasser de la ifdéclaration embêtante en décrémentant la différence. takeproduit une liste vide si le nombre est inférieur ou égal à 0, ce qui entraîne à son tour une chaîne vide.

#(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 octets

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

Essayez-le en ligne!

{ } fonction anonyme avec argument ⍵

⎕a⍳⍵ trouver des index de ses caractères dans l'alphabet

2-/ différences par paires (prev moins next)

1+ ajouter 1

- nier

0⌈ max (0, ...)

0, ajouter un 0

⍴∘'TAPE'¨ remodeler cycliquement la chaîne 'TAPE' à chaque

⍵,¨⍨ ajoute chaque caractère de l'argument à la chaîne remodelée correspondante

∊ aplatir

CJam , 27 25 octets

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

Essayez-le en ligne!

Loin, loin des autres langues de golf, mais je suis fier de ce golf quand même.

Explication

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.

Husk , 26 à 25 octets

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

Essayez-le en ligne!

PowerShell , 72 octets

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

Essayez-le en ligne!

Java, 213 166 153 octets

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

essayez-le en ligne

    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;

S'il vous plaît aidez-moi à le rendre meilleur.

Thanks to @cairdcoinheringaahing for the tip on whitespaces. Thanks to @R.M for the tip on tape string. Thanks to @KevinCruijssen for the lambda and expressions tips.