Herausforderung:

Wenn Sie eine Zeichenfolge sfür die Zeichen a- z, A- Z, 0- 9angeben, hängen Sie die Länge von san sich selbst an und zählen die zusätzlichen Zeichen in der Länge als Teil der Gesamtlänge von s.

Eingang:

Nur eine Zeichenfolge von beliebiger Länge (kann leer sein).

Ausgabe:

Dieselbe Zeichenfolge, aber mit der Länge am Ende angehängt. Die Zeichen, die die Länge darstellen, sollten ebenfalls als Teil der Länge gezählt werden. In Fällen, in denen mehrere gültige Längen angehängt werden müssen, wählen Sie die kleinstmögliche aus (Beispiele finden Sie unter Testfälle).

Testfälle:

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

Regeln:

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes. Standardlücken sind verboten. Einsendungen können ein gesamtes Programm oder eine Funktion sein, und Sie können entweder das Ergebnis als Standardausgabe drucken oder es als Variable von einer Funktion zurückgeben.

Pyth - 7 Bytes

+Qfql+Q

Probieren Sie es hier online aus .

JavaScript (ES6), 32 Byte

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

Wie es funktioniert

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

Beginnend mit N=0testen wir das N-te Zeichen (0-basiert) der Zeichenfolge, die aus der Verkettung der ursprünglichen Eingabezeichenfolge und der Dezimaldarstellung von besteht N. Wir erhöhen, Nbis dieses Zeichen nicht mehr existiert.

Beispiel:

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

Testfälle

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 Bytes

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

Wobei die Variable a die Eingabezeichenfolge ist.

Pyke, 8 Bytes ( alte Version )

.f+liq)+

Erläuterung:

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

Probieren Sie es hier aus! (Neue Version, 9 Bytes)

Python 2, 54 48 46 Bytes

Einfache lösung. Die Rekursion war kürzer.

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

Probieren Sie es online aus

Haskell, 46 Bytes

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

Anwendungsbeispiel: f "aaaaaaaa"-> "aaaaaaaa9".

Probieren Sie einfach alle Zahlen aus, die mit 0 beginnen und nehmen Sie die erste, die passt.

Mathematica, 57 Bytes

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

Unbenannte Funktion, die ein Array von Zeichen als Eingabe verwendet und eine Zeichenfolge zurückgibt. Verwendet die Tatsache, dass, wenn adie Länge der Eingabe ist, die an die Eingabe anzuhängende Zahl aplus die Anzahl der Stellen in ( a+ die Länge von a) ist und nicht nur aplus die Anzahl der Stellen von a. Leider würde es ohne den ~Max~1Sonderfall nicht die richtige Antwort für die Leerstring-Eingabe geben .

Brachylog , 13 Bytes

l<L$@:?rc.lL,

Probieren Sie es online!

Erläuterung

Grundsätzlich eine Beschreibung des Problems. Jeder Wert, der Lgrößer als die Länge der Eingabe ist, wird geprüft, bis ein Wert gefunden wird , dessen Verkettung mit der Eingabe die Länge dieser Verkettung ist.

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 Bytes

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

Die Eingabe muss durch einen Zeilenvorschub (LF) abgeschlossen werden. Funktioniert nur für Eingaben mit einer Länge von weniger als 256 (einschließlich LF).

Probieren Sie es online!

Erläuterung

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

Hinweis: Ich habe Code aus dieser SO-Antwort verwendet , um die Länge in ASCII-Ausgabe zu konvertieren. Ich hoffe, dass dies bei PPCG akzeptabel ist. Dies ist meine erste Codegolf-Einsendung und mein zweites BF-Programm. Feedback ist willkommen.

Netzhaut , 22 Bytes

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

Probieren Sie es online!

Ah, ohne die Ziffern in der Eingabe wären das nur 11 Bytes:

+r`\d*$
$._

Ruby, 62 58 56 Bytes

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

Getestet in irb.

Es gibt wahrscheinlich einen besseren Weg, dies zu tun, aber das war das erste, was ich mir ausgedacht habe. Jede Hilfe beim Golfen wäre dankbar.

edit: Mir ist aufgefallen, dass ich zu viele Klammern verwendet habe.

Perl 6 ,  46  35 Bytes

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

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

Versuch es

Erweitert:

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

[¹¾JDg¾Q#¼\

Ziemlich unkomplizierte Bruteforce:

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

Probieren Sie es online!

Python, 39 Bytes

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

Längere Form:

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

Iterativ in Python 2 (41 Byte):

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

Beginnend mit xals Eingabezeichenfolge awird die Transformation x -> a + str(len(x))dreimal angewendet. Mir ist immer noch nicht klar, warum drei Anwendungen benötigt werden, um immer den Fixpunkt zu erreichen.

PHP, 42 Bytes

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

Laufen Sie mit -r. Test bei OnlinePHPfunctions .

Bash, 47 Bytes

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

Speichern Sie dies als Skript und übergeben Sie die Eingabezeichenfolge als Argument.

Es ist eine Brute-Force-Implementierung: Probieren Sie jede Zahl der Reihe nach aus, bis Sie eine finden, die funktioniert.

> <> (Fisch) 35 Bytes

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

Nimmt Eingaben in den Stapel auf, vergleicht die Länge mit den Werten 9,99,999 ... und addiert 1 zur Stapellänge, wenn die Länge größer ist.

Haskell , 61-60 Bytes

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

Probieren Sie es online!

Rekursive Lösung. Verwendungszweck:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 Bytes

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

MATL , 11 Bytes

`G@Vhtn@>]&

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

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

Ruby, 49 Bytes (Funktion)

Programm (letzter Zeilenumbruch ist nicht erforderlich und daher nicht bewertet):

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

Funktion (letzte Zeile wird gewertet):

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

Faktor 55 Bytes

Es ist ein Spaziergang im Park! Sobald ich die Frage gelesen hatte, fiel mir dies in meinem Kopf ein.

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

Clojure, 72 Bytes

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

R, 49 Bytes

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

Ziemlich einfache Lösung.

Wolfram, 56

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

Da l = StringLength[x]hängt es l + IntegerLength[l + IntegerLength[l]]an x.

Labyrinth , 48 45 41 Bytes

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

Probieren Sie es online!

4 Bytes gespart, danke an @Martin Ender

ForceLang, 83 Bytes

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