Tantangan:

Diberikan string spada karakter a- z, A- Z, 0- 9, tambahkan panjangnya ssendiri, dengan menghitung karakter tambahan dalam panjangnya sebagai bagian dari panjang total s.

Memasukkan:

Hanya seutas panjang acak (bisa kosong).

Keluaran:

String yang sama, tetapi dengan panjangnya ditambahkan sampai akhir. Karakter yang mewakili panjang juga harus dihitung sebagai bagian dari panjang. Dalam kasus di mana ada beberapa panjang yang valid untuk ditambahkan, pilih yang terkecil yang mungkin (lihat kasus uji untuk contoh).

Kasus uji:

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

Aturan:

Ini adalah kode-golf , jadi kode terpendek dalam byte menang. Celah standar dilarang. Kiriman dapat berupa seluruh program atau fungsi, dan Anda dapat mencetak hasilnya ke stdout atau mengembalikannya sebagai variabel dari suatu fungsi.

Pyth - 7 byte

+Qfql+Q

Cobalah online di sini .

JavaScript (ES6), 32 byte

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

Bagaimana itu bekerja

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

Dimulai dengan N=0, kami menguji karakter ke-N (berbasis-0) dari string yang dibuat dari rangkaian string input asli dan representasi desimal dari N. Kami bertambah Nhingga karakter ini tidak ada lagi.

Contoh:

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

Uji kasus

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

Wandbox

Lua 5.2, 32 Bytes

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

Di mana variabel a adalah string input.

Pyke, 8 byte ( versi lama )

.f+liq)+

Penjelasan:

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

Coba di sini! (Versi baru, 9 byte)

Python 2, 54 48 46 byte

Solusi sederhana. Rekursi menjadi lebih pendek.

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

Cobalah online

Haskell, 46 byte

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

Contoh penggunaan: f "aaaaaaaa"-> "aaaaaaaa9".

Cukup coba semua angka dimulai dengan 0 dan ambil yang pertama sesuai.

Mathematica, 57 byte

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

Fungsi tanpa nama mengambil array karakter sebagai input dan mengembalikan string. Menggunakan fakta bahwa jika aadalah panjang input, maka jumlah untuk menambahkan input aditambah jumlah digit dalam ( a+ panjang a), bukan hanya aditambah jumlah digit a. Sayangnya itu tidak akan memberikan jawaban yang benar untuk input string kosong tanpa ~Max~1case khusus.

Brachylog , 13 byte

l<L$@:?rc.lL,

Cobalah online!

Penjelasan

Pada dasarnya deskripsi masalah. Ini akan mencoba setiap nilai Llebih besar dari panjang input sampai menemukan satu yang, ketika digabungkan ke input, adalah panjang dari gabungan tersebut.

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

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

Input harus diakhiri oleh linefeed (LF). Hanya berfungsi untuk input dengan panjang kurang dari 256 (termasuk LF).

Cobalah online!

Penjelasan

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

Catatan: Saya menggunakan kode dari jawaban SO ini untuk mengonversi panjang menjadi keluaran ascii; Saya harap ini dapat diterima di PPCG. Ini adalah pengiriman Codegolf pertama saya, dan program BF kedua saya. Umpan balik disambut.

Retina , 22 byte

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

Cobalah online!

Ah, kalau bukan karena digit muncul di input, ini hanya akan 11 byte:

+r`\d*$
$._

Ruby, 62 58 56 byte

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

Diuji dalam irb.

Mungkin ada cara yang lebih baik untuk melakukan ini, tetapi ini adalah hal pertama yang saya pikirkan. Bantuan apa pun dalam bermain golf akan dihargai.

sunting: Saya menyadari bahwa penggunaan tanda kurung saya berlebihan.

Perl 6 ,  46  35 byte

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

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

Cobalah

Diperluas:

{   # 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#¼\

Bruteforce cukup mudah:

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

Cobalah online!

Python, 39 byte

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

Bentuk lagi:

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

Iteratif dalam Python 2 (41 byte):

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

Dimulai dengan xsebagai string input a, terapkan transformasi x -> a + str(len(x))tiga kali. Saya masih tidak jelas mengapa tiga aplikasi diperlukan untuk selalu mencapai titik tetap.

PHP, 42 byte

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

Jalankan dengan -r. Tes di FungsiPH Online .

bash, 47 byte

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

Simpan ini sebagai skrip, dan berikan string input sebagai argumen.

Ini adalah implementasi brute force: coba setiap angka secara bergantian sampai Anda menemukan yang berfungsi.

> <> (Ikan) 35 byte

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

Mengambil input ke stack, periksa panjangnya terhadap nilai 9,99.999 ... dan jika panjangnya lebih besar dari tambah 1 ke panjang stack.

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

Cobalah online!

Solusi rekursif. Pemakaian:

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@>]&

Cobalah online! Atau verifikasi semua kasus uji .

`      % 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 (program)

Ruby, 49 byte (fungsi)

Program (baris baru terakhir tidak diperlukan dan karenanya tidak disimpan):

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

Fungsi (baris baru terakhir dicetak):

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

Faktor, 55 byte

Ini jalan-jalan di taman! Saya memikirkan hal ini segera setelah saya membaca pertanyaan itu.

[ 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='')

Solusi yang sangat mudah.

Wolfram, 56

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

Mengingat l = StringLength[x]itu ditambahkan l + IntegerLength[l + IntegerLength[l]]ke x.

Labyrinth , 48 45 41 byte

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

Cobalah online!

Disimpan 4 byte berterima kasih kepada @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