Meydan okuma:

- , - , - skarakterleri üzerinde bir dize verildiğinde , kendisine uzunluğunu ekleyerek uzunluktaki ek karakterleri toplam uzunluğunun bir parçası olarak sayar .azAZ09ss

Giriş:

Sadece bir dizi keyfi uzunluk (boş olabilir).

Çıktı:

Aynı dize, ancak uzunluğu sonuna eklenmiş. Uzunluğu temsil eden karakterler de uzunluğun bir parçası olarak sayılmalıdır. Eklenecek birden fazla geçerli uzunluk olan durumlarda, mümkün olan en küçük olanı seçin (örnekler için test durumlarına bakın).

Test Durumları:

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

Kurallar:

Bu kod golf , bayt cinsinden en kısa kod kazanır. Standart boşluklar yasaktır. Gönderimler bütün bir program veya işlev olabilir ve sonucu stdout'a yazdırabilir veya bir işlevden bir değişken olarak geri döndürebilirsiniz.

Pyth - 7 bayt

+Qfql+Q

Burada çevrimiçi deneyin .

JavaScript (ES6), 32 bayt

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

Nasıl çalışır

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

Başlangıçtan itibaren N=0, orijinal giriş dizgisinin birleştirilmesinden oluşan dizgenin Nth karakterini (0-tabanlı) ve ondalık gösterimini test ederiz N. NBu karakter artık varolmayana kadar artırıyoruz .

Örnek:

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

Test durumları

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 bayt

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 bayt

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

Wandbox

Lua 5.2, 32 Bayt

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

Burada a değişkeni giriş dizgisidir.

Pyke, 8 bayt ( eski versiyon )

.f+liq)+

Açıklama:

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

Burada dene! (Yeni sürüm, 9 bayt)

Python 2, 54 48 46 bayt

Basit çözüm Özyineleme kısa sürdü.

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

Çevrimiçi deneyin

Haskell, 46 bayt

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

Kullanım örneği: f "aaaaaaaa"-> "aaaaaaaa9".

Sadece 0 ile başlayan tüm sayıları deneyin ve uygun olanı seçin.

Mathematica, 57 bayt

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

Adsız işlev, bir karakter dizisini giriş olarak alarak bir dize döndürür. Olduğu gerçeğini ortaya kullanır agiriş uzunluğu, giriş da, sayı eklemek için aek olarak basamak sayısı ( a+ uzunluğu a) sadece yerine, abasamak artı sayısı a. Ne yazık ki, ~Max~1özel durum olmadan boş dizge girişi için doğru cevabı vermezdi .

Brachylog , 13 bayt

l<L$@:?rc.lL,

Çevrimiçi deneyin!

açıklama

Temel olarak problemin bir açıklaması. LGirdi ile birleştiğinde, birleştiği zaman o birleştiğin uzunluğu olanı bulana kadar girişin uzunluğundan daha büyük olan her değeri deneyecektir .

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 bayt

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

Giriş, bir satır beslemesi (LF) ile sonlandırılmalıdır. Yalnızca uzunluğu 256'dan küçük olan girişler için çalışır (LF dahil).

Çevrimiçi deneyin!

açıklama

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

Not: Uzunluğu ascii çıktısına dönüştürmek için bu SO cevabındaki kodu kullandım ; Umarım bu PPCG'de kabul edilebilir. Bu benim ilk Codegolf sunumum ve ikinci BF programım. Geri bildirim bekliyoruz.

Retina , 22 bayt

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

Çevrimiçi deneyin!

Ah, eğer girdide görünen rakamlar olmasaydı, bu sadece 11 bayt olurdu:

+r`\d*$
$._

Ruby, 62 58 56 bayt

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

Test edildi irb.

Muhtemelen bunu yapmanın daha iyi bir yolu var, ama bu benim ilk geldiğim şeydi. Golf oynamadaki herhangi bir yardım sizin için çok değerlidir.

düzenleme: Parantez kullanımımın aşırı olduğunu anladım.

Perl 6 ,  46  35 bayt

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

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

Dene

Expanded:

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

[¹¾JDg¾Q#¼\

Oldukça basit bruteforce:

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

Çevrimiçi deneyin!

Python, 39 bayt

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

Daha uzun form:

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

Yinelemeli olarak Python 2 (41 bayt):

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

xGiriş dizesi ile başlayarak a, dönüşümü x -> a + str(len(x))üç kez uygular . Her zaman sabit noktaya ulaşmak için neden üç uygulamaya ihtiyaç duyulduğunu hala anlamadım.

PHP, 42 bayt

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

İle koş -r. ÇevrimiçiPHP İşlevlerinde Test Et .

bash, 47 bayt

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

Bunu bir komut dosyası olarak kaydedin ve giriş dizesini bir argüman olarak iletin.

Bu bir kaba kuvvet uygulamasıdır: işe yarayan bir tane bulana kadar sırayla her sayıyı deneyin.

> <> (Balık) 35 bayt

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

Yığına girdi alır, uzunluğu 9.99.999 ... değerlerine göre kontrol eder ve uzunluk yığın boyuna 1 eklemekten büyükse.

Haskell , 61 60 bayt

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

Çevrimiçi deneyin!

Özyinelemeli çözüm. Kullanımı:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 bayt

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

MATL , 11 bayt

`G@Vhtn@>]&

Çevrimiçi deneyin! Veya tüm test durumlarını doğrulayın .

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

Ruby, 49 bayt (işlev)

Program (son yeni satır gerekli değildir ve dolayısıyla puanlandırılmaz):

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

İşlev (son satır yeni)

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

Faktör, 55 bayt

Parkta yürüyüş var! Soruyu okuduktan hemen sonra kafamda bununla geldim.

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

Clojure, 72 bayt

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

R, 49 bayt

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

Oldukça basit bir çözüm.

Wolfram, 56

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

Verilen l = StringLength[x]bu ekler l + IntegerLength[l + IntegerLength[l]]için x.

Labirent , 48 45 41 bayt

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

Çevrimiçi deneyin!

@Martin Ender 'e teşekkür 4 bayt teşekkür edildi

ForceLang, 83 bayt

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