让我们做浪吧！

29

输入：

  • 长度为的字符串（片段）>= 2。
  • 正整数n >= 1。

输出：

我们输出单线波形。为此，我们将输入字符串重复n次。

挑战规则：

  • 如果输入字符串的第一个字符和最后一个字符匹配，我们在总输出中只输出一次（即^_^长度为2 ^_^_^而不是^_^^_^）。
  • 输入字符串将不包含任何空格/制表符/换行符/等。
  • 如果您的语言不支持非ASCII字符，那就可以了。只要它仍然符合仅ASCII波形输入的挑战。

一般规则：

  • 这是代码高尔夫球，因此最短答案以字节为单位。
    不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能短的答案。
  • 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有正确参数的函数/方法，完整程序。你的来电。
  • 默认漏洞是禁止的。
  • 如果可能，请为您的代码添加一个带有测试的链接。
  • 另外，如有必要，请添加说明。

测试用例：

_.~"(              length 12
_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(

'°º¤o,¸¸,o¤º°'     length 3
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'

-__                length 1
-__

-__                length 8
-__-__-__-__-__-__-__-__

-__-               length 8
-__-__-__-__-__-__-__-__-

¯`·.¸¸.·´¯         length 24
¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯

**                 length 6
*******

String & length of your own choice (be creative!)
code-golf  string 
— 凯文·克鲁伊森
source
将带有结果的代码段添加到问题中将是很不错的:)
— Qwertiy
2
“一个正整数n >= 1 ”对我来说似乎有点浮躁……:)
— paolo 16-10-9

Answers:

8

Pyke，15 14 10字节

tQQhQeq>*+

在这里尝试！

  QhQeq    -    input_1[0] == input_1[-1]
 Q     >   -   input_1[^:]
        *  -  ^ * V
t          -   input_2 - 1
         + - input_1 + ^
— 蓝色
source
+1看起来像波浪一样的解释！
— wastl
23

Python 3，32个字节

lambda s,n:s+s[s[0]==s[-1]:]*~-n

连接n字符串的副本，从所有副本中删除第一个字符，但如果第一个字符与最后一个字符匹配，则删除第一个字符。

— 异或
source
这不能正确处理问题的“’·········”字符串，对吗？当我尝试它，s[0]并且s[-1]似乎是指第一个和最后一个字节，而不是第一个和最后一个字符。编辑：啊，等等，这是Python的2对Python的3。它正常工作在Python 3
— HVD
15

05AB1E，13个字节

使用CP-1252编码。

D¬U¤XQi¦}I<×J

在线尝试！

说明

-___-并3用作输入。

D              # duplicate input string
               # STACK: "-___-", "-___-"
 ¬U¤X          # push copies of the first and last element of the string
               # STACK: "-___-", "-___-", "-", "-"
     Q         # compare for equality 
               # STACK: "-___-", "-___-", 1
      i¦}      # if true, remove the first char of the copy of the input string
               # STACK: "-___-", "___-" 
         I<    # push input number and decrease by 1
               # STACK: "-___-", "___-", 2
           ×   # repeat the top string this many times
               # STACK: "-___-", "___-___-"
            J  # join with input string
               # STACK: "-___-___-___-"
               # implicitly output
— 艾米尼亚
source
11

JavaScript（ES6），47个字节

f=
(s,n)=>s+s.slice(s[0]==s.slice(-1)).repeat(n-1)
;
<div oninput=o.textContent=n.value&&f(s.value,n.value)><input id=s><input id=n type=number min=1><div id=o>
展开摘要

— 尼尔
source
1
恭喜20k！
— 阿德南
2
@Adnan谢谢！也是20002，这很好而且很对称。
— 尼尔
1
在这种情况下有可能会招惹吗？我的意思是，s=>n=>...而不是(s,n)=>
— Zwei，2016年
8

Perl，29个字节

28个字节的代码+ 1个-p。

感谢@Dada帮助我节省了几个字节！

s/^((.).*?)(\2?)$/$1x<>.$3/e

用法

perl -pe 's/^((.).*?)(\2?)$/$1x<>.$3/e' <<< "'°º¤o,¸¸,o¤º°'
3"
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'
perl -pe 's/^((.).*?)(\2?)$/$1x<>.$3/e' <<< '**
6'
*******

在线示例。

— 唐·黑斯廷斯
source
2
真好 您可以使用<>代替来（间接）节省3个字节，$'因为它可以让您摆脱-0。然后，您可以使用s///e而不是//;$_=再赢得一个字节：-)
— 达达
@Dada不错...我完全搞砸了我的原始尝试，将其简化了一下，最终使其变得更大了...我已经接受了您的评论，但我似乎需要一个$匹配的结尾，仍然为我节省了字节不使用'意味着我可以删除它，必须将其保存到文件中以保存添加3 -p并将其放回1！
— Dom Hastings
1
呵呵 是的，确实需要它$来代替您之前拥有的换行符。（对不起，我的评论不是很详细，我很着急...）
— 达达
我喜欢<>在替换字符串中使用的想法。但是，如果n用空格代替换行符，则字符数可以减少一些：s/(.+?) (\d+)/$1x$2/e
— sosamrage ossifrage
1
@DomHastings啊，我的错。没有正确阅读问题：-)
— 挤压ossifrage
6

Perl，23个字节

包括+1的 -p

在STDIN的不同行上输入输入字符串，后跟数字

wave.pl <<< "'°º¤o,¸¸,o¤º°'
3"

wave.pl：

#!/usr/bin/perl -p
$_ x=<>;s/(.)\K
\1?//g

如果单词中的第一个字符不是正则表达式特殊字符，则此22字节版本也适用：

#!/usr/bin/perl -p
$_ x=<>;/./;s/
$&?//g
— 吨·霍斯佩尔
source
整齐！我认为您/g虽然粘贴了它，却忘记了它；-)
— Dada
@Dada糟糕。固定
— Ton Hospel '16
5

MATL，19 17 14字节

ttP=l):&)liX"h

这适用于在线解释器上的ASCII以及使用MATLAB运行时的unicode和ASCII。

在线尝试！

说明

        % Implicitly grab the input as a string
        %   STACK:  {'abcdea'}
        %
tt      % Make two copies and push them to the stack
        %   STACK:  {'abcdea'    'abcdea'    'abcdea'}
        %
P       % Flip the second copy around
        %   STACK:  {'abcdea'    'abcdea'    'aedcba'}
        %
=       % Perform an element-wise comparison. Creates a boolean array
        %   STACK:  {'abcdea'    [1 0 0 0 1]}
        %
l)      % Get the first element. If the first and last char are the same this will be
        % TRUE (1), otherwise FALSE (0)
        %   STACK:  {'abcdea'    1 }
        %
:       % Create an array from [1...previous result]. If the first char was repeated,
        % this results in the scalar 1, otherwise it results in an empty array: []
        %   STACK: {'abcdea'    1 } 
        %
&)      % Break the string into pieces using this index. If there were repeated
        % characters, this pops off the first char, otherwise it pops off
        % an empty string
        %   STACK: {'a'    'bcdea'}
        %
li      % Push the number 1 and explicitly grab the second input argument
        %   STACK: {'a'    'bcdea'    1    3}
        %
X"      % Repeat the second string this many times
        %   STACK: {'a'    'bcdeabcdeabcdea'}
        %
h       % Horizontally concatenate the first char (in case of repeat) 
        % or empty string (if no repeat) with the repeated string
        %   STACK: {'abcdeabcdeabcdea'}
        %
        % Implicitly display the result
— Suever
source
4

批处理，117字节

@set/ps=
@set t=%s%
@if %s:~0,1%==%s:~1% set t=%s:~1%
@for /l %%i in (2,1,%1)do @call set s=%%s%%%%t%%
@echo %s%

将重复次数作为命令行参数，并从STDIN中读取字符串。

— 尼尔
source
3

Gema，41个字符

* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}

样品运行：

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< '_.~"( 12'
_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< "'°º¤o,¸¸,o¤º°' 3"
'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'

bash-4.3$ gema '* *=@subst{\? \$1=\?\; =;@repeat{$2;$1 }}' <<< '** 6'
*******
— 工作的人
source
3

PowerShell v2 +，48个字节

Param($s,$n)$s+$s.Substring($s[0]-eq$s[-1])*--$n

输出整个字符串一次，然后输出字符串或子字符串的n-1个副本，具体取决于第一个和最后一个字符是否匹配。

的 .Substring()方法从提供给字符串末尾的索引输出，因此，如果$s[0]-eq$s[-1]计算结果为false（0），则将获得整个字符串。如果该语句为真（1），则从第二个字符开始获取子字符串。

— 本欧文
source
丹吉特，我打了几分钟。我有相同的答案（使用$ a和$ b代替$ s和$ n）。
— AdmBorkBork
3

VBA 119字节

此游戏的新手，并且vba以最高的字节数获胜：P

PS：不能相信vba会紧靠JAVA HAHA

Function l(s,x)
l=s: s=IIf(Left(s,1)=Right(s,1),Mid(s,2,Len(s)),s)
z: x=x-1: If x>0 Then l=l & s: GoTo z:
End Function

说明：

+------------------------------------------------------------+-----------------------------------------------------------------------------------+
|                            code                            |                                     function                                      |
+------------------------------------------------------------+-----------------------------------------------------------------------------------+
| l=s                                                        | input string s is saved to base                                                   |
| s = IIf(Left(s, 1) = Right(s, 1), Right(s, Len(s) - 1), s) | checks whether 1 and last char is equal,                                          |
|                                                            | if yes removes the first char from s and that s will be used to for further joins |
| z:                                                         | z: is a label                                                                     |
| x = x - 1:                                                 | decreases looping round                                                           |
| If x > 0 Then l = l & s: GoTo z:                           | join strings until no more rounds to do                                           |
+------------------------------------------------------------+-----------------------------------------------------------------------------------+
— 克里什·KM
source
3
欢迎来到PPCG！作为我自己的QBasic程序员，我会说您可以删除大多数空格，并且仍然具有有效的VBA代码，因为您可以键入或粘贴缩短的代码（通过自动格式化程序添加空格），然后运行即可正常工作。那将大大提高您的分数。:)
— DLosc
3

CJam，16 15字节

l]li*{(s@)@|@}*

在线尝试

说明：

l]li*            Create a list of n-times the input string.
{(s@)@|@}*       Fold this list by taking out the last character of the first 
                 argument and the first character of the second argument and 
                 replacing them by their unique set union.
                 e.g.: "aba" "aba" -> "ab" 'a"a"| "ba" -> "ab" "a" "ba"
                       "abc" "abc" -> "ab" 'c"a"| "bc" -> "ab" "ca" "bc
— Neorej
source
2
我喜欢你的波浪输入。:)
— Kevin Cruijssen '16
3

K，12字节

{,/[y#(,)x]}


/in action
{,/[y#(,)x]}["lollol";4]
"lollollollollollollollol"
{,/[y#(,)x]}["-_";10]
"-_-_-_-_-_-_-_-_-_-_"

/explanation (read function from right to left)
x is the string and y is the number of repetitions
(,)y    --enlist x so it becomes 1 value (rather than a list)
y#x     --take y many items of x
,/      --coalesce the list ,/[("-_";"-_")] --> "-_-_"

谢谢

— Chromozorz
source
这打破规则1 {,/y#,$[(*x)~*|x;-1;0]_x}的25首字节手柄/最后的匹配。如果你感到快乐决胜规则1，那么你可以{,/y#,x}为8
— streetster
2

PHP，72字节

<?=($a=$argv[1]).str_repeat(substr($a,$a[0]==substr($a,-1)),$argv[2]-1);

使用PHP 7.1可以减少到65个字节

<?=($a=$argv[1]).str_repeat(substr($a,$a[0]==$a[-1]),$argv[2]-1);
— 约格·赫尔瑟曼
source
2

点子，18字节

正则表达式解决方案，利用“输入中没有空格”规则。将stdin中的字符串和数字作为命令行参数。

(q.s)XaR`(.) \1?`B

在线尝试！

说明：

 q.s                Read from stdin and append a space
(   )Xa             String-multiply by first cmdline arg
       R            Replace
        `(.) \1?`     Regex: char followed by space followed by (optional) same char again
                 B    Callback function, short for {b}: return 1st capturing group

因此，a b变成ab，a a变成a，并删除字符串末尾的空格。然后将结果自动打印。

— DLosc
source
2

Haskell，59个字节

a%b=concat$replicate a b
a@(s:z)#n|s/=last z=n%a|1<2=s:n%z

非高尔夫版本：

-- Helper: Appends str to itself n times
n % str = concat (replicate n str)

-- Wave creating function
(x:xs) # n
 -- If start and end of wave differ, 
 | x /= last xs = n%(x:xs)
 | otherwise   = x:(n%xs)
— 克雷格·罗伊（Craig Roy）
source
2

爪哇10，123个 111 109 107 102 100 79字节

s->n->{var r=s;for(;n-->1;r+=s.matches("(.).*\\1")?s.substring(1):s);return r;}

在线尝试。

具有相同字节数（79个字节）的备用项：

(s,n)->{for(var t=s.matches("(.).*\\1")?s.substring(1):s;n-->1;s+=t);return s;}

在线尝试。

我当然会尝试回答我自己的问题。;）
5个字节，感谢@ dpa97。
从Java 7到10的-21字节转换

说明：

s->n->{                // Method with String and integer parameters and String return-type
  var r=s;             //  Result-String, starting at the input-String
  for(;n-->1;          //  Loop `n-1` times
    r+=s.matches("(.).*\\1")?
                       //   If the first and last characters are the same:
        s.substring(1) //    Append the result-String with the input-String, 
                       //    excluding the first character
       :               //   Else:
        s);            //    Append the result-String with the input-String
  return r;}           //  Return the result-String
— 凯文·克鲁伊森
source
1
s.split（“ ^。”）[1]代替s.replaceAll（“ ^。”，“”）应该可以，保存几个字节
— dpa97
@ dpa97谢谢！我已经编辑了 我总是忘记利用.split。
— 凯文·克鲁伊森
@ dpa97我想我（或者我们一直在想）它s.substring(1)短了两个字节。;）
— Kevin Cruijssen
@KevinCurijssen是的，应该已经发现了，很好的发现。我认为我一直坚持使用正则表达式的想法...
— dpa97
1

Javascript ES6，49个字符

(s,n)=>s.replace(/(.).*?(?=\1?$)/,m=>m.repeat(n))

测试：

f=(s,n)=>s.replace(/(.).*?(?=\1?$)/,m=>m.repeat(n))
console.log(document.querySelector("pre").textContent.split(`
`).map(s=>s.split` `).every(([s,n,k])=>f(s,n)==k))
<pre>_.~"( 12 _.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(
'°º¤o,¸¸,o¤º°' 3 '°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'°º¤o,¸¸,o¤º°'
-__ 1 -__
-__ 8 -__-__-__-__-__-__-__-__
-__- 8 -__-__-__-__-__-__-__-__-
¯`·.¸¸.·´¯ 24 ¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯`·.¸¸.·´¯
** 6 *******</pre>
展开摘要

— Qwertiy
source
1

QBIC，65个字节

;:~left$$|(A,1)=right$$|(A,1)|A=left$$|(A,len(A)-1)][1,a|B=B+A]?B

我想我应该将LEFT $和RIGHT $添加到QBIC ...

说明：

;          make the first cmd line parameter into A$
:          make the second cmd line parameter into a (num)
~left..]   Drop the last char if equal to the first char
[1,a...]   FOR the given number of repetitions, concat A$ to B$ (starts out empty)
?B         print B$
— 施滕伯格
source
1

C＃，79个字节

(s,n)=>s+new string('x',n-1).Replace("x",s[0]==s[s.Length-1]?s.Substring(1):s);

重复字符串的一种荒谬方法。创建具有所需重复长度的新字符串，然后将每个字符替换为要重复的字符串。除此之外，其他策略看起来几乎是相同的策略。

/*Func<string, int, string> Lambda =*/ (s, n) =>
    s                                      // Start with s to include first char at start
    + new string('x', n - 1).Replace("x",  // Concatenate n-1 strings of...
        s[0] == s[s.Length - 1]            // if first/last char are the same
            ? s.Substring(1)               // then skip the first char for each concat
            : s                            // else concat whole string each time
    )
;
— 牛奶
source
1
嗯，如果输入字符串中包含一个x？也许最好将其更改为空格，因为“ 输入字符串将不包含任何空格/制表符/换行符/等。 ”。
— 凯文·克鲁伊森
1
如果输入有，它将很好地工作x。它首先创建xx...x字符串，然后替换每个x字符串，而无需从头开始重新评估需要替换的字符串。
— 牛奶
1

SpecBAS-68字节

1 INPUT a$,n: l=LEN a$: ?IIF$(a$(1)<>a$(l),a$*n,a$( TO l-1)*n+a$(l))

使用inline- IF检查第一个和最后一个字符是否相同。如果不是，则打印字符串n次数。否则，将字符串拼接为length-1，重复该操作并将最后一个字符放在末尾。

只能接受ASCII字符（或SpecBAS IDE内置的字符）

在此处输入图片说明

— 布赖恩
source
1

APL，19个字节

{⍺,∊1↓⍵⍴⊂⍺↓⍨⊃⍺=⊃⌽⍺}

用法：

      '^_^' {⍺,∊1↓⍵⍴⊂⍺↓⍨⊃⍺=⊃⌽⍺} 5
^_^_^_^_^_^

说明：

  • ⊃⍺=⊃⌽⍺：查看第一个字符是否与最后一个字符匹配
  • ⍺↓⍨：如果是这种情况，请删除第一个字符
  • ⊂：附上结果
  • ⍵⍴：复制⍵时间
  • 1↓：删除第一个（比短(⍵-1)⍴）
  • ∊：获取所有简单元素（撤消装箱）
  • ⍺,：将整个字符串的一个实例添加到最前面
— 马里纳斯
source
1

后记，98字节

exch/s exch def/l s length 1 sub def s 0 get s l get eq{/s s 0 l getinterval def}if{s print}repeat

...但是您可能需要在其上加上一个“ flush”，以使您的PS解释器可以刷新通讯缓冲区，另外六个字节:(

— 迪·迪布
source
1

Common Lisp（LispWorks），176个字节

(defun f(s pos)(if(equal(elt s 0)(elt s #1=(1-(length s))))(let((s1(subseq s 0 1))(s2(subseq s 0 #1#)))(dotimes(j pos)(format t s2))(format t s1))(dotimes(j pos)(format t s))))

用法：

    CL-USER 130 > (f "_.~~\"(" 12)
    _.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(_.~"(
    NIL

    CL-USER 131 > (f "'°o¤o,??,o¤o°'" 3)
    '°o¤o,??,o¤o°'°o¤o,??,o¤o°'°o¤o,??,o¤o°'
    NIL

    CL-USER 132 > (f "-__" 1)
    -__
    NIL

    CL-USER 133 > (f "-__" 8)
    -__-__-__-__-__-__-__-__
    NIL

    CL-USER 134 > (f "ˉ`·.??.·′ˉ" 24)
    ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ`·.??.·′ˉ
    NIL

    CL-USER 135 > (f "**" 6)
    *******
    NIL

说明：

~~ =>   ~

\" =>   "

高尔夫：

    (defun f (s pos)
      (if (equal (elt s 0) (elt s (1- (length s))))
          (let ((s1 (subseq s 0 1)) (s2 (subseq s 0 (1- (length s)))))
            (dotimes (j pos)
              (format t s2))
            (format t s1))        
        (dotimes (i pos)
          (format t s))))
— Sadfaf
source
1

Vim，17个字节

执行此操作的简单方法是使用反向引用正则表达式，该正则表达式可以判断第一个和最后一个字符是否匹配。但是长的正则表达式很长。我们不想要那个。

lDg*p^v$?<C-P>$<CR>hd@aP

要重复的波在缓冲区中。我假设要重复的数字在寄存器中"a（qaNq使用N作为要设置的数字键入）。这个想法是：

  • 如果第一个和最后一个字节匹配，请删除所有内容，直到最后一个字符。
  • 如果第一个和最后一个字节不匹配，请删除所有字符。

然后P删除文本@a时间。

  • lDg*：此操作会创建一个与任何第一个字符匹配的正则表达式，而不管它是否需要转义，或者它是否是单词。（*足以制作正确转义的正则表达式，但是\<\>如果它是单词字符（如_），则会添加不必要的垃圾。）
  • p^：最后一步很混乱。清理到行首的原始位置。
  • v$：在可视模式下， $默认情况下移至后的线的端部。
  • ?<C-P>$<CR>hd：如果前一个正则表达式位于该行的末尾，则此搜索将移至该正则表达式；否则，请不要超出行尾。从那里向左移动，我们完成了所需的（乏味的）删除。
  • @aP：将数字重复作为宏运行，以用作参数P。
— 乌迪欧卡
source
1

Ruby，38个字节

->s,n{s[0]==s[-1]?s[0..-2]*n+s[0]:s*n}

我认为这很不言自明。我仍然想知道是否有一种更简洁的方式来表示s[0..-2]块，但是我还没有找到它。

— 李伟
source
0

Java（117字节）

String w(String a,int b){String c=a;for(;b>0;b--)c+=b+a.substring(a.charAt(a.length()-1)==a.charAt(0)?1:0);return c;}
— 编码的
source
1
嗨，欢迎来到PPCG！嗯，我已经在这里发布了一个简短的Java 7答案。您使用的方法与我之前使用的方法类似。通过使用同样的方法，你可以打高尔夫球b>0;b--来b-->0;。另外，为什么b+在c+=b+a.substring？不过，如果您独立提出来，这是一个很好的第一答案。祝您在PPCG的住宿愉快！:)此外，您可能会发现有趣的Java高尔夫技巧。
— 凯文·克鲁伊森
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.