Les gens me disent que le carré d'un nombre est le nombre multiplié par lui-même. C'est évidemment faux. La bonne façon de mettre un nombre au carré est d'en faire un carré, en l'empilant au-dessus de lui-même un nombre de fois égal au nombre de chiffres qu'il a, puis en lisant tous les nombres du carré résultant, tous les deux horizontalement (à partir de de gauche à droite uniquement) et verticalement (de haut en bas uniquement), puis en les ajoutant ensemble. Donc, pour le nombre 123, vous créez d'abord le carré:

123
123
123

Ensuite, vous prenez toutes les lignes et colonnes du carré et les ajoutez ensemble:

123+123+123+111+222+333

Ce qui nous donne un résultat de 1035.

Pour les nombres négatifs, vous empilez normalement (n'oubliez pas que vous ne comptez que le nombre de chiffres , donc le signe négatif n'est pas inclus dans la longueur), puis lisez les nombres horizontaux normalement (avec des signes négatifs), puis ignorez les signes négatifs pour les nombres verticaux. Donc, pour le nombre, -144nous obtenons le carré:

-144
-144
-144

Ce qui nous donne -144-144-144+111+444+444, ce qui équivaut567

Pour les nombres à un seul chiffre, le carré est toujours égal au nombre doublé (lu une fois horizontalement et une fois verticalement). Nous 4donne donc

4

Ce qui nous donne 4+4, ce qui est égal 8.

Pour les nombres avec des parties décimales, empilez normalement (rappelez-vous que seuls les chiffres sont comptés dans le nombre de fois que vous empilez le nombre, et donc le point décimal n'est pas compté), et ignorez les symboles décimaux lors de la lecture des nombres verticaux. Par exemple, le nombre 244.2nous donne

244.2
244.2
244.2
244.2

Ce qui nous donne 244.2+244.2+244.2+244.2+2222+4444+4444+2222, ce qui est égal 14308.8.

Les nombres fractionnaires ou complexes ne peuvent pas être mis au carré.

Ta tâche:

Je suis fatigué de quadriller les chiffres à la main, j'ai donc décidé d'automatiser le processus. Écrivez-moi un programme ou une fonction qui prend un flottant ou une chaîne, selon votre préférence, en entrée et renvoie le résultat de la mise au carré à ma façon.

Exemples:

123    -> 1035
388    -> 3273
9999   -> 79992
0      -> 0
8      -> 16
-6     -> 0
-25    -> 27
-144   -> 567
123.45 -> 167282.25
244.2  -> 14308.8
2      -> 4
-0.45  -> 997.65
0.45   -> 1000.35

Notation:

Mes mains sont à l'étroit en écrivant tous ces carrés, et mon ordinateur ne prend pas en charge le copier / coller, donc l'entrée avec le moins de code pour moi à taper (mesurée en octets pour une raison quelconque?) Gagne!

05AB1E , 7 octets

þSDg×+O

Essayez-le en ligne!

Explication

þSDg×+O Implicit input
þ       Keep digits
 S      Get chars
  D     Duplicate
   g    Length
    ×   Repeat string(s)
     +  Add (implicit input added to all elements)
      O Sum

Gelée ,  13  12 octets

fØDẋ€L$ŒV+VS

Un lien monadique acceptant une liste de caractères (un nombre décimal bien formé, le zéro de tête unique étant une exigence pour -1 <n <1 ) et renvoyant un nombre.

Essayez-le en ligne!

14 octets d'accepter et de numéros de rappel (entrée limitée à +/- 10 ^-5 par ŒṘ): ŒṘfØDẋ€L$ŒV+⁸S.

Comment?

fØDẋ€L$ŒV+VS - Link: list of characters         e.g. "-0.45"
 ØD          - yield digit characters                "0123456789"
f            - filter keep                           "045"
      $      - last two links as a monad:
     L       -   length (number of digit characters) 3
   ẋ€        -   repeat list for €ach digit          ["000","444","555"]
       ŒV    - evaluate as Python code (vectorises)  [0,444,555]
          V  - evaluate (the input) as Jelly code    -0.45
         +   - addition (vectorises)                 [-0.45,443.55,554.55]
           S - sum                                   997.65

Haskell, 59 56 octets

f s|l<-filter(>'.')s=0.0+sum(read<$>(s<$l)++[c<$l|c<-l])

L'entrée est considérée comme une chaîne.

Essayez-le en ligne!

Comment ça marche

l<-filter(>'.')s      -- let l be the string of all the numbers of the input string
f s   = 0.0 + sum     -- the result is the sum of (add 0.0 to fix the type to float)
   read<$>            -- turn every string of the following list into a number
   s<$l               -- length of l times the input string followed by
   [c<$l|c<-l]        -- length of l times c for each c in l   

Japt v2 , 16 octets

o\d
l
¬xpV +V*Ng

Testez-le en ligne!

Explication

o\d    First line: Set U to the result.
o      Keep only the chars in the input that are
 \d      digits. (literally /\d/g)

l    Second line: Set V to the result.
l    U.length

¬xpV +V*Ng    Last line: implicitly output the result.
¬             Split U into chars.
 x            Sum after
  pV            repeating each V times.
     +V*Ng    Add V * first input (the sum of the horizontals) to the result.

C # (.NET de base), 150 141 133 octets

9 octets enregistrés grâce à @TheLethalCoder 8 octets supplémentaires
enregistrés grâce à @TheLethalCoder

a=>{var c=(a+"").Replace(".","").Replace("-","");int i=0,l=c.Length;var r=a*l;for(;i<l;)r+=int.Parse(new string(c[i++],l));return r;}

Essayez-le en ligne!

Prend une chaîne en entrée et sort le nombre «carré» sous forme de flottant.

Ce code suit l'algorithme suivant:

1. Créez une nouvelle chaîne à partir de l'entrée, mais sans les décimales et les symboles, afin que nous puissions obtenir notre longueur et les nombres pour les colonnes à partir de là.

2. Calculez les entrées fois la longueur de la chaîne que nous avons créée au point 1.

3. Pour chaque colonne de notre «carré», créez une nouvelle chaîne avec le numéro de colonne et la longueur de la ligne et ajoutez-la à notre résultat.

Exemple:

Contribution: -135.5

1. Si nous remplaçons les décimales et les symboles, nous obtenons la chaîne 1355, qui a une longueur de 4.
2. Les temps d'entrée 4: -135.5 * 4 = -542.
3. Maintenant , nous créons de nouvelles chaînes pour chaque colonne, les analyser et de les ajouter à notre résultat:
   1111, 3333, 5555, 5555.

Si nous résumons ces chiffres, nous obtenons 15012, ce qui est exactement ce que notre programme affichera.

Brachylog , 23 octets

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+

Essayez-le en ligne!

Brachylog ne va pas bien avec les flotteurs ...

Explication:

{∋ịṫ}ᶠ⟨≡zl⟩j₎ᵐ;[?]zcịᵐ+ Takes string (quoted) input, with '-' for the negative sign
     ᶠ                  Return all outputs (digit filter)
{   }                    Predicate (is digit?)
 ∋                        An element of ? (input)
  ị                       Convert to number (fails if '-' or '.')
   ṫ                      Convert back to string (needed later on)
      ⟨   ⟩             Fork
       ≡                 Identity
         l               Length
                        with
        z                Zip
             ᵐ          Map
            ₎            Subscript (optional argument)
           j              Juxtapose (repeat) (this is where we need strings)
              ;         Pair with literal
               [ ]       List
                ?         ?
                  z     Zip
                   c    Concatenate (concatenate elements)
                     ᵐ  Map
                    ị    Convert to number
                      + Add (sum elements)

Husk , 15 octets

§+ȯṁrfΛ±TṁrSR#±

Prend une chaîne et renvoie un nombre. Essayez-le en ligne!

Explication

C'est un peu ennuyeux que la fonction d'analyse intégrée rdonne des erreurs d'analyse sur les entrées non valides au lieu de renvoyer une valeur par défaut, ce qui signifie que je dois filtrer explicitement les colonnes qui sont constituées de non-chiffres. S'il renvoyait 0 sur des entrées mal formées, je pourrais laisser tomber fΛ±et enregistrer 3 octets.

§+ȯṁrfΛ±TṁrSR#±  Implicit input, e.g. "-23"
             #±  Count of digits: 2
           SR    Repeat that many times: ["-23","-23"]
         ṁr      Read each row (parse as number) and take sum of results: -46
  ȯṁrfΛ±T        This part is also applied to the result of SR.
        T        Transpose: ["--","22","33"]
     fΛ±         Keep the rows that contain only digits: ["22","33"]
   ṁr            Parse each row as number and take sum: 55
§+               Add the two sums: 9

Python 3 , 95 94 87 85 84 octets

def f(i):l=[x for x in i if"/"<x];k=len(l);print(k*float(i)+sum(int(x*k)for x in l))

Suite de test .

Python 3 , 78 octets

lambda x:sum(float(i*len(z))for z in[[i for i in str(x)if"/"<i]]for i in[x]+z)

Suite de tests.

La deuxième approche est un portage vers Python 3 inspiré par la solution de @ officialaimm.

Python 2 , 81 74 octets

-7 octets grâce à @Mr. Xcoder :'/'<i

• Prend entier ou float, retourne float.

lambda x:sum(float(i*len(z))for z in[[i for i in`x`if"/"<i]]for i in[x]+z)

Essayez-le en ligne!

Explication:

Say 123.45est donné en entrée. [i for i in`x`if"/"<x]donne une liste d'entiers stringifiés ['1','2','3','4','5'](qui l'est aussi z). Maintenant, nous itérons à travers, [x]+zc'est- à- dire [123.45,'1','2','3','4','5']en multipliant chaque élément par len(z), ici 5et en convertissant chacun en un flottant (de sorte que les chaînes se convertissent également en conséquence), ce qui donne [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Enfin, nous calculons le sum(...)et obtenons 167282.25.

JavaScript, 75 62 octets

a=>(b=a.match(/\d/g)).map(b=>a+=+b.repeat(c),a*=c=b.length)&&a

Essayez-le en ligne

-2 octets grâce à Arnauld
-5 octets grâce à Shaggy (je pensais que la fonction devait recevoir un nombre, mais maintenant je vois que beaucoup d'autres réponses reçoivent aussi une chaîne)

Perl 5 , 37 33 + 1 (-p) = 38 34 octets

$_*=@n=/\d/g;for$\(@n){$_+=$\x@n}

Essayez-le en ligne!

Utilisé quelques astuces du code de Dom pour raser 4 octets

A expliqué:

@n=/\d/g;    # extract digits from input
$_*=@n;      # multiply input by number of digits
for$\(@n){   # for each digit:
  $_+=       # add to the input
  $\x@n}     # this digit, repeated as many times as there were digits
             # taking advantage of Perl's ability to switch between strings
             # and numbers at any point

Gelée , 17 octets

ŒṘfØDẋ€L©$ŒV;ẋ®$S

Essayez-le en ligne!

Pyth, 18 octets

s+RvQsM*RF_lB@jkUT

Essayez ici.

Pyth , 21 20 octets

K@jkUTQ+smv*lKdK*lKv

Suite de tests.

Utilise une approche complètement différente de la réponse de @ EriktheOutgolfer , qui m'a aidé à jouer au golf 1 octet dans le chat, de 22 à 21.

Explication

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - Filtre les chiffres et les affecte à une variable K.
         m - Carte. Itéré à travers les chiffres avec une variable d
           v - Évaluer (convertir en float).
            * lKd - Multiplie chaque chiffre de chaîne par la longueur de K.
        s - Somme
       + - Somme
                 * lKvQ - Multipie le nombre par la longueur des chiffres Chaîne

Octave , 100 82 octets

Merci beaucoup @TomCarpenter de m'avoir appris que les affectations ont une valeur de retour et de m'avoir sauvé des 18octets!

@(v)(n=nnz(s=strrep(num2str(abs(v)),'.','')-'0'))*v+sum(sum(s'*logspace(0,n-1,n)))

Essayez-le en ligne!

Non golfé / Explication

function f=g(v)
  s=strrep(num2str(abs(v)),'.','')-'0';  % number to vector of digits (ignore . and -)
  n=nnz(s);                              % length of that vector
  f=n*v+sum(sum(s'*logspace(0,n-1,n)))   % add the number n times and sum the columns of the square
end

La façon dont cela fonctionne est que nous devons essentiellement ajouter le nombre lui-même nfois, puis ajouter la somme des colonnes. La sommation s' * logspace(0,n-1,n)atteint la somme des colonnes, par exemple si v=-123.4cette matrice sera:

[ 1     10    100   1000;
  2     20    200   2000;
  3     30    300   3000;
  4     40    400   4000 ]

Nous avons donc juste besoin de sumle faire et nous avons terminé.

Swift 4 , 139 134 octets

func f(s:String){let k=s.filter{"/"<$0};print(Float(s)!*Float(k.count)+k.map{Float(String(repeating:$0,count:k.count))!}.reduce(0,+))}

Suite de tests.

Explication

• func f(s:String)- Définit une fonction favec un paramètre String explicite s.

• let k=s.filter{"/"<$0}- Filtre les chiffres: j'ai remarqué que les deux -et .ont des valeurs ASCII plus petites que tous les chiffres, et /est entre ., -et 0. Par conséquent, je viens de vérifier s'il "/"est plus petit que le caractère actuel, comme je l'ai fait dans ma réponse Python.

• print(...) - Imprime le résultat.

• Float(s)!*Float(k.count)- Convertit à la fois la chaîne et le nombre de chiffres en Float et les multiplie (Swift ne permet pas la multiplication Float et Int :()). Il ajoute donc le nombre de xfois, oùx est le nombre de chiffres qu'il contient.

• k.map{Int(String(repeating:$0,count:k.count))! - k.map{} correspond kà la valeur actuelle $0. String(repeating:$0,count:k.count)prend chaque chiffre, crée une chaîne de xchiffres identiques et le Float(...)!convertit en nombre à virgule flottante.

• .reduce(0,+) - Obtient la somme de la liste ci-dessus.

• Et +résume enfin les deux résultats.

Prenons un exemple!

Disons que notre chaîne est "0.45". Tout d'abord, nous filtrons les chiffres, nous nous retrouvons donc avec 0, 4, 5. Nous convertissons "0.45"à flotteur et multiplier par le nombre de chiffres: 0.45 * 3 = 1.35. Ensuite , nous prenons chaque chiffre et la transformer en une chaîne à répéter ce chiffre jusqu'à ce qu'il remplisse la largeur du carré (combien de chiffres il y a): 0, 4, 5 -> 000, 444, 555. Nous résumons cela, 000 + 444 + 555 = 999. Ensuite , nous ajoutons simplement les résultats ensemble: 1.35 + 999 = 1000.35.

C #, 139 137 octets

using System.Linq;n=>{var d=(n+"").Where(char.IsDigit);return d.Sum(i=>int.Parse(new string(i,d.Count())))+new int[d.Count()].Sum(_=>n);}

Enregistré 2 octets grâce à @Ian H.

Essayez-le en ligne!

Version complète / formatée:

namespace System.Linq
{
    class P
    {
        static void Main()
        {
            Func<double, double> f = n =>
            {
                var d = (n + "").Where(char.IsDigit);
                return d.Sum(i => int.Parse(new string(i, d.Count()))) + new int[d.Count()].Sum(_ => n);
            };

            Console.WriteLine(f(123));
            Console.WriteLine(f(-144));
            Console.WriteLine(f(4));
            Console.WriteLine(f(244.2));

            Console.ReadLine();
        }
    }
}

Mathematica, 107 octets

(t=Length[s=#&@@RealDigits[#]//.{a___, 0}:>{a}];If[IntegerPart@#==0,t++];t#+Tr[FromDigits@Table[#,t]&/@s])&

PHP, 78 88 +1 octets

for($e=preg_match_all("#\d#",$n=$argn);~$c=$n[$i++];)$s+=str_repeat($c,$e);echo$s+$n*$e;

Exécuter en tant que tuyau avec -nR.

Peut générer des avertissements en PHP 7.1. Répétez $c,$eavec $c>0?$c:0,$epour corriger.

Python 3 , 68 70 73 77 octets

lambda n:sum(float(n)+int(_*sum(x>"/"for x in n))for _ in n if"/"<_)

Essayez-le en ligne!

Boucle sur chaque caractère numérique et le répète par le nombre total de caractères numériques, en fait un entier et ajoute cela à n. De cette façon, on nobtient des dtemps ajoutés , la partie horizontale de la somme, ainsi que la répétition des chiffres, qui est la partie verticale. Utilisé à l'origine str.isdigitmais >"/", grâce à d'autres dans ce fil, a économisé beaucoup d'octets. Enregistre deux octets en prenant ncomme chaîne, mais la sortie est plus compliquée.

lambda n:sum(n+int(_*sum(x>"/"for x in str(n)))for _ in str(n)if"/"<_)

Essayez-le en ligne!