ท้าทาย:

กำหนดสตริงsตัวอักษรa- z, A- Z, 0- 9ผนวกความยาวของsตัวเองนับตัวอักษรเพิ่มเติม (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

กฎ:

นี่คือcode-golfดังนั้นรหัสที่สั้นที่สุดในหน่วยไบต์ชนะ ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม การส่งอาจเป็นโปรแกรมทั้งหมดหรือฟังก์ชั่นและคุณอาจพิมพ์ผลลัพธ์ไปที่ 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เราจะทำการทดสอบตัวละครชับ (0-based) 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

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 ไบต์

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

Wandbox

Lua 5.2, 32 Bytes

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 ไบต์

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

อินพุตจะต้องถูกยกเลิกโดย linefeed (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#¼\

bruteforce ตรงไปตรงมาสวย:

            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

ทุบตี, 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='')

ทางออกที่ตรงไปตรงมาสวย

Wolfram, 56

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

ได้รับl = StringLength[x]มันผนวกไปl + IntegerLength[l + IntegerLength[l]]x

เขาวงกต , 48 45 41 ไบต์

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

ลองออนไลน์!

บันทึกแล้ว 4 ไบต์ขอบคุณ @Martin Ender

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