도전:

대문자 및 / 또는 소문자 만 포함하는 문자열이있는 경우 (가장 선호하는 경우) tape수평으로 넣어서 수정하십시오. 우리는 알파벳에서 인접한 두 문자의 차이를 확인하여이 작업을 수행 (랩 어라운드를 무시하고 단지 앞으로), 그리고 많은으로 공간을 채우는 TAPE/ tape우리가 필요로.

예:

입력 : abcmnnnopstzra
출력 :abcTAPETAPETmnnnopTAstTAPETzra

왜?

• 사이 c에 m있어야 하고 defghijkl(길이 9), 우리는 이것을 다음과 같이 채 웁니다 TAPETAPET;
• 사이 p에 s있어야 하고 qr(길이 2), 우리는 이것을 다음과 같이 채 웁니다 TA;
• 사이 t에 z있어야 하고 uvwxy(길이 5)이를로 채 웁니다 TAPET.

도전 규칙 :

• 차이점은 앞으로 만 적용되므로 사이에 테이프가 없습니다 zra.
• 와 같은 인접 문자를 여러 개 가질 수 nnn있습니다.
• 합리적인 형식으로 입력 할 수 있습니다. 단일 문자열, 문자열 배열 / 목록, 문자 배열 / 목록 등일 수 있습니다. 출력의 유연성은 동일합니다.
• 원하는 방식으로 소문자 및 / 또는 대문자를 사용할 수 있습니다. 이것은 입력, 출력 및에 모두 적용됩니다 TAPE.
• 이 선택 불가 인 TAPE경우에 상기 입력은 변함 필요하다.

일반적인 규칙:

• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.
  코드 골프 언어가 코드 골프 언어 이외의 언어로 답변을 게시하지 못하게하지 마십시오. '모든'프로그래밍 언어에 대한 가능한 한 짧은 대답을 생각해보십시오.
• 표준 규칙이 답변에 적용 되므로 STDIN / STDOUT, 적절한 매개 변수 및 리턴 유형의 전체 프로그램과 함께 함수 / 방법을 사용할 수 있습니다. 당신의 전화.
• 기본 허점 은 금지되어 있습니다.
• 가능하면 코드 테스트에 대한 링크를 추가하십시오.
• 또한 필요한 경우 설명을 추가하십시오.

테스트 사례 :

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 바이트

'¡ÉIÇ¥<∍‚ζJJ

온라인으로 사용해보십시오!

설명

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

젤리 , 13 바이트

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

온라인으로 사용해보십시오!

설명

OI '“¡ ʂƁ»ṁ $ € ż @ – 전체 프로그램. 문자열을 명령 행 인수로 사용하십시오.
O – 서수. 각 문자의 ASCII 값을 가져옵니다.
 I '– 증분 (델타)을 구하고 각각에서 1을 뺍니다.
          € – 각각의 차이점에 대해
   "¡ ʂƁ»ṁ $ –이 값에 따라 압축 된 줄"테이프 "를 성형합니다.
                기본적으로 "테이프"를 필요한 길이로 늘리거나 줄입니다.
           ż @ – 입력과 인터리브.

하스켈 , 58 바이트

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

온라인으로 사용해보십시오! 이 기능은 f연속 된 문자의 문자열과 외모를 통해 재귀 x와 y. cycle"TAPE"무한 문자열을 산출합니다 "TAPETAPETAPE...". [x..y]문자 범위 x를 y포함 하여 문자 범위 를 포함하므로 길이에서 2를 빼야합니다. 경우에 x다음 알파벳 이후에 발생 y또는 둘 모두가 동일한 문자, 우리는 뺀 부정적인 번호를 얻을 수 있지만, 다행히 take뿐만 아니라 사람들을 받아들이는 그냥 아무것도 취하지 않는다.

펄 5 , -F46 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 96 87 80 바이트

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

온라인으로 사용해보십시오!

하스켈 , 64 바이트

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

대문자 또는 소문자 문자열을 처리 하지만 둘다는 아닙니다.

온라인으로 사용해보십시오!

C, 84 바이트

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

온라인으로 사용해보십시오!

C (Windows 명령 프롬프트에서 실행), 81 바이트

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

산출:

파이썬 3 , 98 바이트

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]

온라인으로 사용해보십시오!

Asone Tuhid 덕분에 -1 바이트

스칼라 , 66 바이트

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

온라인으로 사용해보십시오!

설명

/: 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 바이트

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

온라인으로 사용해보십시오!

설명

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

자바 스크립트, 131 127 바이트

Rick Hitchcock 덕분에 4 바이트가 절약되었습니다 .

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

풀림

z = a => [... a]. 감소 (
  (x, y) =>
    x + [... 배열 (
      (f = y.charCodeAt ()-(x.slice (-1) .charCodeAt ()))> 1? (f-1) : 0
    )].줄이다(
      (e, r, t) => 
        e + "TAPE"[t % 4], "") + y
);

내 문제는 Javascript가 문자 a와 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>

파이썬 2/3 , 70 69 바이트

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

온라인으로 사용해보십시오!

숯 , 20 바이트

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

온라인으로 사용해보십시오! 설명:

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

핍 , 29 바이트

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

입력을 명령 줄 인수로 사용합니다 (소문자 또는 대문자는 중요하지 않음). 온라인으로 사용해보십시오!

설명

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

자바 스크립트 (ES6), 80 78 바이트

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

두 문자 사이의 거리는 해당 문자의 연결을베이스 36, 370을 빼고 계수 37로 변환하여 결정할 수 있습니다.

예를 들면 다음과 같습니다 (parseInt('cy',36)-370)%37 == 22.

그런 다음 padEnd갭을 채우고 루프를 처리하기 위해 재귀를 사용할 수 있습니다 .

테스트 사례 :

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 바이트

해결책:

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

예 :

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"

설명:

상당히 간단한 해결책이지만 높은 바이트 수 ... 델타를 찾고 문자열에서 가져와 "TAPE"델타가 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 바이트

셀을 통해 대문자 문자열로 입력 A1을 받아 VBE 즉시 창으로 출력 하는 익명의 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

루비 , 59 53 바이트

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

온라인으로 사용해보십시오!

이것은 실제로 매우 간단합니다. 우리는 문자열을 문자 배열 로 분할 하여 입력을 취하고 (이 점을 지적한 Asone Tuhid 덕분에) 줄임 작업을 적용합니다. 여기서는 필러 문자열로 "TAPE"를 사용하여 각 문자를 필요한 길이로 정당화합니다.

K (oK) , 33 바이트

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

온라인으로 사용해보십시오!

{ } 인수가있는 익명 함수 x

-':x 각각의 이전을 빼십시오 (첫 번째 항목 앞에 가상의 0을 사용하십시오)

1_ 첫 번째 아이템 삭제

0, 앞에 0을 더하다

-1+ -1을 더하다

0| 최대 (0, ...)

(... 왼쪽의 목록에서 각 항목 )#\:"TAPE"의 문자열 "TAPE"을 재구성하십시오.

(... 각 재 ),'x형성된 x문자열에 해당 문자를 추가하십시오

,/ 모두 연결하다

루비 , 78 77 64 62 바이트

Kevin Cruijssen 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

자바 (JDK) , 91 바이트

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

온라인으로 사용해보십시오!

설명

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

크레딧

• RM 덕분에 -2 바이트
• ceilingcat 덕분에 Java 10 이상으로 업그레이드하고 유형을var
• Kevin Cruijssen 덕분에 -3 바이트 , 내 (이전) 대체 버전의 결과를 반환하는 대신 인쇄하여

C # (. NET 코어) , 122111 바이트

@KevinCruijssen 덕분에 11 바이트 절약

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

온라인으로 사용해보십시오!

설명:

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 바이트

대문자 문자열로 입력하여 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

온라인으로 사용해보십시오!

파이썬 3, 90 바이트

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

온라인으로 사용해보십시오

클로저, 139119 바이트

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

문자열을 가져와 테이프 화 된 것을 반환하는 익명 함수. 항상 그렇듯이 Clojure는 모든 것을 잘 수행하지 못하는 것 같습니다. 내가 실제로 해결할 수 없었던 것은 짧은 문자로 다음 문자를 가져 오는 것입니다. 마지막 문자에서 나는 OutOfBoundsException명백한 이유를 얻을 것 입니다. 그래서 나는 cycle그것을 둘러 쌉니다. 아마도 더 우아한 해결책이있을 것입니다.

언 골프

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

최신 정보

몇 바이트를 처리했습니다. if차이를 줄임으로써 성가신 진술을 제거했습니다 . take숫자가 0 이하이면 빈 목록을 생성하여 빈 문자열을 만듭니다.

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

언 골프

#(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 바이트

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

온라인으로 사용해보십시오!

{ } 인수가있는 익명 함수 ⍵

⎕a⍳⍵ 알파벳에서 문자의 색인을 찾으십시오

2-/ 쌍별 차이 (이전 마이너스 다음)

1+ 1을 더하다

- 부정하다

0⌈ 최대 (0, ...)

0, 앞에 0을 더하다

⍴∘'TAPE'¨'TAPE'각 줄 을 주기적으로 바꾸십시오

⍵,¨⍨ 인수의 각 문자를 해당하는 재구성 문자열에 추가하십시오.

∊ 반음 낮추다

CJam , 27 25 바이트

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

온라인으로 사용해보십시오!

다른 골프 언어와는 거리가 멀지 만 어쨌든이 골프를 자랑스럽게 생각합니다.

설명

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.

껍질 , 26 25 바이트

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

온라인으로 사용해보십시오!

PowerShell , 72 바이트

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

온라인으로 사용해보십시오!

자바 213 166 153 바이트

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

온라인으로 사용해보십시오

    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;

더 나아지게 도와주세요.

공백 팁에 대한 @cairdcoinheringaahing 감사합니다. 테이프 스트링 팁에 대한 @RM에 감사합니다. 람다 및 표현 팁에 대한 @KevinCruijssen에게 감사합니다.