As pessoas continuam me dizendo que o quadrado de um número é o número multiplicado por ele mesmo. Isto é obviamente falso. A maneira correta de colocar um número ao quadrado é transformá-lo em um quadrado, empilhando-o em cima de si várias vezes igual ao número de dígitos que possui e, em seguida, lendo todos os números do quadrado resultante, ambos horizontalmente (de somente da esquerda para a direita) e verticalmente (somente de cima para baixo) e, em seguida, adicionando-os. Portanto, para o número 123, você primeiro cria o quadrado:

123
123
123

Em seguida, você pega todas as linhas e colunas do quadrado e as adiciona:

123+123+123+111+222+333

O que nos dá um resultado de 1035.

Para números negativos, você empilha normalmente (lembre-se de contar apenas o número de dígitos , para que o sinal negativo não seja incluído no comprimento) e, em seguida, leia os números horizontais normalmente (com sinais negativos) e ignore os sinais negativos para os números verticais. Então, para o número -144, obtemos o quadrado:

-144
-144
-144

O que nos dá -144-144-144+111+444+444, que é igual a567

Para números com apenas um dígito, o quadrado é sempre igual ao número dobrado (leia uma vez na horizontal e outra na vertical). Então 4nos dá

4

O que nos dá 4+4, o que é igual 8.

Para números com partes decimais, empilhe normalmente (lembre-se de que apenas os dígitos são contados no número de vezes que você empilha o número e, portanto, o ponto decimal não é contado) e ignore os símbolos decimais ao ler os números verticais. Por exemplo, o número 244.2nos dá

244.2
244.2
244.2
244.2

O que nos dá 244.2+244.2+244.2+244.2+2222+4444+4444+2222, o que é igual 14308.8.

Números fracionários ou complexos não podem ser elevados ao quadrado.

Sua tarefa:

Estou cansado de quadrilhar números do meu jeito com a mão, então decidi automatizar o processo. Escreva-me um programa ou função que pegue um float ou string, conforme sua preferência, como entrada e retorne o resultado de quadrá-lo do meu jeito.

Exemplos:

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

Pontuação:

Minhas mãos estão ficando apertadas de escrever todos esses quadrados, e meu computador não suporta copiar / colar, então a entrada com a menor quantidade de código para eu digitar (medida em bytes por algum motivo?) Vence!

05AB1E , 7 bytes

þSDg×+O

Experimente online!

Explicação

þ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éia ,  13  12 bytes

fØDẋ€L$ŒV+VS

Um link monádico que aceita uma lista de caracteres (um número decimal bem formado, sendo o zero inicial simples um requisito para -1 <n <1 ) e retornando um número.

Experimente online!

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

Quão?

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

A entrada é tomada como uma sequência.

Experimente online!

Como 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   

Japonês v2 , 16 bytes

o\d
l
¬xpV +V*Ng

Teste online!

Explicação

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

Guardou 9 bytes graças a @TheLethalCoder Guardou
outros 8 bytes graças 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;}

Experimente online!

Pega uma string como uma entrada e gera o número do quadrado como um flutuador.

Este código segue o seguinte algoritmo:

1. Crie uma nova string a partir da entrada, mas sem os pontos decimais e símbolos, para que possamos obter nosso comprimento e os números das colunas a partir daí.

2. Calcule os tempos de entrada do comprimento da string que criamos no ponto 1.

3. Para cada coluna em nosso 'quadrado', crie uma nova string com o número da coluna e o comprimento da linha e adicione-a ao nosso resultado.

Exemplo:

Entrada: -135.5

1. Se substituirmos pontos decimais e símbolos, obtemos a string 1355, que tem um comprimento de 4.
2. Os tempos de entrada 4: -135.5 * 4 = -542.
3. Agora vamos criar novas cordas para cada coluna, analisá-los e adicioná-los ao nosso resultado:
   1111, 3333, 5555, 5555.

Se somarmos esses números, obteremos 15012exatamente o que nosso programa produzirá.

Braquilog , 23 bytes

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

Experimente online!

Brachylog não combina bem com carros alegóricos ...

Explicação:

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

Casca , 15 bytes

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

Pega uma string e retorna um número. Experimente online!

Explicação

É um pouco chato que a função de análise interna rforneça erros de análise em entradas inválidas em vez de retornar um valor padrão, o que significa que eu tenho que filtrar explicitamente as colunas que consistem em não dígitos. Se retornasse 0 em entradas malformadas, eu poderia eliminar fΛ±e salvar 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))

Conjunto de Teste .

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)

Suíte de teste.

A segunda abordagem é uma porta para o Python 3 inspirada na solução do @ officialaimm.

Python 2 , 81 74 bytes

-7 bytes graças a @Mr. Xcoder :'/'<i

• Recebe inteiro ou flutua, retorna flutuação.

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

Experimente online!

Explicação:

A palavra 123.45é dada como entrada. [i for i in`x`if"/"<x]fornece uma lista de números inteiros com strings ['1','2','3','4','5'](que também é z). Agora iteramos através [x]+zisto é [123.45,'1','2','3','4','5'], multiplicação por cada elemento len(z), aqui 5e a conversão de cada um para um flutuador (de modo que as cordas também converter em conformidade), obtendo-se [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Finalmente calculamos sum(...)e obtemos 167282.25.

JavaScript, 75 62 bytes

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

Experimente online

-2 bytes graças a Arnauld
-5 bytes graças a Shaggy (embora a função deva receber um número, mas agora vejo que muitas outras respostas também recebem string)

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

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

Experimente online!

Utilizamos alguns truques do código do Dom para raspar 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

Geléia , 17 bytes

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

Experimente online!

Pitão, 18 bytes

s+RvQsM*RF_lB@jkUT

Experimente aqui.

Pitão , 21 20 bytes

K@jkUTQ+smv*lKdK*lKv

Suíte de teste.

Usa uma abordagem completamente diferente da resposta de @ EriktheOutgolfer , que me ajudou a obter 1 byte no chat, de 22 a 21.

Explicação

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - Filtra os dígitos e os atribui a uma variável K.
         m - mapa. Iterado pelos dígitos com uma variável d
           v - Avaliar (converter para flutuar).
            * lKd - multiplica cada dígito de string pelo comprimento de K.
        s - Soma
       + - Soma
                 * lKvQ - multiplica o número pelo comprimento dos dígitos String

Oitava , 100 82 bytes

Muito obrigado ao TomCarpenter por me ensinar que as atribuições têm um valor de retorno e me salvam 18bytes!

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

Experimente online!

Ungolfed / Explicação

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

A maneira como isso funciona é que basicamente precisamos adicionar o número nvezes e adicionar a soma das colunas. A soma s' * logspace(0,n-1,n)atinge a soma das colunas, por exemplo, se v=-123.4essa matriz for:

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

Então, só precisamos fazer sumisso e terminamos.

Swift 4 , 139 134 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,+))}

Suíte de teste.

Explicação

• func f(s:String)- Define uma função fcom um parâmetro String explícito s.

• let k=s.filter{"/"<$0}- Filtra os dígitos: notei que ambos -e .possuem valores ASCII menores que todos os dígitos, e /está entre ., -e 0. Portanto, apenas verifiquei se "/"é menor que o caractere atual, como fiz na minha resposta em Python.

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

• Float(s)!*Float(k.count)- Converte a String e o número de dígitos em Flutuante e os multiplica (Swift não permite a multiplicação Flutuante e Int :()). Portanto, ele adiciona o número de xvezes, onde xestá o número de dígitos que ele contém.

• k.map{Int(String(repeating:$0,count:k.count))!- k.map{}mapeia kcom o valor atual $0. String(repeating:$0,count:k.count)pega cada dígito, cria uma sequência de xdígitos idênticos e o Float(...)!converte em um número de ponto flutuante.

• .reduce(0,+) - Obtém a soma da lista acima.

• E finalmente +soma os dois resultados.

Vamos dar um exemplo!

Digamos que nossa String seja "0.45". Primeiro, filtramos os dígitos, então ficamos com 0, 4, 5. Convertemos "0.45"para flutuar e multiplicar pelo número de dígitos: 0.45 * 3 = 1.35. Então tomamos cada dígito e transformá-lo em um String repetindo esse dígito até preencher a largura do quadrado (quantos dígitos existem): 0, 4, 5 -> 000, 444, 555. Nós somamos isso 000 + 444 + 555 = 999. Em seguida, basta adicionar os resultados juntos: 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 graças a @Ian H.

Experimente online!

Versão completa / formatada:

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;

Corra como cano com -nR.

Pode gerar avisos no PHP 7.1. Repita $c,$ecom $c>0?$c:0,$epara corrigir.

Python 3 , 68 70 73 77 bytes

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

Experimente online!

Faz um loop sobre cada caractere de dígito e o repete pelo número total de caracteres de dígito, transforma isso em um número inteiro e adiciona isso a n. Dessa forma, nsão adicionados dtempos adicionais , a parte horizontal da soma, juntamente com a repetição de dígitos, que é a parte vertical. Originalmente usado , str.isdigitmas >"/"graças a outras pessoas neste segmento, economizamos muitos bytes. Salva dois bytes usando ncomo uma string, mas a saída é mais confusa.

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

Experimente online!