Défi:

Étant donné une chaîne ssur les caractères a- z, A- Z, 0- 9, ajoutez la longueur de sà lui-même, en comptant le ou les caractères supplémentaires de la longueur dans la longueur totale de s.

Contribution:

Juste une chaîne de longueur arbitraire (peut être vide).

Sortie:

La même chaîne, mais avec sa longueur ajoutée à la fin. Les caractères qui représentent la longueur doivent également être comptés comme faisant partie de la longueur. Dans les cas où il y a plusieurs longueurs valides à ajouter, choisissez la plus petite possible (voir des exemples de tests).

Cas de test:

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

Règles:

C'est du code-golf , donc le code le plus court en octets gagne. Les échappatoires standard sont interdites. Les soumissions peuvent être un programme entier ou une fonction, et vous pouvez imprimer le résultat sur stdout ou le renvoyer sous forme de variable à partir d’une fonction.

Pyth - 7 octets

+Qfql+Q

Essayez-le en ligne ici .

JavaScript (ES6), 32 octets

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

Comment ça fonctionne

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

En commençant par N=0, nous testons le Nième caractère (base 0) de la chaîne constituée de la concaténation de la chaîne d'entrée d'origine et de la représentation décimale de N. Nous incrémentons Njusqu'à ce que ce personnage n'existe plus.

Exemple:

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

Cas de test

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 octets

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 octets

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

Boîte à baguette

Lua 5.2, 32 octets

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

Où la variable a est la chaîne d'entrée.

Pyke, 8 octets ( ancienne version )

.f+liq)+

Explication:

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

Essayez-le ici! (Nouvelle version, 9 octets)

Python 2, 54 48 46 octets

Solution simple. La récursion a fini par être plus courte.

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

Essayez-le en ligne

Haskell, 46 octets

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

Exemple d'utilisation: f "aaaaaaaa"-> "aaaaaaaa9".

Essayez simplement tous les nombres commençant par 0 et prenez le premier qui vous convient.

Mathematica, 57 octets

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

Fonction sans nom prenant un tableau de caractères en entrée et renvoyant une chaîne. Utilise le fait que si aest la longueur de l'entrée, le nombre à ajouter à l'entrée est aainsi que le nombre de chiffres dans ( a+ la longueur de a), plutôt que simplement ale nombre de chiffres de a. Malheureusement, cela ne donnerait pas la bonne réponse pour l'entrée chaîne vide sans le ~Max~1cas particulier.

Brachylog , 13 octets

l<L$@:?rc.lL,

Essayez-le en ligne!

Explication

Fondamentalement, une description du problème. Il essaiera toute valeur Lsupérieure à la longueur de l'entrée jusqu'à ce qu'il en trouve une pour laquelle, lorsqu'elle est concaténée à l'entrée, correspond à la longueur de cette concaténation.

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 octets

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

L'entrée doit être terminée par un saut de ligne (LF). Ne fonctionne que pour les entrées de longueur inférieure à 256 (y compris le BF).

Essayez-le en ligne!

Explication

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

Remarque: j'ai utilisé le code de cette réponse SO pour convertir la longueur en sortie ascii; J'espère que cela est acceptable sur PPCG. Ceci est ma première soumission Codegolf et mon deuxième programme BF. Les commentaires sont les bienvenus.

Rétine , 22 octets

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

Essayez-le en ligne!

Eh bien, s'il n'y avait pas de chiffres dans l'entrée, cela ne serait que 11 octets:

+r`\d*$
$._

Ruby, 62 58 56 octets

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

Testé dans irb.

Il existe probablement une meilleure façon de procéder, mais c’est la première chose que j’ai trouvée. Toute aide au golf serait appréciée.

edit: J'ai réalisé que mon utilisation des parenthèses était excessive.

Perl 6 ,  46  35 octets

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

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

L'essayer

Étendu:

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

[¹¾JDg¾Q#¼\

Bruteforce assez simple:

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

Essayez-le en ligne!

Python, 39 octets

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

Forme plus longue:

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

Itérativement en Python 2 (41 octets):

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

En commençant par xla chaîne d'entrée a, applique la transformation x -> a + str(len(x))trois fois. Je ne comprends toujours pas pourquoi trois applications sont nécessaires pour toujours atteindre le point fixe.

PHP, 42 octets

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

Courez avec -r. Testez à OnlinePHPfunctions .

bash, 47 octets

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

Enregistrez ceci en tant que script et transmettez la chaîne d'entrée en tant qu'argument.

C'est une implémentation en force brute: essayez chaque chiffre à tour de rôle jusqu'à trouver celui qui fonctionne.

> <> (Poisson) 35 octets

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

Prend une entrée sur la pile, vérifie la longueur par rapport aux valeurs de 9,99 999 ... et si la longueur est supérieure à 1, ajoutez 1 à la longueur de la pile.

Haskell , 61 60 octets

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

Essayez-le en ligne!

Solution récursive Usage:

Prelude> c "aaaaaaaaa"
"aaaaaaaaa11"

C #, 77 octets

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

MATL , 11 octets

`G@Vhtn@>]&

Essayez-le en ligne! Ou vérifiez tous les cas de test .

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

Ruby, 49 octets (fonction)

Programme (la dernière nouvelle ligne n’est pas nécessaire et n’est donc pas notée):

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

Fonction (le dernier saut de ligne est marqué):

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

Facteur, 55 octets

C'est une promenade dans le parc! J'ai pensé à cela dès que j'ai lu la question.

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

Clojure, 72 octets

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

R, 49 octets

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

Solution assez simple.

Wolfram, 56 ans

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

Étant donné l = StringLength[x]qu'il ajoute l + IntegerLength[l + IntegerLength[l]]à x.

Labyrinthe , 48 45 41 octets

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

Essayez-le en ligne!

4 octets sauvés remerciés à @Martin Ender

ForceLang, 83 octets

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