Sfida:

Data una stringa contenente solo lettere maiuscole e / o minuscole (qualunque preferiate), mettetela in tapeorizzontale per sistemarla. Lo facciamo controllando la differenza di due lettere adiacenti nell'alfabeto (ignorando il giro e solo andando avanti), e riempiendo lo spazio con tutto TAPE/ tapequanto avremmo bisogno.

Esempio:

Ingresso: abcmnnnopstzra
Uscita:abcTAPETAPETmnnnopTAstTAPETzra

Perché?

• Between cand mdovrebbe essere defghijkl(lunghezza 9), quindi lo riempiamo di TAPETAPET;
• Between pe sdovrebbe essere qr(lunghezza 2), quindi lo riempiamo di TA;
• Tra te zdovrebbe essere uvwxy(lunghezza 5), ​​quindi lo riempiamo TAPET.

Regole della sfida:

• La differenza si applica solo in avanti, quindi nessun nastro tra zra.
• È possibile avere più lettere uguali simili nnn.
• È consentito accettare l'input in qualsiasi formato ragionevole. Può essere una singola stringa, array di stringhe / elenco, array di caratteri / elenco, ecc. L'output ha la stessa flessibilità.
• È consentito utilizzare lettere minuscole e / o maiuscole nel modo desiderato. Questo vale sia per l'input, che per l'output e TAPE.
• È possibile che non TAPEsia necessario, nel qual caso l'ingresso rimane invariato.

Regole generali:

• Questo è code-golf , quindi vince la risposta più breve in byte.
  Non lasciare che le lingue di code-golf ti scoraggino dal pubblicare risposte con lingue non codegolfing. Prova a trovare una risposta il più breve possibile per "qualsiasi" linguaggio di programmazione.
• Per la tua risposta valgono regole standard , quindi puoi usare STDIN / STDOUT, funzioni / metodo con i parametri corretti e tipo di ritorno, programmi completi. La tua chiamata.
• Sono vietate le scappatoie predefinite .
• Se possibile, aggiungi un link a un test per il tuo codice.
• Inoltre, si prega di aggiungere una spiegazione, se necessario.

Casi 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 byte

'¡ÉIÇ¥<∍‚ζJJ

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione

OI '“¡ʂƁ» ṁ $ € ż @ - Programma completo. Prendi una stringa come argomento della riga di comando.
O - Ordinale. Ottieni i valori ASCII di ciascun personaggio.
 I ': ottieni gli incrementi (delta) e sottrai 1 da ciascuno.
          € - Per ogni differenza I ...
   “¡ꟅƁ» ṁ $ - Modella la stringa compressa "tape" in base a questi valori.
                Praticamente estende / accorcia il "nastro" alla lunghezza necessaria.
           ż @ - Interlaccia con l'ingresso.

Haskell , 58 byte

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

Provalo online! La funzione fricorre sulla stringa e guarda i caratteri consecutivi xe y. cycle"TAPE"restituisce la stringa infinita "TAPETAPETAPE...". [x..y]ottiene la gamma di caratteri da xa yinclusivo, quindi abbiamo bisogno di sottrarre due dalla lunghezza. Nel caso in cui si xverifichi più avanti nell'alfabeto, allora yo entrambi hanno lo stesso carattere, otteniamo un numero negativo dopo la sottrazione, ma per fortuna takeaccetta anche quelli e non prende nulla.

Perl 5 , -F46 byte

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

Provalo online!

Python 2 , 96 87 80 byte

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

Provalo online!

Haskell , 64 byte

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

Gestisce stringhe di lettere maiuscole o minuscole, ma non entrambe.

Provalo online!

C, 84 byte

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

Provalo online!

C (eseguito sul prompt dei comandi di Windows), 81 byte

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

Produzione:

Python 3 , 98 byte

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]

Provalo online!

-1 byte grazie a Asone Tuhid

Scala , 66 byte

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

Provalo online!

Spiegazione

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

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

Provalo online!

Spiegazione

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

4 byte salvati grazie 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))

srotolata

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

Il mio problema qui è che Javascript non aveva un modo pulito per ottenere la distanza tra il carattere 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 byte

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

Provalo online!

Carbone , 20 byte

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

Provalo online! Spiegazione:

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

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

Accetta input come argomento della riga di comando (maiuscolo o minuscolo, non importa). Provalo online!

Spiegazione

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 byte

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

La distanza tra due caratteri può essere determinata convertendo la loro concatenazione in base 36, sottraendo 370, modulo 37.

Ad esempio (parseInt('cy',36)-370)%37 == 22,.

Possiamo quindi utilizzare padEndper riempire gli spazi vuoti e ricorsione per gestire il ciclo.

Casi 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 byte

Soluzione:

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

Esempi:

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"

Spiegazione:

Soluzione abbastanza semplice, ma con un elevato numero di byte ... Trova i delta, prendi dalla stringa "TAPE", unisciti al taglio della stringa originale dove i delta sono> 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 byte

Una funzione di finestra immediata VBE anonima che accetta l'input come stringa maiuscola tramite cella A1e restituisce alla finestra immediata 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

Rubino , 59 53 byte

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

Provalo online!

Questo in realtà è piuttosto semplice: prendiamo l'input come dividere la nostra stringa in una matrice di caratteri (grazie ad Asone Tuhid per averlo sottolineato) e applichiamo un'operazione di riduzione, dove giustificiamo ogni carattere alla lunghezza richiesta usando "TAPE" come stringa di riempimento.

K (oK) , 33 byte

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

Provalo online!

{ } funzione anonima con argomento x

-':x sottrai ogni precedente (usa uno 0 immaginario prima del primo oggetto)

1_ rilascia il primo oggetto

0, anteporre uno 0

-1+ aggiungi -1

0| max (0, ...)

(... )#\:"TAPE"rimodella la stringa "TAPE"per ogni elemento dall'elenco a sinistra

(... ),'xaggiungi il carattere corrispondente xa ciascuna stringa rimodellata

,/ concatenare tutto

Rubino , 78 77 64 62 byte

-1 byte grazie a Kevin Cruijssen

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

Provalo online!

Java (JDK) , 91 byte

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

Provalo online!

Spiegazione

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

Crediti

• -2 byte grazie a RM
• -4 byte grazie a ceilingcat , aggiornando a Java 10+ e passando a tipivar
• -3 byte grazie a Kevin Cruijssen , stampando il risultato della mia versione (precedentemente) alternativa invece di restituirla

C # (.NET Core) , 122 111 byte

Salvato 11 byte grazie 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;}

Provalo online!

Spiegazione:

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 byte

Una funzione anonima che accetta l'input come stringa maiuscola e l'output su 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

Provalo online!

Python 3, 90 byte

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

Provalo online

Clojure, 139 119 byte

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

Funzione anonima che accetta la stringa e restituisce quella registrata. Come sempre, Clojure non sembra esibirsi troppo bene. Quello che non sono riuscito a capire è recuperare il prossimo carattere in breve tempo. All'ultimo carattere avrei ottenuto unOutOfBoundsException ragione ovvia. Quindi ci ho messo cycleintorno. Forse c'è una soluzione più 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 %))

Aggiornare

Gestito per eliminare alcuni byte. Mi sono sbarazzato della fastidiosa ifdichiarazione diminuendo la differenza. takeproduce un elenco vuoto se il numero è 0 o inferiore che a sua volta risulta in una stringa vuota.

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

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

Provalo online!

{ } funzione anonima con argomento ⍵

⎕a⍳⍵ trova gli indici dei suoi caratteri nell'alfabeto

2-/ differenze a coppie (precedente meno successivo)

1+ aggiungi 1

- negare

0⌈ max (0, ...)

0, anteporre uno 0

⍴∘'TAPE'¨rimodellare ciclicamente la stringa 'TAPE'per ciascuno

⍵,¨⍨ aggiungere ogni carattere dall'argomento alla stringa rimodellata corrispondente

∊ appiattire

CJam , 27 25 byte

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

Provalo online!

Lontano, lontano dalle altre lingue del golf, ma sono orgoglioso di questo golf comunque.

Spiegazione

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.

Buccia , 26 25 byte

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

Provalo online!

PowerShell , 72 byte

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

Provalo online!

Java, 213 166 153 byte

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

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

Per favore, aiutami a renderlo migliore.

Grazie a @cairdcoinheringaahing per la punta sugli spazi bianchi. Grazie a @RM per il suggerimento sulla stringa di nastro. Grazie a @KevinCruijssen per i suggerimenti lambda ed espressioni.