Thử thách:

Đưa ra một chuỗi strên các ký tự a- z, A- Z, 0- 9, nối thêm độ dài của schính nó, đếm (các) ký tự bổ sung theo chiều dài như một phần của tổng chiều dài s.

Đầu vào:

Chỉ cần một chuỗi có độ dài tùy ý (có thể để trống).

Đầu ra:

Cùng một chuỗi, nhưng với độ dài của nó được nối vào cuối. Các ký tự đại diện cho chiều dài cũng nên được tính là một phần của chiều dài. Trong trường hợp có nhiều độ dài hợp lệ để nối thêm, hãy chọn độ dài nhỏ nhất có thể (xem trường hợp kiểm tra để biết ví dụ).

Các trường hợp thử nghiệm:

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

Quy tắc:

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng. Sơ hở tiêu chuẩn bị cấm. Đệ trình có thể là toàn bộ chương trình hoặc chức năng và bạn có thể in kết quả ra thiết bị xuất chuẩn hoặc trả lại dưới dạng một biến từ một chức năng.

Pyth - 7 byte

+Qfql+Q

Hãy thử trực tuyến tại đây .

JavaScript (ES6), 32 byte

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

Làm thế nào nó hoạt động

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

Bắt đầu với N=0, chúng tôi kiểm tra ký tự thứ N (dựa trên 0) của chuỗi được tạo bằng cách nối chuỗi đầu vào ban đầu và biểu diễn thập phân của N. Chúng tôi gia tăng Ncho đến khi nhân vật này không còn tồn tại nữa.

Thí dụ:

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

Các trường hợp thử nghiệm

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

LaTeX, 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 byte

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 byte

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

Cây đũa phép

Lua 5.2, 32 byte

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

Trong đó biến a là chuỗi đầu vào.

Pyke, 8 byte ( phiên bản cũ )

.f+liq)+

Giải trình:

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

Hãy thử nó ở đây! (Phiên bản mới, 9 byte)

Python 2, 54 48 46 byte

Giải pháp đơn giản. Đệ quy kết thúc ngắn hơn.

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

Dùng thử trực tuyến

Haskell, 46 byte

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

Ví dụ sử dụng: f "aaaaaaaa"-> "aaaaaaaa9".

Đơn giản chỉ cần thử tất cả các số bắt đầu bằng 0 và lấy số đầu tiên phù hợp.

Toán học, 57 byte

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

Hàm không tên lấy một mảng các ký tự làm đầu vào và trả về một chuỗi. Sử dụng thực tế là nếu alà độ dài của đầu vào, thì số để nối vào đầu vào là acộng với số chữ số trong ( a+ độ dài của a), thay vì chỉ acộng với số chữ số của a. Thật không may, nó sẽ không đưa ra câu trả lời đúng cho đầu vào chuỗi trống mà không có ~Max~1trường hợp đặc biệt.

Brachylog , 13 byte

l<L$@:?rc.lL,

Hãy thử trực tuyến!

Giải trình

Về cơ bản là một mô tả của vấn đề. Nó sẽ thử mọi giá trị Llớn hơn độ dài của đầu vào cho đến khi tìm thấy một giá trị mà khi được nối với đầu vào là độ dài của phép nối đó.

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 byte

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

Đầu vào phải được chấm dứt bởi một nguồn cấp dữ liệu (LF). Chỉ hoạt động đối với các đầu vào có độ dài nhỏ hơn 256 (bao gồm cả LF).

Hãy thử trực tuyến!

Giải trình

# 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
>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>[-]>>>++++++++++<[->-[>+>>]>[+[-
<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>[-]]<[<[->-<]++++++[->++++++++
<]>.[-]]<<++++++[-<++++++++>]<.[-]<<[-<+>]

Lưu ý: Tôi đã sử dụng mã từ câu trả lời SO này để chuyển đổi độ dài thành đầu ra ascii; Tôi hy vọng điều này được chấp nhận trên PPCG. Đây là lần gửi Codegolf đầu tiên của tôi và chương trình BF thứ hai của tôi. Phản hồi được hoan nghênh.

Võng mạc , 22 byte

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

Hãy thử trực tuyến!

À, nếu không có chữ số xuất hiện trong đầu vào, thì đây sẽ chỉ là 11 byte:

+r`\d*$
$._

Ruby, 62 58 56 byte

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

Đã thử nghiệm trong irb.

Có lẽ có một cách tốt hơn để làm điều này, nhưng đây là điều đầu tiên tôi nghĩ ra. Bất kỳ trợ giúp trong việc chơi golf sẽ được đánh giá cao.

chỉnh sửa: Tôi nhận ra việc sử dụng dấu ngoặc đơn của tôi là quá mức.

Perl 6 ,  46  35 byte

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

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

Thử nó

Mở rộng:

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

[¹¾JDg¾Q#¼\

Khá đơn giản bruteforce:

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

Hãy thử trực tuyến!

Python, 39 byte

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

Hình thức dài hơn:

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

Lặp lại trong Python 2 (41 byte):

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

Bắt đầu với xchuỗi đầu vào a, áp dụng phép biến đổi x -> a + str(len(x))ba lần. Tôi vẫn không rõ tại sao cần có ba ứng dụng để luôn đạt đến điểm cố định.

PHP, 42 byte

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

Chạy với -r. Kiểm tra tại các chức năng trực tuyến .

bash, 47 byte

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

Lưu cái này dưới dạng tập lệnh và truyền chuỗi đầu vào làm đối số.

Đó là một triển khai vũ lực: thử lần lượt từng số cho đến khi bạn tìm thấy một số hoạt động.

> <> (Cá) 35 byte

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

Đưa đầu vào vào ngăn xếp, kiểm tra độ dài so với các giá trị 9,99.999 ... và nếu chiều dài lớn hơn thêm 1 vào chiều dài ngăn xếp.

Haskell , 61 60 byte

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

Hãy thử trực tuyến!

Giải pháp đệ quy. Sử dụng:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 byte

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

MATL , 11 byte

`G@Vhtn@>]&

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

`      % 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 byte (chương trình)

Ruby, 49 byte (chức năng)

Chương trình (dòng mới nhất là không cần thiết và do đó không được bảo vệ):

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

Chức năng (dòng mới nhất được ghi):

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

Yếu tố, 55 byte

Đó là một cuộc dạo chơi trong công viên! Tôi nghĩ ra điều này trong đầu ngay khi đọc câu hỏi.

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

Clojure, 72 byte

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

R, 49 byte

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

Giải pháp khá đơn giản.

Sói, 56

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

Cho l = StringLength[x]nó nối l + IntegerLength[l + IntegerLength[l]]vào x.

Mê cung , 48 45 41 byte

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

Hãy thử trực tuyến!

Đã lưu 4 byte cảm ơn @Martin Ender

ForceLang, 83 byte

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