Sfida:

Dato una stringa ssui caratteri a- z, A- Z, 0- 9, aggiungi la lunghezza di sse stesso, contando i caratteri aggiuntivi nella lunghezza come parte della lunghezza totale di s.

Ingresso:

Solo una stringa di lunghezza arbitraria (può essere vuota).

Produzione:

La stessa stringa, ma con la sua lunghezza aggiunta alla fine. Anche i caratteri che rappresentano la lunghezza devono essere conteggiati come parte della lunghezza. Nei casi in cui vi siano più lunghezze valide da aggiungere, scegliere la più piccola possibile (vedere esempi di test).

Casi 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

Regole:

Questo è code-golf , quindi vince il codice più breve in byte. Sono vietate le scappatoie standard. Gli invii possono essere un intero programma o una funzione e puoi stampare il risultato su stdout o restituirlo come variabile da una funzione.

Pyth - 7 byte

+Qfql+Q

Provalo online qui .

JavaScript (ES6), 32 byte

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

Come funziona

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

A partire da N=0, testiamo l'ennesimo carattere (basato su 0) della stringa costituita dalla concatenazione della stringa di input originale e dalla rappresentazione decimale di N. Aumentiamo Nfino a quando questo personaggio non esiste più.

Esempio:

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

Casi 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 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 byte

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

Dove la variabile a è la stringa di input.

Pyke, 8 byte ( vecchia versione )

.f+liq)+

Spiegazione:

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

Provalo qui! (Nuova versione, 9 byte)

Python 2, 54 48 46 byte

Soluzione semplice. La ricorsione ha finito per essere più breve.

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

Provalo online

Haskell, 46 byte

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

Esempio di utilizzo: f "aaaaaaaa"-> "aaaaaaaa9".

Prova semplicemente tutti i numeri che iniziano con 0 e prendi il primo che si adatta.

Mathematica, 57 byte

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

Funzione senza nome che accetta una matrice di caratteri come input e restituisce una stringa. Usa il fatto che se aè la lunghezza dell'input, il numero da aggiungere all'ingresso è apiù il numero di cifre ( a+ la lunghezza di a), piuttosto che solo ail numero di cifre di a. Sfortunatamente non darebbe la risposta giusta per l'input di stringa vuota senza il ~Max~1caso speciale.

Brachylog , 13 byte

l<L$@:?rc.lL,

Provalo online!

Spiegazione

Fondamentalmente una descrizione del problema. Proverà ogni valore Lmaggiore della lunghezza dell'input fino a quando non ne trova uno per il quale, quando concatenato all'input, è la lunghezza di tale concatenazione.

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

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

L'ingresso deve essere terminato con un avanzamento riga (LF). Funziona solo per input con una lunghezza inferiore a 256 (incluso LF).

Provalo online!

Spiegazione

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

Nota: ho usato il codice di questa risposta SO per convertire la lunghezza in output ASCII; Spero che questo sia accettabile su PPCG. Questa è la mia prima presentazione su Codegolf e il mio secondo programma BF. Il feedback è gradito.

Retina , 22 byte

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

Provalo online!

Ah bene, se non fosse per le cifre che compaiono nell'input, questo sarebbe solo 11 byte:

+r`\d*$
$._

Rubino, 62 58 56 byte

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

Testato in irb.

Probabilmente c'è un modo migliore per farlo, ma questa è stata la prima cosa che mi è venuta in mente. Qualsiasi aiuto nel golf sarebbe apprezzato.

modifica: ho capito che il mio uso delle parentesi era eccessivo.

Perl 6 ,  46  35 byte

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

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

Provalo

Allargato:

{   # 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 piuttosto semplice:

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

Provalo online!

Python, 39 byte

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

Forma più lunga:

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

Iterativamente in Python 2 (41 byte):

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

A partire da xcome stringa di input a, applica la trasformazione x -> a + str(len(x))tre volte. Non sono ancora chiaro il motivo per cui sono necessarie tre applicazioni per raggiungere sempre il punto fisso.

PHP, 42 byte

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

Corri con -r. Test su OnlinePHPfunctions .

bash, 47 byte

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

Salvalo come script e passa la stringa di input come argomento.

È un'implementazione della forza bruta: prova ogni numero a turno finché non ne trovi uno che funzioni.

> <> (Pesce) 35 byte

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

Riceve input nello stack, controlla la lunghezza rispetto ai valori 9,99.999 ... e se la lunghezza è maggiore di aggiungi 1 alla lunghezza dello 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

Provalo online!

Soluzione ricorsiva. Uso:

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

Provalo online! Oppure verifica tutti i casi di 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 byte (programma)

Ruby, 49 byte (funzione)

Programma (l'ultima riga non è necessaria e quindi non è stata classificata):

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

Funzione (viene segnata l'ultima riga):

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

Fattore, 55 byte

È una passeggiata nel parco! Mi è venuto in mente questo non appena ho letto la domanda.

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

Soluzione piuttosto semplice.

Wolfram, 56

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

Dato che l = StringLength[x]si aggiunge l + IntegerLength[l + IntegerLength[l]]a x.

Labyrinth , 48 45 41 byte

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

Provalo online!

Salvati 4 byte ringraziati su @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