Le persone continuano a dirmi che il quadrato di un numero è il numero moltiplicato per se stesso. Questo è ovviamente falso. Il modo corretto di quadrare un numero è di trasformarlo in un quadrato, impilandolo su se stesso un numero di volte uguale al numero di cifre che ha, e quindi leggendo tutti i numeri dal quadrato risultante, entrambi in orizzontale (da da sinistra a destra) e in verticale (solo da su a giù), quindi aggiungendoli insieme. Quindi, per il numero 123, devi prima creare il quadrato:

123
123
123

Quindi prendi tutte le righe e le colonne dal quadrato e le aggiungi insieme:

123+123+123+111+222+333

Il che ci dà un risultato di 1035.

Per i numeri negativi, si impila normalmente (ricordarsi di contare solo il numero di cifre , quindi il segno negativo non è incluso nella lunghezza), quindi leggere normalmente i numeri orizzontali (con segni negativi), quindi ignorare i segni negativi per i numeri verticali. Quindi, per il numero -144otteniamo il quadrato:

-144
-144
-144

Che ci dà -144-144-144+111+444+444, che è uguale567

Per i numeri con una sola cifra, il quadrato è sempre uguale al numero raddoppiato (letto una volta in orizzontale e una volta in verticale). Quindi 4ci dà

4

Che ci dà 4+4, che è uguale 8.

Per i numeri con parti decimali, impila normalmente (ricorda che vengono contate solo le cifre nel numero di volte in cui impili il numero e quindi il punto decimale non viene conteggiato) e ignora i simboli decimali quando leggi i numeri verticali. Ad esempio, il numero 244.2ci dà

244.2
244.2
244.2
244.2

Che ci dà 244.2+244.2+244.2+244.2+2222+4444+4444+2222, che è uguale 14308.8.

I numeri frazionari o complessi non possono essere quadrati.

Il tuo compito:

Sono stanco di quadrare i numeri a modo mio, quindi ho deciso di automatizzare il processo. Scrivimi un programma o una funzione che accetta un float o una stringa, come preferisci, come input e restituisce il risultato della quadratura a modo mio.

Esempi:

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

punteggio:

Le mie mani si stanno restringendo per la scrittura di tutti quei quadrati e il mio computer non supporta il copia / incolla, quindi vince la voce con il minor numero di codice da digitare (misurato in byte per qualche motivo?)!

05AB1E , 7 byte

þSDg×+O

Provalo online!

Spiegazione

þ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

Gelatina ,  13  12 byte

fØDẋ€L$ŒV+VS

Un collegamento monadico che accetta un elenco di caratteri (un numero decimale ben formato, il singolo zero iniziale è un requisito per -1 <n <1 ) e restituisce un numero.

Provalo online!

14 byte per accettare e numeri di ritorno (ingresso limitato a +/- 10 ^-5 da ŒṘ): ŒṘfØDẋ€L$ŒV+⁸S.

Come?

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 byte

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

L'input è preso come una stringa.

Provalo online!

Come funziona

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 byte

o\d
l
¬xpV +V*Ng

Provalo online!

Spiegazione

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 byte

Salvataggio di 9 byte grazie a @TheLethalCoder Salvataggio di
altri 8 byte grazie 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;}

Provalo online!

Prende una stringa come input e genera il numero "quadrato" come float.

Questo codice segue il seguente algoritmo:

1. Crea una nuova stringa dall'input, ma senza i punti decimali e i simboli, in modo da poter ottenere la nostra lunghezza e i numeri per le colonne da lì.

2. Calcola i tempi di input per la lunghezza della stringa che abbiamo creato al punto 1.

3. Per ogni colonna nel nostro "quadrato", crea una nuova stringa con il numero di colonna e la lunghezza della riga e aggiungila al nostro risultato.

Esempio:

Ingresso: -135.5

1. Se sostituiamo i punti decimali e i simboli otteniamo la stringa 1355, che ha una lunghezza di 4.
2. I tempi di ingresso 4: -135.5 * 4 = -542.
3. Ora creiamo nuove stringhe per ogni colonna, li analizziamo e aggiungerli al nostro risultato:
   1111, 3333, 5555, 5555.

Se sommiamo questi numeri otteniamo 15012, che è esattamente ciò che il nostro programma produrrà.

Brachylog , 23 byte

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

Provalo online!

Brachylog non va bene con i galleggianti ...

Spiegazione:

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

Buccia , 15 byte

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

Prende una stringa e restituisce un numero. Provalo online!

Spiegazione

È un po 'fastidioso che la funzione di analisi integrata rdia errori di analisi su input non validi invece di restituire un valore predefinito, il che significa che devo filtrare esplicitamente le colonne costituite da non cifre. Se restituisse 0 su input non validi, potrei rilasciare fΛ±e salvare 3 byte.

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

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 byte

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

Test Suite.

Il secondo approccio è una porta per Python 3 ispirata alla soluzione di @ officialaimm.

Python 2 , 81 74 byte

-7 byte grazie a @Mr. Xcoder :'/'<i

• Accetta numeri interi o float, restituisce float.

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

Provalo online!

Spiegazione:

Say 123.45è dato come input. [i for i in`x`if"/"<x]fornisce un elenco di numeri interi stringati ['1','2','3','4','5'](che è anche z). Ora iteriamo per [x]+zesempio [123.45,'1','2','3','4','5'], moltiplicando ogni elemento da len(z), qui 5e la conversione di ciascuno per un galleggiante (in modo che le stringhe anche convertire conseguenza), cedendo [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Infine calcoliamo sum(...)e otteniamo 167282.25.

JavaScript, 75 62 byte

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

Provalo online

-2 byte grazie ad Arnauld
-5 byte grazie a Shaggy (anche se la funzione deve ricevere un numero, ma ora vedo che anche molte altre risposte ricevono una stringa)

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

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

Provalo online!

Ho usato alcuni trucchi del codice di Dom per radere 4 byte

Ha spiegato:

@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

Gelatina , 17 byte

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

Provalo online!

Pyth, 18 byte

s+RvQsM*RF_lB@jkUT

Provalo qui.

Pyth , 21 20 byte

K@jkUTQ+smv*lKdK*lKv

Suite di test.

Utilizza un approccio completamente diverso dalla risposta di @EriktheOutgolfer , che mi ha aiutato a giocare a golf a 1 byte in chat, dalle 22 alle 21.

Spiegazione

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - Filtra le cifre e le assegna a una variabile K.
         m - Mappa. Scorrere le cifre con una variabile d
           v - Valuta (converti in float).
            * lKd - Moltiplica ogni cifra di String per la lunghezza di K.
        s - Somma
       + - Somma
                 * lKvQ - Moltiplica il numero per la lunghezza delle cifre String

Ottava , 100 82 byte

Grazie mille @ TomCarpenter per avermi insegnato che le assegnazioni hanno un valore di ritorno e mi fanno risparmiare 18byte!

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

Provalo online!

Ungolfed / Spiegazione

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

Il modo in cui funziona è che in pratica dobbiamo aggiungere il numero stesso nvolte e quindi aggiungere la somma delle colonne. La somma s' * logspace(0,n-1,n)raggiunge la somma delle colonne, ad esempio se v=-123.4quella matrice sarà:

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

Quindi abbiamo solo bisogno di sumfarlo e abbiamo finito.

Swift 4 , 139 134 byte

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

Test Suite.

Spiegazione

• func f(s:String)- Definisce una funzione fcon un parametro String esplicito s.

• let k=s.filter{"/"<$0}- Filtri le cifre: ho notato che entrambi -e .hanno valori ASCII ridotte rispetto a tutti le cifre, e /si trova tra ., -e 0. Quindi, ho appena controllato se "/"è più piccolo del personaggio attuale, come ho fatto nella mia risposta Python.

• print(...) - Stampa il risultato.

• Float(s)!*Float(k.count)- Converte sia la stringa che il numero di cifre in Float e li moltiplica (Swift non consente la moltiplicazione Float e Int :()). Quindi aggiunge il numero di xvolte, dov'è xil numero di cifre che contiene.

• k.map{Int(String(repeating:$0,count:k.count))!- k.map{}mappa kcon il valore corrente $0. String(repeating:$0,count:k.count)prende ogni cifra, crea una stringa di xcifre identiche e la Float(...)!converte in un numero a virgola mobile.

• .reduce(0,+) - Ottiene la somma dell'elenco sopra.

• E infine +somma i due risultati.

Facciamo un esempio!

Di 'che è la nostra corda "0.45". Prima di tutto, filtriamo le cifre, quindi ci rimane 0, 4, 5. Convertiamo "0.45"a Float e moltiplicare per il numero di cifre: 0.45 * 3 = 1.35. Poi prendiamo ogni cifra e trasformarlo in una stringa ripetere che cifre, fino a riempire la larghezza del quadrato (quante cifre sono): 0, 4, 5 -> 000, 444, 555. Sommiamo questo, 000 + 444 + 555 = 999. Poi basta aggiungere i risultati insieme: 1.35 + 999 = 1000.35.

C #, 139 137 byte

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

Salvato 2 byte grazie a @Ian H.

Provalo online!

Versione completa / formattata:

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 byte

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

PHP, 78 88 +1 byte

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

Esegui come pipe con -nR.

Può generare avvisi in PHP 7.1. Sostituisci $c,$econ $c>0?$c:0,$eper risolvere.

Python 3 , 68 70 73 77 byte

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

Provalo online!

Passa sopra ogni carattere di cifra e lo ripete per il numero complessivo di caratteri di cifra, lo trasforma in un numero intero e lo aggiunge a n. In questo modo nvengono aggiunti dtempi, la parte orizzontale della somma, insieme alla ripetizione delle cifre, che è la parte verticale. Originariamente utilizzato str.isdigitma >"/", grazie ad altri in questo thread, ha salvato molti byte. Salva due byte prendendo ncome stringa, ma l'output è più disordinato.

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

Provalo online!