Écrire des nombres fait partie des mondes Hello de la programmation, souvent des nombres de 1 à 10.

Je veux écrire beaucoup de chiffres! Beaucoup, beaucoup de nombres. Mais combien de nombres dois-je écrire?

Tâche

Pour une entrée entière, donnez un nombre en sortie qui me donnerait le nombre de chiffres qui seraient dans une chaîne contenant tous les nombres entiers compris entre 0 et l'entrée, inclus. L'identifiant de négation ("-") compte pour un seul caractère.

Exemple d'E / S

Entrée: 8
Écrit: 0,1,2,3,4,5,6,7,8
Sortie: 9

Entrée: 101
écrit: 0,1,2,3 ...., 99,100,101
Sortie: 196

Entrée: 102
écrit: 0,1,2,3 ...., 100,101,102
sortie: 199

Entrée -10
Sortie écrite: 0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10
sortie: 22

Ceci est un code-golf . Le plus petit nombre d'octets gagne!

05AB1E , 3 octets

Code:

ÝJg

Utilise le codage CP-1252 . Essayez-le en ligne!

Explication:

Ý     # Range [0 .. input]
 J    # Join into one string
  g   # Get the length of the string

Python 2 , 55 46 octets

lambda n:len(`range(abs(n)+1)`)+2*~n+3*n*(n<0)

Essayez-le en ligne!

Aller mieux.

Röda , 23 octets

f x{[#([seq(0,x)]&"")]}

Essayez-le en ligne!

A expliqué:

f x{[#([seq(0,x)]&"")]}
f x{                  } /* Defines function f with parameter x. */
        seq(0,x)        /* Creates a stream of numbers from 0 to x. */
       [        ]       /* Creates an array. */
                 &""    /* Joins with "". */
     #(             )   /* Calculates the length of the resulting string. */
    [                ]  /* Returns the value. */

Python 2 , 41 octets

f=lambda n:len(`n`)+(n and f(n+cmp(0,n)))

Essayez-le en ligne!

Utilitaires Bash + OS X (BSD), 24 22 octets

Merci à @seshoumara pour la sauvegarde de 2 octets.

seq 0 $1|fold -1|wc -l

Le test fonctionne sous Mac OS X:

$ for n in 8 101 102 -10 -1 0 1; do printf %6d $n; ./digitcount $n; done
     8       9
   101     196
   102     199
   -10      22
    -1       3
     0       1
     1       2

Voici une version GNU:

Bash + coreutils, 40 38 octets

Encore une fois, 2 octets sauvés grâce à @seshoumara.

(seq $1 0;seq 0 $1)|uniq|fold -1|wc -l

Essayez-le en ligne!

Python 2, 83 , 78 64 octets

version la plus courte:

lambda x:sum(map(len,map(str,(range(0,x+cmp(x,.5),cmp(x,.5))))))

cette version a économisé 5 octets, grâce à @numbermaniac:

x=input()
print len(''.join(map(str,(range(x+1)if x>0 else range(0,x-1,-1)))))

Essayez-le en ligne!

celui-ci je suis venu seul avec cela après (même nombre d'octets):

x=input()
print sum(map(len,map(str,(range(x+1)if x>0 else range(0,x-1,-1)))))

Essayez-le en ligne!

Java 7, 74 octets _{(récursif - comprenant le deuxième paramètre par défaut)}

int c(int r,int n){r+=(n+"").length();return n>0?c(r,n-1):n<0?c(r,n+1):r;}

Explication (1):

int c(int r, int n){     // Recursive method with two integer parameters and integer return-type
                         // Parameter `r` is the previous result of this recursive method (starting at 0)
  r += (n+"").length();  //  Append the result with the current number's width
  return n > 0 ?         //  If the input is positive
     c(r, n-1)           //   Continue recursive method with n-1
    : n < 0 ?            //  Else if the input is negative
     c(r, n+1)           //   Continue recursive method with n+1
    ?                    //  Else (input is zero)
     r;                  //   Return the result
}                        // End of method

Java 7, 81 79 octets _{(boucle - paramètre unique)}

Si avoir un second paramètre par défaut 0pour cette approche récursive n'est pas autorisé pour une raison quelconque, une boucle for telle que celle-ci pourrait être utilisée à la place:

int d(int n){String r="x";for(int i=n;i!=0;i+=n<0?1:-1)r+=i;return r.length();}

Explication (2)

int d(int n){                 // Method with integer parameter and integer return-type
  String r = "x";             //  Initial String (with length 1 so we won't have to +1 in the end)
  for(int i=n; i != 0;        //  Loop as long as the current number isn't 0
      i += n < 0 ? 1 : 1)     //   After every iteration of the loop: go to next number
    r += i;                   //   Append String with current number
                              //  End of loop (implicit / single-line body)
  return r.length();          //  Return the length of the String
}                             // End of method

Code de test:

Essayez ici.

class M{
  static int c(int r,int n){r+=(n+"").length();return n>0?c(r,n-1):n<0?c(r,n+1):r;}

  static int d(int n){String r="x";for(int i=n;i!=0;i+=n<0?1:-1)r+=i;return r.length();}

  public static void main(String[] a){
    System.out.println(c(0, 8) + "\t" + d(8));
    System.out.println(c(0, 101) + "\t" + d(101));
    System.out.println(c(0, 102) + "\t" + d(102));
    System.out.println(c(0, -10) + "\t" + d(-10));
  }
}

Sortie:

9   9
196 196
199 199
22  22

RProgN 2 , 5 octets

n0R.L

Explication

n0R   # A Stack of all numbers between 0 and the input converted to a number.
   .L # The length of the stringification of this.

Solution simple, fonctionne comme un charme.

Essayez-le en ligne!

Brachylog , 5 octets

⟦ṡᵐcl

Essayez-le en ligne!

Construit la plage [0, entrée], convertit chaque nombre en chaîne, se concatène en une seule chaîne et renvoie la longueur du résultat

PHP, 59 60 octets

Outgolfé par Roberto06 - https://codegolf.stackexchange.com/a/112536/38505

Merci à roberto06 pour avoir remarqué que la version précédente ne fonctionnait pas pour les nombres négatifs.

Construit simplement un tableau de nombres, le met dans une chaîne, puis compte les chiffres (et le signe moins)

<?=preg_match_all("/\-|\d/",implode(",",range(0,$argv[1])));

Exemple d'exécution: php -f 112504.php 8

• 8 cas de test
• 101 cas de test
• 102 cas de test
• -10 cas de test

Haskell , 39 38 octets

f 0=1
f n=length$show=<<[0..n]++[n..0]

Essayez-le en ligne! Edit: sauvegardé 1 octet grâce à @xnor!

Explication:

En Haskell pour les nombres a, b [a..b]la plage va de aà ben incréments de 1 ou en incréments de 1, selon qu’elle best plus grande a. Donc, pour un résultat positif, nla première liste [0..n]++[n..0]est [0,1,2,...,n]et la seconde est vide. Pour négatif, nla deuxième plage donne [0,-1,-2,...,n]et la première est vide. Toutefois, si les n=0deux plages renvoient la liste [0], la concaténation [0,0]donnerait un résultat faux 2. C'est pourquoi 0est traité comme un cas particulier.

L' =<<opérateur sur une liste est identique à concatMap, de sorte que chaque nombre est converti en chaîne par showet que toutes ces chaînes sont concaténées dans une chaîne longue dont elles lengthsont finalement renvoyées.

Avant le conseil de xnor, je l’utilisais à la [0,signum n..n]place [0..n]++[n..0]. signum nest -1pour les nombres négatifs, 0pour zéro et 1pour les nombres positifs et une plage de la forme [a,b..c]construit la liste des nombres de aà cavec incrémentation b. Construit ainsi [0,signum n..n]la gamme [0,1,2,...,n]pour le positif net [0,-1,-2,...,n]pour le négatif n. Car n=0cela construirait la liste infinie [0,0,0,...], nous avons donc besoin de le gérer 0comme un cas spécial.

PHP, 41 35 octets

6 octets sauvegardés grâce à user59178

Comme la réponse de ʰᵈ était fausse pour une entrée négative, j'ai pris sur moi de construire une nouvelle solution:

<?=strlen(join(range(0,$argv[1])));

Cette fonction:

• Construit un tableau de 0à $argv[1](alias l'entrée)
• Implose-la avec un caractère vide (c'est-à-dire la transforme en chaîne)
• Écho la longueur de la chaîne

Essayez-le ici!

Ruby , 20 26 29 octets

->x{[*x..-1,0,*1..x]*''=~/$/}

Essayez-le en ligne!

R, 26 à 20 octets

sum(nchar(0:scan()))

Approche très basique:

• Faire un vecteur 0: x

• Compter les caractères dans chaque valeur (sera forcé à une chaîne automatiquement)

• Somme

Vous ne savez pas s'il existe des astuces pour réduire la définition de la fonction? 6 octets sauvés grâce à Giuseppe, en prenant les entrées de stdin à la place.

Mathematica, 48 47 46 octets

-1 octet grâce à Martin Ender !

StringLength[""<>ToString/@Range[0,#,Sign@#]]&

Fonction anonyme, prenant le nombre comme argument.

Solution plus courte de Greg Martin , 39 octets

1-#~Min~0+Tr@IntegerLength@Range@Abs@#&

Lot, 110 octets

@set/a"n=%1,t=n>>31,n*=t|1,t=1-t*n,i=0
@for /l %%i in (0,1,9)do @set/a"t+=(i-n)*(i-n>>31),i=i*10+9
@echo %t%

Calculs sum(min(0,abs(n)+1-10^k),k=0..9)+(n<0?1-n:1). (Je n'ai qu'à y aller en 9raison des limitations de l'arithmétique entière de Batch.)

Python 2 , 68 octets

def f(i,j=1):
 if i==0:print j
 else:j+=len(`i`);f((i-1,i+1)[i<0],j)

Essayez-le en ligne!

Plus long que mais différent des autres solutions Python. Définit une fonction récursive appelée par exemplef(10)

MATL , 11 octets

0hSZ}&:VXzn

Essayez-le en ligne!

0h           % Implicitly input n. Append a 0: gives array [n 0]
  S          % Sort
   Z}        % Split array: pushes 0, n or n, 0 according to the previous sorting
     &:      % Binary range: from 0 to n or from n to 0
       V     % Convert to string. Inserts spaces between numbers
        Xz   % Remove spaces
          n  % Length of string. Implicit display

PowerShell , 23 octets

-join(0.."$args")|% Le*

Essayez-le en ligne! (sera sur TIO pour les très grandes entrées (absolues))

Utilise l' ..opérateur de plage pour construire une plage allant de 0à l'entrée $args(convertie en chaîne à convertir à partir du tableau d'entrée). C'est -joinédité ensemble dans une chaîne (par exemple, 01234) et ensuite le Length en est pris. Cela reste sur le pipeline et la sortie est implicite.

Perl 6 , 18 octets

{chars [~] 0...$_}

L'essayer

Étendu:

{  # bare block lambda with implicit parameter ｢$_｣

  chars        # how many characters (digits + '-')
    [~]        # reduce using string concatenation operator &infix:<~>
      0 ... $_ # deductive sequence from 0 to the input
}

QBIC , 25 octets

:[0,a,sgn(a)|A=A+!b$]?_lA

Explication:

:[0,a     Read 'a' from the cmd line, start a FOR loop from 0 to 'a'
,sgn(a)|  with incrementer set to -1 for negative ranges and 1 for positive ones
A=A+!b$   Add a string cast of each iteration (var 'b') to A$
]         NEXT
?_lA      Print the length of A$

JavaScript, 50 octets

Collaboré avec @ETHproductions

n=>{for(t="";n;n<0?n++:n--)t+=n;alert(++t.length)}

Bash + GNU coreutils, 28

eval printf %s {0..$1}|wc -c

Essayez-le en ligne .

Retina , 28 octets

\d+
$*
1
$`1¶
1+
$.&
^-?
0
.

Essayez-le en ligne!

Explication

\d+
$*

Convertissez le nombre en unaire, en gardant le signe intact.

1
$`1¶

Chaque 1 est remplacé par tout jusqu'à lui-même, plus une nouvelle ligne. Avec cela, nous obtenons une plage de 1 à n si n était positif, de -1 à n avec une valeur supplémentaire -au début si elle était négative. Tous les nombres sont en unaire et séparés par des nouvelles lignes.

1+
$.&

Convertissez chaque séquence de uns en nombre décimal correspondant.

^-?
0

Mettez un 0au début, remplacez le plus -si c'est là.

.

Comptez le nombre de caractères (non-newline).

Emacs, 20 octets

C-x ( C-x C-k TAB C-x ) M-{input} C-x e C-x h M-=

La commande elle-même est composée de 20 frappes de touche, mais il me faut des éclaircissements sur la manière dont cela doit être compté en octets. Je pensais que compter chaque frappe de touche comme un octet serait le plus juste. La commande ci-dessus est écrite de manière conventionnelle pour en faciliter la lecture.

Explication

C-x (

Commencez à définir une macro de clavier.

C-x C-k TAB

Créez un nouveau compteur de macros. Écrit 0dans le tampon; la valeur du compteur est maintenant 1.

C-x )

Terminez la définition de la macro du clavier.

M-{input} C-x e

Après avoir appuyé sur META, tapez votre numéro d'entrée. Le C-x epuis exécute la macro que plusieurs fois.

C-x h

Définit mark en début de tampon (qui sélectionne tout le texte ainsi généré).

M-=

Exécuter le nombre de caractères sur la région sélectionnée. Le nombre de caractères sera imprimé dans le mini-tampon.

Exemple

Toutes mes excuses pour la terrible couleur de surbrillance. Voici un exemple d'utilisation de cette commande avec l'entrée 100. La sortie se trouve dans le mini-tampon en bas de l'écran.

Lua, 52 octets

t=0;for i=0,io.read()do t=t+#tostring(i)end;print(t)

Itère dans une boucle for de 0 - entrée, convertit l'entier ien chaîne et ajoute la longueur de la chaîne tavant l'impressiont

Perl 5 , 32 octets

31 octets de code + -pdrapeau.

$\+=y///c for$_>0?0..$_:$_..0}{

Essayez-le en ligne!

C #, 77 73 octets

-4 octets grâce à @ Kevin Cruijssen

Fonction lambda:

(r)=>{var l="";for(int i=0,s=r<0?-1:1;i!=r+s;i+=s)l+=i;return l.Length;};

Ungolfed et avec des cas de test:

class P
{
    delegate int numbers(int e);
    static void Main()
    {
        numbers n = (r) =>
        {
            var l = ""; 
            for (int i = 0, s = r < 0 ? -1 : 1; i != r + s; i += s)
                l += i; 
            return l.Length;
        };
        System.Console.WriteLine(n(8));
        System.Console.WriteLine(n(101));
        System.Console.WriteLine(n(102));
        System.Console.WriteLine(n(-10));
        System.Console.ReadKey();
    }
}

JavaScript, 44 octets

f=(n,i=1)=>n<0?f(-n)-n:n<i?1:n+1-i+f(n,i*10)

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

REXX, 56 octets

arg n
l=0
do i=0 to n by sign(n)
  l=l+length(i)
  end
say l