在那里，我用胶带固定了它

41

挑战：

给定仅包含大写和/或小写字母的字符串（以您喜欢的为准），将其tape水平放置即可修复。为此，我们检查字母表中两个相邻字母的差异（忽略环绕并仅向前移动），并在需要的位置填充TAPE/ tape。

例：

输入：abcmnnnopstzra
输出：abcTAPETAPETmnnnopTAstTAPETzra

为什么？

  • 之间c和m应该是defghijkl（长度9），因此，我们用填补这一TAPETAPET;
  • 之间p和s应该是qr（长度为2），因此我们用填补这一TA;
  • 之间t并z应uvwxy（长度为5），所以我们填补了这一带TAPET。

挑战规则：

  • 差异仅适用于正向，因此之间没有胶带zra。
  • 可能会有多个相同的相邻字母，例如nnn。
  • 您可以采用任何合理的格式输入。可以是单个字符串，字符串数组/列表，字符数组/列表等。输出具有相同的灵活性。
  • 您可以随意使用小写和/或大写字母。这适用于输入，输出和TAPE。
  • 可能没有TAPE必要，在这种情况下，输入保持不变。

通用规则：

  • 这是代码高尔夫球，因此最短的答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
  • 标准规则适用于您的答案，因此您可以使用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"
code-golf  string 
— 凯文·克鲁伊森
source
10
不确定为什么我们要在两次修正之间丢弃一些东西（例如，在用TAPETAPET进行修正之后，再通过TA进行修正之前，我们丢弃了APE）对我来说是对TAPE的浪费，但这也许就是我滚动的方式（对不起）。
— 乔纳森·艾伦
@JonathanAllan Hehe，您说的对，这确实是对“磁带”的浪费，这是正确的。嗯，这可能是我在挑战的第二部分中使用的东西。;）
— Kevin Cruijssen
如果字符串是用胶带附带的，例如abTAPEgh怎么办？
— manassehkatz
@manassehkatz它将被解释为其他每个字符，因此ab[TAPETAPETAPETAPET]TA[TAPETAPETAPETA]PE[T]gh（添加[]使其更易读）。
— 凯文·克鲁伊森
1
@KevinCruijssen这是一致的，尽管（与“浪费磁带”问题一样）不是100％逻辑的。因此，也许一个更测试用例：输大盘，输出TATAPETAPETAPETAPE（我想我说对了...）
— manassehkatz

Answers:

8

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
— 艾米尼亚
source
4
您介意添加解释吗？我认为这与Jelly的答案非常相似，但是我很好奇哪个字符用于哪个操作来获得结果。我面临的挑战中的一般规则之一是：“ 另外，如有必要，请添加说明。 ”使用Jelly，05AB1E，木炭，APL等语言，可以假定大多数人都不会阅读，并且必须进行说明。:)
— Kevin Cruijssen
@KevinCruijssen：当然可以。我通常在05AB1E答案中添加一个解释，但发布时我并不总是有空。
— Emigna
1
您可以添加@KevinCruijssen到任何05AB1E TIO链接的参数中，-d以获取正在发生的事情的原始堆栈逐个操作转储，以代替解释，但是我也尝试将其发布，这并不容易，尤其是在某些情况下我的大声笑。
— 魔术八达通Ur
10

果冻，13个字节

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

在线尝试！

说明

OI'“¡ṁ»ṁ$€ż@ –完整程序。将字符串作为命令行参数。
O –序数。获取每个字符的ASCII值。
 I'–获得增量（增量），并从每个增量中减去1。
          €–每个差额我...
   “¡ʂƁ»ṁ$ –根据这些值模制压缩的字符串“ tape”。
                基本上将“磁带”延伸/缩短到必要的长度。
           ż@ –与输入交织。
— Xcoder先生
source
这是使您降至12 的技巧
— 乔纳森·艾伦
@JonathanAllan对我来说这似乎无效。输出abctapetapetmnnnopapstetapezra而不是abctapetapetmnnnoptasttapetzra。
— Xcoder先生18年
7
哦，是的，这是无效的-我还没有意识到我们要浪费胶卷！
— 乔纳森·艾伦，
7

Haskell，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，因此我们需要从长度中减去两个。如果x出现在字母的后面，y或者两者都是相同的字符，则我们在减去后会得到一个负数，但是幸运的是也take接受了这些，并且什么也不做。

— 莱科尼
source
6

Perl 5中，-F46个字节

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

在线尝试！

— 吨·霍斯佩尔
source
2
正要问为什么P,E,T,A而不是T,A,P,E，但是我现在注意到您使用((P,E,T,A)x7)[2..-$^H+($^H=ord)而不是((T,A,P,E)x7)[0..-$^H+($^H=ord)-2保存两个字节。好答案！
— 凯文·克鲁伊森
的确很好！比我幼稚的方法好多了！不过，您可以使用文字^H（\x08）保存2个字节！
— Dom Hastings，
@DomHastings文字控制字符变量已被许多perl版本禁用。我可以在较旧的perl版本上获得分数（就像我最近所做的那样do$0），但是这里只有2个字节，所以我没有打扰
— Ton Hospel
啊，当然！这是因为macOS默认情况下具有5.18.2，所以这是我最熟悉的版本！
— Dom Hastings
4

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

输出：

— 稳定箱
source
4

Python 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]

在线尝试！

-1字节感谢Asone Tuhid

— 超中微子
source
@AsoneTuhid谢谢。我建议您发布自己的答案，因为您已经打了很多球，并且也对TFeld做了同样的事情，所以编辑会造成重复（这是不允许的）
— HyperNeutrino
好吧，有一个-1字节
— Asone Tuhid
@AsoneTuhid哦，好的，谢谢
— HyperNeutrino，
4

Scala，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
— 乔尼·格雷厄姆
source
欢迎使用PPCG，这是一个不错的第一答案！向我+1。
— 凯文·克鲁伊森
4

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!
— M4tini
source
2
欢迎光临本站！:)
— DJMcMayhem
3

JavaScript中，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] .reduce（
  （x，y）=>
    x + [... Array（
      （f = y.charCodeAt（）-（x.slice（-1）.charCodeAt（）））> 1？（f-1）：0
    ）]。降低（
      （e，r，t）=> 
        e +“ TAPE” [t％4]，“”）+ y
）;

我的问题是Java语言没有干净的方法来获取字符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>
展开摘要

— 贾尔
source
1
真好 您可以删除尾部的分号来保存字节，并通过分配charCodeAt变量来节省更多字节： 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))
— Rick Hitchcock
谢谢！我对它的工作原理感到非常恶心，但是很高兴知道它在将来会起作用。
— 贾尔
2

木炭，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
— 尼尔
source
2

点，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
— DLosc
source
2

JavaScript（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来填补空白，并使用递归来处理循环。

测试用例：

显示代码段

— 里克·希区柯克
source
2

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
— 街头小贩
source
2

Excel VBA，106字节

匿名VBE立即窗口函数，该函数通过单元格将输入作为大写字符串A1并输出到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
— 泰勒·斯科特
source
2

红宝石，59 53字节

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

在线尝试！

这实际上是非常简单的-我们将输入作为字符串分割成 一个字符数组（感谢Asone Tuhid指出了这一点）并应用reduce操作，在此我们使用“ TAPE”作为填充符字符串将每个字符调整为所需的长度。

— 基里尔
source
问题是您可以将输入作为字符数组。（53个字节）
— Asone Tuhid
2

K（oK），33个字节

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

在线尝试！

{ } 带参数的匿名函数 x

-':x 减去每个先验（在第一项之前使用虚数0）

1_ 删除第一项

0, 前置0

-1+ 加-1

0| 最大（0，...）

(... )#\:"TAPE"将字符串重塑"TAPE"为左侧列表中的每个项目

(... ),'x将相应的字符附加x到每个重整的字符串

,/ 连接所有

— ngn
source
2

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

学分

  • -2字节归功于RM
  • -4个字节（由于ceilingcat），通过升级到Java 10+并将类型切换到var
  • -3个字节，感谢Kevin Cruijssen，通过打印（以前的）替代版本的结果而不是返回它
— 奥利维尔·格雷戈尔（OlivierGrégoire）
source
int p=123将保存一个字符。p只要大于或等于第一个字符，第一个迭代中的内容都没有关系。第一个字符可以具有的最大值是'z'== ASCII 122，所以123就足够了。另外，如果使用大写字母，则可以使用91而不是123，以节省其他字符。
— RM
@RM谢谢，的确可以！
— 奥利维尔·格雷戈尔
1
— 凯文·克鲁伊森
1

C＃（.NET Core），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.
}
— 拉兹纳古尔
source
1
好的回答，我+1。您可以通过将更while改为for并删除括号来节省4个字节：for(int i=1,e,d;i<s.Length;r+=s[i++])for(e=d=s[i]-s[i-1];d-->1;r+=t[(e-d)%4]);。:)呵呵，既然你正在使用t="ETAP"只有一次，你可以直接使用它，并改变string以var挽救7个以上字节：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;}。
— 凯文·克鲁伊森
@KevinCruijssen：谢谢，我不会考虑通过将内容移至for循环来摆脱括号。另外，如果对丢失感到愚蠢，可以直接使用“ ETAP”。
— raznagul
您的答案仍然很好，所以不必担心。:)几乎每当我自己发布一个答案时，我都会得到高尔夫球提示。而且，比起从一开始就完全打好高尔夫，更容易打高尔夫。PS：您可能已经看过它们，但是如果您还没有读过C＃中的代码高尔夫球技巧和<all language>中的高尔夫球技巧，可能会很有趣。
— 凯文·克鲁伊森
1

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

在线尝试！

— 泰勒·斯科特
source
1

Clojure， 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 %))
— 约书亚记
source
1

APL（Dyalog Classic），30字节

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

在线尝试！

{ } 带参数的匿名函数 ⍵

⎕a⍳⍵ 在字母中查找其字符的索引

2-/ 成对差异（上一个减去下一个）

1+ 加1

- 否定

0⌈ 最大（0，...）

0, 前置0

⍴∘'TAPE'¨将字符串周期性地重塑'TAPE'为每个

⍵,¨⍨ 将参数中的每个字符附加到相应的重形字符串

∊ 展平

— ngn
source
1

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.
— 硕果累累
source
0

Java中，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提供的lambda和表达式提示。

— 阿米尔·M
source
1
欢迎光临本站！您可以删除很多空格来打高尔夫球，并确保检查Java中打高尔夫球的这些技巧！
— Caird coinheringaahing
1
您不需要创建变量t，因为您只使用了一次。你可以做"TAPETAPETAPETAPETAPETAPET".substring...。
— RM
欢迎来到PPCG！除了@RM所说的以外，您还可以打高尔夫：int a=1,l=i.length;a<=l;a++可以int a=0,l=i.length;++a<=l;，char u=i[a-1];o+=u;if(a<l){char n=可以char u=i[a-1],n;o+=u;if(a<l){n=，(n-u)不需要括号和n-u-1可以n+~u。另外，您的答案当前是代码段，而不是函数。要使其成为lambda，您需要i->{在前面和后面添加}。因此，总计：在线尝试。153个字节
— 凯文·克鲁伊森
— 吊顶猫
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.