Compito

Scrivi un programma che prenderà (come input) un numero intero positivo. Conterà quindi da 0, aggiungendo ogni numero intero a a String, continuando solo se la lunghezza di Stringè inferiore al valore dell'input.

Un numero intero serializzato è definito come numero intero formato con il valore massimo che appartiene a String. Con "formato completo", l'intero non dovrebbe contenere cifre mancanti (che si verificherebbe se Stringsi rispettasse il vincolo di lunghezza di ).

L'output del programma dovrebbe essere il numero intero serializzato per il rispettivo input positivo.

Regole

• È il golf del codice, quindi vince la risposta più breve (in byte)!
• L'input sarà sempre positivo.
• L'output deve essere un numero intero in base-10 (decimale).
• Il programma deve essere indicizzato 0.

Esempio di input | Produzione

   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)

Appunti)

• Se hai domande (o desideri che io fornisca altri esempi), ti preghiamo di commentare!
• Ispirazione: /programming/45034478/how-do-i-calculate-the-ma maximum- serialized- integers-in- 1024- length- limit

JavaScript (ES6), 40 37 byte

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

Modifica: salvato 3 byte con l'aiuto di @Arnauld.

05AB1E , 10 7 byte

Idea di utilizzare i prefissi della risposta Jelly di Jonathan

LηJ€g›O

Provalo online!

Spiegazione

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 byte

Porto lambda ricorsivo dalla risposta di @ officialaimm .

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

Provalo online!

Japt , 13 byte

1n@P±X l >U}a

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Haskell , 55 53 50 byte

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

Provalo online!

L'uso è (1024#"") 0

Python 2 , 60 59 58 byte

• Grazie @Felipe per 2 byte

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

Provalo online!

Gelatina ,  11 10  9 byte

RD;\L€<⁸S

Un collegamento monadico che prende un numero intero positivo e restituisce un numero intero non negativo.

Provalo online!

Come?

la modifica...

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 byte

tf<Q=+d

Provalo online. Suite di test.

Perl 6 , 36 byte

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

Provalo online!

• 0 ...^ {...}è la sequenza di numeri da zero fino a uno in meno del numero per il quale il blocco di codice tra parentesi graffe restituisce true. (... senza il punto di inserimento restituirebbe il primo numero per il quale il blocco è tornato vero.)
• [~] 0 .. $^aè la concatenazione di numeri 0fino al numero corrente $^a(il parametro per il blocco di codice).
• .combè un elenco di tutti i caratteri (cifre) nella stringa concatenata. Interpretato come un numero, valuta la lunghezza della stringa. .charssarebbe più naturale usare qui, poiché valuta direttamente la lunghezza della stringa, ma il nome è più lungo di un carattere.
• $_ è l'argomento della funzione di livello superiore.
• [*-1] seleziona l'ultimo elemento dell'elenco generato.

QBIC , 34 byte

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

Spiegazione

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

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

Provalo online!

J, 26 byte

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

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

Provalo online!

WendyScript , 42 byte

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

f(1024) // returns 377

Provalo online!

Ungolfed:

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

PHP, 41 byte

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

Provalo online .

Java 8, 64 byte

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

O lievi alternative con lo stesso conteggio byte:

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;}

Spiegazione:

Provalo qui.

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

Rubino , 39 byte

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

Provalo online!

Rubino, 44 ​​byte

Ispirato dalla risposta JAVA di Kevin Cruijssen. -4 byte grazie a G B.

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

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

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

Provalo online!