挑战：

给定s字符a- z，A- Z，0- 上的字符串9，将其长度附加s到其自身，将长度中的其他字符计为的总长度s。

输入：

只是任意长度的字符串（可以为空）。

输出：

相同的字符串，但其长度附加到末尾。代表长度的字符也应算作长度的一部分。如果要附加多个有效长度，请选择最小的长度（有关示例，请参见测试用例）。

测试用例：

INPUT     -> OUTPUT       // Comment
aaa       -> aaa4
          -> 1            // Empty string
aaaaaaaa  -> aaaaaaaa9    // aaaaaaaa10 would also normally be valid, but violates using the smallest number rule mentioned above
aaaaaaaaa -> aaaaaaaaa11
a1        -> a13          // Input can contain numbers at the end of the string, you do not have to handle the fact that it looks like 13 rather than 3.

Longer test case(s):

aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa101
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa -> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa102

规则：

这是代码高尔夫球，因此以字节为单位的最短代码获胜。禁止出现标准漏洞。提交可以是整个程序或函数，您可以将结果打印到stdout或将其作为变量从函数返回。

Pyth-7个字节

+Qfql+Q

在这里在线尝试。

JavaScript（ES6），32个字节

f=(s,n=0)=>(s+n)[n]?f(s,n+1):s+n

这个怎么运作

f = (s, n = 0) =>   // given a string 's' and starting with n = 0:
  (s + n)[n] ?      // if the Nth character of (s + n) exists:
    f(s, n + 1)     //   try again with n + 1
  :                 // else
    s + n           //   return s + n

首先N=0，我们测试由原始输入字符串和的十进制表示形式串联而成的字符串的第N个字符（从0开始）N。我们递增N直到该字符不再存在。

例：

N =  0 : abcdefghi0
         ^
N =  1 : abcdefghi1
          ^
N =  2 : abcdefghi2
           ^
...
N =  8 : abcdefghi8
                 ^
N =  9 : abcdefghi9
                  ^
N = 10 : abcdefghi10
                   ^
N = 11 : abcdefghi11    -> success
                    ^

测试用例

f=(s,n=0)=>(s+n)[n]?f(s,n+1):s+n

console.log(f("aaa"));       // -> aaa4
console.log(f(""));          // -> 1
console.log(f("aaaaaaaa"));  // -> aaaaaaaa9
console.log(f("aaaaaaaaa")); // -> aaaaaaaaa11
console.log(f("a1"));        // -> a13

乳胶，108/171

\newcounter{c}\def\s#1#2]{\stepcounter{c}\def\t{#2}\ifx\empty\t\arabic{c}\else#1\s#2]\fi}\def\q[#1]{\s#10]}

\q[] //1

JavaScript（ES6），37个字节

f=(s,t=s,u=s+t.length)=>t==u?t:f(s,u)

<input oninput=o.textContent=f(this.value)><pre id=o>

C，67 65 61字节

x;f(*v){printf("%d",(int)log10(x=-~printf(v))*-~(x%10>8)+x);}

魔盒

Lua 5.2，32字节

a=arg[1]print(a..#a+#(''..#a+1))

其中变量a是输入字符串。

Pyke，8个字节（旧版本）

.f+liq)+

说明：

.f    )  -  first where (i++)
  +      -    input + i
   l     -    len(^)
    iq   -   ^ == i
       + - input + ^

在这里尝试！（新版本，9字节）

Python 2，54 48 46字节

简单的解决方案。递归最终变得更短。

f=lambda s,n=0:f(s,n+1)if(s+`n`)[n:]else s+`n`

在线尝试

Haskell，46个字节

f s=[l|i<-[0..],l<-[s++show i],length l==i]!!0

用法示例：f "aaaaaaaa"-> "aaaaaaaa9"。

只需尝试从0开始的所有数字，然后选择适合的第一个数字即可。

Mathematica，57个字节

#<>ToString[(a=Length@#)+(i=IntegerLength)[a+i@a]~Max~1]&

未命名函数，将字符数组作为输入并返回字符串。使用以下事实：如果a是输入的长度，则要追加到输入a的数字是加（a+的长度a）中a的位数，而不仅仅是加的位数a。不幸的是，如果没有~Max~1特殊情况，它将无法为空字符串输入提供正确的答案。

Brachylog，13个字节

l<L$@:?rc.lL,

在线尝试！

说明

基本上是问题的描述。它将尝试L大于输入长度的每个值，直到找到一个值，该值在连接到输入时就是该连接的长度。

l<L              length(Input) < L
  L$@            Convert L to a string
     :?rc.       The Output is the concatenation of the Input with L as string
         .lL,    The length of the Output is L itself

Brainfuck，258字节

,>+<----------[++++++++++>+[>+<-],----------]<[<]>[.>]>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

输入必须由换行（LF）终止。仅适用于长度小于256（包括LF）的输入。

在线尝试！

说明

# read first char and add one to cell #1
# the cell after the input will contain the length
,>+<
# subtract 10 to check for LF
----------
# while the input is not 10 (LF)
[
# restore the input to its original value
++++++++++
# add one to the length
>+
# cut and paste the length to the next cell, then read the input
[>+<-],
# subtract 10 to check for LF
----------
]
# for input abc, the tape here would be: a b c *0* 4
# rewind to the beginning of the input
<[<]>
# print the input string
[.>]>
# convert the length to ascii chars and output them
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

注意：我使用了这个SO答案中的代码来将长度转换为ascii输出。我希望这在PPCG上是可以接受的。这是我第一次提交Codegolf，也是我第二次BF程序。欢迎反馈。

视网膜，22字节

\G`
.
x
+r`\d*$
$._
x

在线尝试！

嗯，好吧，如果不是输入中出现数字，那将只有11个字节：

+r`\d*$
$._

Ruby，62 58 56字节

s=gets.chomp;p s+"#{(s+"#{(s+"#{s.size}").size}").size}"

在中测试irb。

可能有更好的方法来做到这一点，但这是我想到的第一件事。任何打高尔夫球的帮助将不胜感激。

编辑：我意识到我对括号的使用过多。

Perl 6的， 46  35个字节

{$_~(.chars,*.chars+.chars...{$^a==$^b})[*-1]}

{$_~(.chars,*.chars+.chars...*)[2]}

试试吧

展开：

{   # bare block lambda with implicit parameter ｢$_｣

  $_  # the input

  ~   # concatenated with

  (  # sequence generator

    .chars,  # the number of chars in ｢$_｣ (seed the generator)


    *\      # Whatever lambda input (represents previous value)
    .chars  # number of chars in that
    +       # plus
    .chars  # the number of chars in ｢$_｣


    ...     # keep doing that until

    *       # indefinitely

  )[2] # get the value at index 2 of the sequence
}

05AB1E，11个字节

[¹¾JDg¾Q#¼\

非常简单的蛮力：

            Implicit i = 0
[           while true
 ¹¾J        Concatenate input and i -> str
    Dg¾Q#   Break if length(str) == i
         ¼\ Else, i += 1

在线尝试！

Python，39个字节

lambda a:eval('a+str(len('*3+'a))))))')

较长的形式：

lambda a:a+str(len(a+str(len(a+str(len(a))))))

在Python 2中迭代（41个字节）：

x=a=input();exec"x=a+`len(x)`;"*3;print x

从x作为输入字符串开始a，应用转换x -> a + str(len(x))三次。我仍然不清楚为什么需要三个应用程序才能始终达到目标。

PHP，42字节

while(++$n<strlen($a=$argv[1].$n));echo$a;

用运行-r。在OnlinePHPfunctions中进行测试。

bash，47个字节

 for((n=-1;${#s} != $n;));{ s=$1$[++n];};echo $s

将其另存为脚本，然后将输入字符串作为参数传递。

这是一个蛮力的实现：依次尝试每个数字，直到找到一个有效的数字。

> <>（鱼）35字节

i:1+?!v:o
ln;v9l<  >
*9+>:&)?!^1l&a

将输入输入堆栈，根据值9,99,999 ...检查长度，如果长度大于堆栈长度加1。

Haskell，61 60字节

e=length
l%n|s<-show$l+1,n>e s=s|m<-n+1=(l+1)%m
c s=s++e s%2

在线尝试！

递归解决方案。用法：

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C＃，77个字节

n=>{int a=n.Length;int c=(a+1).ToString().Length-1;return(n+(n.Length+1+c));}

MATL，11个字节

`G@Vhtn@>]&

在线尝试！或验证所有测试用例。

`      % Do...while
  G    %   Push input
  @    %   Push iteration index (1-based)
  V    %   Convert number to string
  h    %   Concatenate horizontally
  t    %   Duplicate
  n    %   Get length of concatenated string
  @    %   Push iteration index
  >    %   True if length of concatenated string exceeds iteration index
]      % End. Run next iteration if top of stack is true; else exit loop
&      % Specifiy that next function (implicit display) takes only one input
       % Implicitly display top of the stack. This is the concatenated string
       % that had a length equal to the iteration index

Ruby，51个字节（程序）

Ruby，49个字节（功能）

程序（不需要最后一个换行符，因此不计分）：

x=gets.strip
i=0
i+=1 until(y=x+i.to_s).size==i
p y

函数（对最后一个换行符进行评分）：

def f x
i=0
i+=1 until(y=x+i.to_s).size==i
y
end

因子，55字节

在公园里散步！读完问题，我脑子里就想到了这个。

[ dup length dup log10 ⌈ + >integer 10 >base append ]

Clojure，72个字节

(defn f([s](f s 1))([s n](if(=(count(str s n))n)(str s n)(f s(inc n)))))

R，49个字节

cat(a<-scan(,""),(t<-nchar(a))+nchar(t+1),sep='')

非常简单的解决方案。

沃尔夫拉姆，56岁

#<>ToString@Nest[l+IntegerLength@#&,l=StringLength@#,2]&

给定l = StringLength[x]它附加l + IntegerLength[l + IntegerLength[l]]到x。

迷宫，48 45 41字节

)"   10/{:@!
.,;: _ { _ ;
   })"}) 10-9!@

在线尝试！

感谢@Martin Ender保存了4个字节

ForceLang，83个字节

set s io.readln()
label 1
set n 1+n
set t s+n
if t.len=n
 io.write t
 exit()
goto 1