Tâche

Écrivez un programme qui prendra (en entrée) un entier positif. Il comptera ensuite à partir de 0, en ajoutant chaque entier à a String, en ne continuant que si la longueur de Stringest inférieure à la valeur de l'entrée.

Un entier sérialisé est défini comme l'entier entièrement formé avec la valeur maximale appartenant au String. Par "entièrement formé", l'entier ne devrait avoir aucun chiffre manquant (ce qui se produirait si la contrainte de longueur de la Stringest remplie).

La sortie du programme doit être l' entier sérialisé pour son entrée positive respective.

Règles

• C'est le golf de code, donc la réponse la plus courte (en octets) gagne!
• L'entrée sera toujours positive.
• La sortie doit être un entier en base 10 (décimal).
• Le programme doit être indexé 0.

Exemple d'entrée | Production

   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)

Remarques)

• Si vous avez des questions (ou si vous souhaitez que je donne plus d'exemples), veuillez commenter!
• Inspiration: /programming/45034478/how-do-i-calculate-the-maximum-serialized-integers-in-1024-length-limit

JavaScript (ES6), 40 37 octets

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

Edit: enregistré 3 octets avec l'aide de @Arnauld.

05AB1E , 10 7 octets

Idée d'utiliser des préfixes de la réponse Jelly de Jonathan

LηJ€g›O

Essayez-le en ligne!

Explication

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 octets

Port lambda récursif de la réponse de @ officialaimm .

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

Essayez-le en ligne!

Japt , 13 octets

1n@P±X l >U}a

Testez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Haskell , 55 53 50 octets

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

Essayez-le en ligne!

L'utilisation est (1024#"") 0

Python 2 , 60 59 58 octets

• Merci @Felipe pour 2 octets

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

Essayez-le en ligne!

Gelée ,  11 10  9 octets

RD;\L€<⁸S

Un lien monadique prenant un entier positif et retournant un entier non négatif.

Essayez-le en ligne!

Comment?

édition ...

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 octets

tf<Q=+d

Essayez-le en ligne. Suite de tests.

Perl 6 , 36 octets

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

Essayez-le en ligne!

• 0 ...^ {...}est la séquence de nombres de zéro jusqu'à un de moins que le nombre pour lequel le bloc de code entre accolades renvoie vrai. ( ...sans le signe d'insertion retournerait le premier nombre pour lequel le bloc a renvoyé true.)
• [~] 0 .. $^aest la concaténation des nombres du 0numéro actuel $^a(le paramètre au bloc de code).
• .combest une liste de tous les caractères (chiffres) de la chaîne concaténée. Interprété comme un nombre, il évalue la longueur de la chaîne. .charsserait plus naturel à utiliser ici, car il évalue directement la longueur de la chaîne, mais le nom est un caractère plus long.
• $_ est l'argument de la fonction de niveau supérieur.
• [*-1] sélectionne le dernier élément de la liste générée.

QBIC , 34 octets

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

Explication

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

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

Essayez-le en ligne!

J, 26 octets

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

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

Essayez-le en ligne!

WendyScript , 42 octets

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

f(1024) // returns 377

Essayez-le en ligne!

Non golfé:

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

PHP, 41 octets

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

Essayez-le en ligne .

Java 8, 64 octets

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

Ou de légères alternatives avec le même nombre d'octets:

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

Explication:

Essayez-le ici.

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

Rubis , 39 octets

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

Essayez-le en ligne!

Rubis, 44 octets

Inspiré par la réponse JAVA de Kevin Cruijssen. -4 octets grâce à G B.

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

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

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

Essayez-le en ligne!