Tarea

Escriba un programa que tome (como entrada) un número entero positivo. Luego contará desde 0, agregando cada número entero a a String, solo continuará si la longitud del valor Stringes menor que el valor de la entrada.

Un entero serializado se define como el entero completamente formado con el valor máximo que pertenece al String. Por "completamente formado", el entero no debería tener dígitos faltantes (lo que ocurriría si Stringse cumple la restricción de longitud del ).

La salida del programa debe ser el entero serializado para su respectiva entrada positiva.

Reglas

• Es el código de golf, por lo que gana la respuesta más corta (en bytes).
• La entrada siempre será positiva.
• La salida debe ser un número entero en base-10 (decimal).
• El programa debe estar indexado a 0.

Entrada de ejemplo | Salida

   5 | 4   (0 1 2 3 4              - Length of 5)
  11 | 9   (0 1 2 3 4 5 6 7 8 9 1  - Length of 11)
  12 | 10  (0 1 2 3 4 5 6 7 8 9 10 - Length of 12)
1024 | 377 (0 1 2 3 4 5 6 7 8 ...  - Length of 1024)

Nota (s)

• Si tiene alguna pregunta (o desea que le proporcione más ejemplos), ¡por favor comente!
• Inspiración: /programming/45034478/how-do-i-calculate-the-maximum-serialized-integers-in-1024-length-limit

JavaScript (ES6), 40 37 bytes

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

<input type=number min=1 value=1 oninput=o.textContent=f(this.value)><pre id=o>0

Editar: guardado 3 bytes con algo de ayuda de @Arnauld.

05AB1E , 10 7 bytes

Idea para usar prefijos de la respuesta de Jonathan Jelly

LηJ€g›O

Pruébalo en línea!

Explicación

L         # range [1 ... input]
 η        # prefixes
  J       # join each to string
   €g     # get length of each string
     ›    # input is greater than string length
      O   # sum

Python 2 , 55 bytes

Puerto lambda recursivo de la respuesta de @ officialaimm .

f=lambda k,s='',i=1:k>len(s+`i`)and f(k,s+`i`,i+1)or~-i

Pruébalo en línea!

Japt , 13 bytes

1n@P±X l >U}a

¡Pruébelo en línea!

Explicación

1n@ P± X l >U}a
1nX{P+=X l >U}a
                   Implicit: U = input integer, P = empty string
  X{         }a    Return the first integer X in [0, 1, 2, ...] that returns a truthy value:
    P+=X             Append X to P.
         l >U        Return P.length > U.
                   This returns the first integer that can't fit into the U-char string.
1n                 Subtract 1 from the result.
                   Implicit: output result of last expression

PHP , 56 bytes

for(;$argn>$l=strlen($r);)$r.=+$i++;echo$i-1-($argn<$l);

Pruébalo en línea!

Haskell , 55 53 50 bytes

(n#x)a|l<-a++show x=last$x-1:[n#l$x+1|length l<=n]

Pruébalo en línea!

El uso es (1024#"") 0

Python 2 , 60 59 58 bytes

• Gracias @Felipe por 2 bytes

i,j,k='',1,input()
while len(i+`j`)<k:i+=`j`;j+=1
print~-j

Pruébalo en línea!

Gelatina ,  11 10  9 bytes

RD;\L€<⁸S

Un enlace monádico que toma un número entero positivo y devuelve un número entero no negativo.

Pruébalo en línea!

¿Cómo?

edición...

RD;\L€<⁸S - link: number n
R         - range -> [1,2,...10,11,...,n-1]
 D        - convert to decimal (vectorises) -> [[1],[2],...,[1,0],[1,1],...D(n-1)]
   \      - cumulative reduce by:
  ;       -   concatenation -> prefixes i.e.: [[1],[1,2],...,[1,2,...,1,0],[1,2,...,1,0,1,1],[1,2,...,1,0,1,1,...Flattened(D(n))]]
    L€    - length of €ach -> [1,2,3,...,11,13,...,length([1,2,...,1,0,1,1,...Flattened(D(n))])]
       ⁸  - chain's left argument, n
      <   - less than? (vectorises)
        S - sum (yields the number of prefixes that are less than or equal in length to n)
          -   Note: `0` is excluded from the range and all the prefixes, but including
          -         it would mean comparing to n+1 AND decrementing at the end (for a
          -         total cost of a byte)

Pyth, 8 7 bytes

tf<Q=+d

Pruébalo en línea. Banco de pruebas.

Perl 6 , 36 bytes

{(0...^{([~] 0..$^a).comb>$_})[*-1]}

Pruébalo en línea!

• 0 ...^ {...}es la secuencia de números desde cero hasta uno menos que el número para el cual el bloque de código entre llaves devuelve verdadero. ( ...sin el intercalado devolvería el primer número para el que el bloque devuelve verdadero).
• [~] 0 .. $^aes la concatenación de números 0hasta el número actual $^a(el parámetro para el bloque de código).
• .combes una lista de todos los caracteres (dígitos) en la cadena concatenada. Interpretado como un número, evalúa la longitud de la cadena. .charssería más natural de usar aquí, ya que se evalúa directamente a la longitud de la cadena, pero el nombre es un carácter más largo.
• $_ es el argumento de la función de nivel superior.
• [*-1] selecciona el último elemento de la lista generada.

QBIC , 34 bytes

{A=!p$~_lB+A|>:|_xp-1|\B=B+A]p=p+1

Explicación

{           DO infinitely
A=!p$       Set A$ to p cast to num
            Note that p starts out as 0.
~      >:   IF the input number is exceeded by
 _l   |     the length of
   B+A      A$ and B$ combined
_xp-1|      THEN QUIT, printing the last int successfully added to B$
            The _X operator quits, (possibly) printing something if followed by a-zA-Z
            _x is slightly different, it prints the expression between the operator _x and |
\B=B+A      ELSE add A$ to B$
]           END IF
p=p+1       Raise p, and rerun

Python 2 , 44 bytes

f=lambda k,i=0:-2*(k<0)or-~f(k-len(`i`),i+1)

Pruébalo en línea!

J 26 bytes

(>i:1:)([:+/\[:>.10^.1+i.)

((>i:1:)([:+/\[:>.10^.1+i.))"0 ] 5 11 12 1024 2000 20000 100000 1000000
4 9 10 377 702 5276 22221 185184

R , 43 bytes

n=scan();sum(cumsum(floor(log10(1:n))+1)<n)

Pruébalo en línea!

WendyScript , 42 bytes

<<f=>(x){<<n=""#i:0->x{n+=i?n.size>=x/>i}}

f(1024) // returns 377

Pruébalo en línea!

Sin golf:

let f => (x) {
  let n = ""
  for i : 0->x { 
    n+=i
    if n.size >= x 
    ret i
  }
  ret
}

PHP, 41 bytes

while(strlen($s.=+$i++)<=$argn);echo$i-2;

Pruébalo en línea .

Java 8, 64 bytes

n->{int i=0;for(String t="0";;t+=++i)if(t.length()>n)return~-i;}

O alternativas leves con el mismo número de bytes:

n->{int i=0;for(String t="";;t+=i++)if(t.length()>n)return i-2;}
n->{int i=-1;for(String t="";;t+=++i)if(t.length()>n)return~-i;}

Explicación:

Pruébalo aquí

n->{                  // Method with integer as both parameter and return-type
  int i=0;            //  Integer `i`, starting at 0
  for(String t="0";   //  String, starting at "0"
      ;               //  Loop indefinitely
       t+=++i)        //    After every iteration: append the String with `i+1`
                      //    by first increasing `i` by 1 with `++i`
    if(t.length()>n)  //   If the length of the String is larger than the input:
      return~-i;      //    Return `i-1`
                      //  End of loop (implicit / single-line body)
}                     // End of method

Ruby , 39 bytes

->n{~-(0..n).find{|x|0>n-="#{x}"=~/$/}}

Pruébalo en línea!

Ruby, 44 bytes

Inspirado por la respuesta JAVA de Kevin Cruijssen. -4 bytes gracias a G B.

->n{i,t=0,'';t+="#{i+=1}"while t.size<n;i-1}

Perl 5 , 31 + 1 ( -p) = 32 bytes

$".=++$\while$_>=length$"}{$\--

Pruébalo en línea!