La gente sigue diciéndome que el cuadrado de un número es el número multiplicado por sí mismo. Esto es obviamente falso. La forma correcta de cuadrar un número es convertirlo en un cuadrado, apilándolo encima de sí mismo una cantidad de veces igual al número de dígitos que tiene, y luego leyendo todos los números del cuadrado resultante, ambos horizontalmente (de solo de izquierda a derecha) y verticalmente (solo de arriba a abajo), y luego sumarlos. Entonces, para el número 123, primero creas el cuadrado:

123
123
123

Luego, toma todas las filas y columnas del cuadrado y las agrega:

123+123+123+111+222+333

Lo que nos da un resultado de 1035.

Para los números negativos, usted apila normalmente (recuerde que solo cuenta el número de dígitos , por lo que el signo negativo no está incluido en la longitud), y luego lee los números horizontales normalmente (con signos negativos), y luego ignora los signos negativos para Los números verticales. Entonces, para el número -144obtenemos el cuadrado:

-144
-144
-144

Lo que nos da -144-144-144+111+444+444, lo que es igual567

Para números con solo un dígito, el cuadrado siempre es igual al número duplicado (leído una vez horizontalmente y una vez verticalmente). Entonces 4nos da

4

Lo que nos da 4+4, lo que es igual8 .

Para números con partes decimales, apile normalmente (recuerde que solo se cuentan los dígitos en la cantidad de veces que apila el número y, por lo tanto, no se cuenta el punto decimal), e ignore los símbolos decimales al leer los números verticales. Por ejemplo, el número 244.2nos da

244.2
244.2
244.2
244.2

Lo que nos da 244.2+244.2+244.2+244.2+2222+4444+4444+2222, lo que es igual14308.8 .

Los números fraccionales o complejos no pueden ser cuadrados.

Tu tarea:

Estoy cansado de cuadrar los números a mano, así que decidí automatizar el proceso. Escríbame un programa o función que tome un flotante o una cadena, lo que prefiera, como entrada y devuelva el resultado de cuadrarlo a mi manera.

Ejemplos:

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

Tanteo:

Mis manos se están apretando por escribir todos esos cuadrados, y mi computadora no admite copiar / pegar, por lo que gana la entrada con la menor cantidad de código para escribir (¿medido en bytes por alguna razón?).

05AB1E , 7 bytes

þSDg×+O

Pruébalo en línea!

Explicación

þ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

Jalea ,  13  12 bytes

fØDẋ€L$ŒV+VS

Un enlace monádico que acepta una lista de caracteres (un número decimal bien formado, el único cero inicial es un requisito para -1 <n <1 ) y devuelve un número.

Pruébalo en línea!

14 bytes para aceptar y números de retorno (entrada limitada a +/- 10 ^-5 por ŒṘ): ŒṘfØDẋ€L$ŒV+⁸S.

¿Cómo?

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 bytes

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

La entrada se toma como una cadena.

Pruébalo en línea!

Cómo funciona

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 bytes

o\d
l
¬xpV +V*Ng

¡Pruébelo en línea!

Explicación

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 Core), 150 141 133 bytes

Guardado 9 bytes gracias a @TheLethalCoder
Guardado otros 8 bytes gracias a @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;}

Pruébalo en línea!

Toma una cadena como entrada y genera el número 'cuadrado' como flotante.

Este código sigue el siguiente algoritmo:

1. Cree una nueva cadena a partir de la entrada, pero sin los puntos decimales y los símbolos, para que podamos obtener nuestra longitud y los números de las columnas desde allí.

2. Calcule la entrada multiplicada por la longitud de la cadena que creamos en el punto 1.

3. Para cada columna en nuestro 'cuadrado', cree una nueva cadena con el número de columna y la longitud de la fila y agréguela a nuestro resultado.

Ejemplo:

Entrada: -135.5

1. Si reemplazamos los puntos decimales y los símbolos, obtenemos la cadena 1355, que tiene una longitud de 4.
2. Los tiempos de entrada 4: -135.5 * 4 = -542.
3. Ahora vamos a crear nuevas cadenas para cada columna, analizarlos y añadirlos a nuestro resultado:
   1111, 3333, 5555, 5555.

Si sumamos estos números, obtenemos 15012, que es exactamente lo que generará nuestro programa.

Brachylog , 23 bytes

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

Pruébalo en línea!

Brachylog no va bien con carrozas ...

Explicación:

{∋ịṫ}ᶠ⟨≡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)

Casco , 15 bytes

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

Toma una cadena y devuelve un número. Pruébalo en línea!

Explicación

Es un poco molesto que la función de análisis incorporada rdé errores de análisis en las entradas no válidas en lugar de devolver un valor predeterminado, lo que significa que tengo que filtrar explícitamente las columnas que consisten en no dígitos. Si devuelve 0 en entradas mal formadas, podría soltar fΛ±y guardar 3 bytes.

§+ȯṁ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 bytes

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))

Test Suite .

Python 3 , 78 bytes

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

Banco de pruebas.

El segundo enfoque es un puerto para Python 3 inspirado en la solución de @ officialaimm.

Python 2 , 81 74 bytes

-7 bytes gracias a @Mr. Xcoder :'/'<i

• Toma entero o flotante, devuelve flotante.

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

Pruébalo en línea!

Explicación:

Say 123.45se da como entrada. [i for i in`x`if"/"<x]da una lista de enteros stringified ['1','2','3','4','5'](que también es z). Ahora iteramos , [x]+zes decir [123.45,'1','2','3','4','5'], multiplicamos cada elemento por len(z)aquí 5y los convertimos en un flotante (para que las cadenas también se conviertan en consecuencia), produciendo [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Finalmente calculamos sum(...)y obtenemos 167282.25.

JavaScript, 75 62 bytes

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

Pruébalo en línea

-2 bytes gracias a Arnauld
-5 bytes gracias a Shaggy (aunque la función debe recibir un número, pero ahora veo que muchas otras respuestas también reciben cadena)

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

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

Pruébalo en línea!

Usé algunos trucos del código de Dom para afeitar 4 bytes

Explicado:

@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

Jalea , 17 bytes

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

Pruébalo en línea!

Pyth, 18 bytes

s+RvQsM*RF_lB@jkUT

Pruébalo aquí.

Pyth , 21 20 bytes

K@jkUTQ+smv*lKdK*lKv

Banco de pruebas.

Utiliza un enfoque completamente diferente de la respuesta de @ EriktheOutgolfer , que me ayudó a jugar golf 1 byte en el chat, del 22 al 21.

Explicación

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ: filtra los dígitos y los asigna a una variable K.
         m - Mapa. Iterado a través de los dígitos con una variable d
           v - Evaluar (convertir a flotante).
            * lKd: multiplica cada dígito de cadena por la longitud de K.
        s - Suma
       + - Suma
                 * lKvQ: multiplica el número por la longitud de los dígitos Cadena

Octava , 100 82 bytes

¡Muchas gracias @TomCarpenter por enseñarme que las tareas tienen un valor de retorno y ahorrarme 18bytes!

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

Pruébalo en línea!

Ungolfed / Explicación

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 forma en que esto funciona es que, básicamente, necesitamos sumar el número ny multiplicar la suma de las columnas. Sumar s' * logspace(0,n-1,n)logra la suma de columnas, por ejemplo, si v=-123.4esa matriz será:

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

Así que solo tenemos que sumhacerlo y listo.

Swift 4 , 139134 bytes

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,+))}

Banco de pruebas.

Explicación

• func f(s:String)- Define una función fcon un parámetro de cadena explícito s.

• let k=s.filter{"/"<$0}- Filtros de los dígitos: Me di cuenta de que tanto -y .tienen valores ASCII más pequeños que todos los dígitos, y /está entre ., -y 0. Por lo tanto, acabo de comprobar si "/"es más pequeño que el carácter actual, como lo hice en mi respuesta de Python.

• print(...) - Imprime el resultado.

• Float(s)!*Float(k.count)- Convierte la cadena y el número de dígitos en flotante y los multiplica (Swift no permite la multiplicación de flotación e int :()). Entonces agrega el número de xveces, dondex está el número de dígitos que contiene?

• k.map{Int(String(repeating:$0,count:k.count))!- se k.map{}asigna kcon el valor actual $0. String(repeating:$0,count:k.count)toma cada dígito, crea una cadena de xdígitos idénticos y la Float(...)!convierte en un número de coma flotante.

• .reduce(0,+) - Obtiene la suma de la lista anterior.

• Y finalmente +suma los dos resultados.

¡Tomemos un ejemplo!

Digamos que nuestra cadena es "0.45". En primer lugar, filtramos los dígitos, por lo que nos queda 0, 4, 5. Convertimos "0.45"a flotar y se multiplica por el número de dígitos: 0.45 * 3 = 1.35. Luego tomamos cada dígito y convertirlo en una cadena de dígitos que repetir hasta que se llene la anchura de la plaza (cuántos dígitos hay): 0, 4, 5 -> 000, 444, 555. Sumamos esto, 000 + 444 + 555 = 999. Entonces sólo sumar los tiempos: 1.35 + 999 = 1000.35.

C #, 139 137 bytes

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

Guardado 2 bytes gracias a @Ian H.

Pruébalo en línea!

Versión completa / formateada:

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 bytes

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

PHP, 78 88 +1 bytes

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

Ejecutar como tubería con -nR.

Puede generar advertencias en PHP 7.1. Reparar $c,$econ $c>0?$c:0,$epara arreglar.

Python 3 , 68 70 73 77 bytes

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

Pruébalo en línea!

Recorre cada carácter de dígitos y lo repite por el número total de caracteres de dígitos, lo convierte en un número entero y lo agrega a n. De esta forma se nobtienen dtiempos adicionales , la parte horizontal de la suma, junto con la repetición de dígitos, que es la parte vertical. Originalmente utilizado str.isdigitpero >"/", gracias a otros en este hilo, ahorró muchos bytes. Guarda dos bytes al tomarlos ncomo una cadena, pero el resultado es más desordenado.

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

Pruébalo en línea!