Die Leute sagen mir immer wieder, dass das Quadrat einer Zahl die mit sich selbst multiplizierte Zahl ist. Das ist offensichtlich falsch. Die richtige Methode, eine Zahl zu quadrieren, besteht darin, sie in ein Quadrat zu verwandeln, indem sie so oft auf sich selbst gestapelt wird, wie sie Ziffern hat, und dann alle Zahlen aus dem resultierenden Quadrat horizontal (von bis) abzulesen nur von links nach rechts) und vertikal (nur von oben nach unten) und addieren sie dann. Für die Zahl 123 erstellen Sie also zunächst das Quadrat:

123
123
123

Dann nehmen Sie alle Zeilen und Spalten aus dem Quadrat und addieren sie:

123+123+123+111+222+333

Welches gibt uns ein Ergebnis von 1035.

Bei negativen Zahlen stapeln Sie normal (denken Sie daran, dass Sie nur die Anzahl der Stellen zählen , damit das negative Vorzeichen nicht in der Länge enthalten ist), lesen die horizontalen Zahlen normal (mit negativen Vorzeichen) und ignorieren dann die negativen Vorzeichen für die vertikalen Zahlen. Also, für die Zahl -144bekommen wir das Quadrat:

-144
-144
-144

Was gibt uns -144-144-144+111+444+444, was ist gleich567

Bei Zahlen mit nur einer Ziffer entspricht das Quadrat immer der doppelten Zahl (einmal horizontal und einmal vertikal lesen). So 4gibt es uns

4

Was gibt uns 4+4, was ist gleich 8.

Stapeln Sie Zahlen mit Dezimalstellen normal (denken Sie daran, dass nur Ziffern gezählt werden, wenn Sie die Zahl stapeln, und daher der Dezimalpunkt nicht gezählt wird) und ignorieren Sie die Dezimaltrennzeichen, wenn Sie die vertikalen Zahlen lesen. Zum Beispiel 244.2gibt uns die Nummer

244.2
244.2
244.2
244.2

Was gibt uns 244.2+244.2+244.2+244.2+2222+4444+4444+2222, was ist gleich 14308.8.

Bruchteile oder komplexe Zahlen können nicht quadriert werden.

Deine Aufgabe:

Ich habe es satt, die Zahlen von Hand zu quadrieren, deshalb habe ich beschlossen, den Vorgang zu automatisieren. Schreiben Sie mir ein Programm oder eine Funktion, die je nach Belieben einen Gleitkommawert oder einen String als Eingabe verwendet und das Ergebnis der Quadratur auf meine Weise zurückgibt.

Beispiele:

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

Wertung:

Meine Hände werden eng, weil ich all diese Quadrate ausgeschrieben habe, und mein Computer unterstützt das Kopieren / Einfügen nicht. Daher gewinnt der Eintrag mit der geringsten Codemenge, die ich eingeben kann (gemessen in Byte aus irgendeinem Grund?)!

05AB1E , 7 Bytes

þSDg×+O

Probieren Sie es online!

Erläuterung

þ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

Jelly ,  13  12 Bytes

fØDẋ€L$ŒV+VS

Eine monadische Verknüpfung, die eine Liste von Zeichen akzeptiert (eine wohlgeformte Dezimalzahl, wobei die einzelne führende Null eine Voraussetzung für -1 <n <1 ist ) und eine Zahl zurückgibt.

Probieren Sie es online!

14 Bytes zu übernehmen und Rücklaufnummern (Eingangs beschränkt auf +/- 10 ^-5 durch ŒṘ) ŒṘfØDẋ€L$ŒV+⁸S.

Wie?

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

Die Eingabe wird als Zeichenfolge verwendet.

Probieren Sie es online!

Wie es funktioniert

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

Testen Sie es online!

Erläuterung

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

9 Bytes dank @TheLethalCoder
gespeichert Weitere 8 Bytes dank @TheLethalCoder gespeichert

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

Probieren Sie es online!

Nimmt einen String als Eingabe und gibt die quadrierte Zahl als Gleitkommazahl aus.

Dieser Code folgt dem folgenden Algorithmus:

1. Erstellen Sie eine neue Zeichenfolge aus der Eingabe, jedoch ohne die Dezimalstellen und Symbole, damit wir unsere Länge und die Zahlen für die Spalten von dort abrufen können.

2. Berechnen Sie die Eingabe mal die Länge der Zeichenfolge, die wir unter Punkt 1 erstellt haben.

3. Erstellen Sie für jede Spalte in unserem "Quadrat" eine neue Zeichenfolge mit der Spaltennummer und der Zeilenlänge und fügen Sie sie unserem Ergebnis hinzu.

Beispiel:

Eingang: -135.5

1. Wenn wir Dezimalstellen und Symbole ersetzen, erhalten wir den String 1355mit der Länge von 4.
2. Die Eingabe mal 4: -135.5 * 4 = -542.
3. Nun erstellen wir neue Saiten für jede Spalte, analysieren sie und fügen Sie sie auf unser Ergebnis:
   1111, 3333, 5555, 5555.

Wenn wir diese Zahlen zusammenfassen, erhalten wir 15012genau das, was unser Programm ausgibt.

Brachylog , 23 Bytes

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

Probieren Sie es online!

Brachylog passt nicht gut zu Schwimmern ...

Erläuterung:

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

Schale , 15 Bytes

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

Nimmt einen String und gibt eine Zahl zurück. Probieren Sie es online!

Erläuterung

Es ist ein bisschen ärgerlich, dass die eingebaute Parsing-Funktion rbei ungültigen Eingaben Analysefehler ausgibt, anstatt einen Standardwert zurückzugeben, was bedeutet, dass ich die Spalten, die aus Nicht-Ziffern bestehen, explizit herausfiltern muss. Wenn es bei fehlerhaften Eingaben 0 zurückgibt, könnte ich fΛ±3 Bytes löschen und sparen.

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

Test Suite.

Der zweite Ansatz ist eine Portierung auf Python 3, die von der @ officialaimm-Lösung inspiriert wurde.

Python 2 , 81 74 Bytes

-7 Bytes dank @Mr. Xcoder :'/'<i

• Übernimmt Integer oder Float, gibt Float zurück.

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

Probieren Sie es online!

Erläuterung:

Sprich 123.45wird als Input gegeben. [i for i in`x`if"/"<x]gibt eine Liste von Ganzzahlen ['1','2','3','4','5'](die auch ist z). Nun iterieren wir durch, [x]+zdh [123.45,'1','2','3','4','5']multiplizieren jedes Element mit len(z)hier 5und konvertieren jedes in ein Float (so dass auch Strings entsprechend konvertiert werden), was ergibt [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]. Schließlich berechnen wir die sum(...)und erhalten 167282.25.

JavaScript, 75 62 Bytes

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

Probieren Sie es online aus

-2 Bytes dank Arnauld
-5 Bytes dank Shaggy (obwohl die Funktion eine Zahl erhalten muss, sehe ich jetzt, dass viele andere Antworten auch einen String erhalten)

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

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

Probieren Sie es online!

Benutzte einige Tricks aus Doms Code, um 4 Bytes zu rasieren

Erklärt:

@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

Gelee , 17 Bytes

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

Probieren Sie es online!

Pyth, 18 Bytes

s+RvQsM*RF_lB@jkUT

Probieren Sie es hier aus.

Pyth , 21 20 Bytes

K@jkUTQ+smv*lKdK*lKv

Testsuite.

Verwendet einen völlig anderen Ansatz als als die Antwort @ EriktheOutgolfer , die mir geholfen hat, 1 Byte im Chat von 22 auf 21 zu spielen.

Erläuterung

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - Filtert die Ziffern und ordnet sie einer Variablen K zu.
         m - Karte. Durchlaufen Sie die Ziffern mit einer Variablen d
           v - Auswerten (in float konvertieren).
            * lKd - Multipliziert jede String-Ziffer mit der Länge von K.
        s - Summe
       + - Summe
                 * lKvQ - Multipliziert die Zahl mit der Länge der Ziffernfolge

Oktave , 100 82 Bytes

Vielen Dank an @TomCarpenter, dass Sie mir beigebracht haben, dass Zuweisungen einen Rückgabewert haben und mir 18Bytes ersparen !

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

Probieren Sie es online!

Ungolfed / Erklärung

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

Das funktioniert so, dass wir im Grunde genommen die Zahl selbst nund dann die Summe der Spalten addieren müssen. Durch Summieren wird s' * logspace(0,n-1,n)die Summe der Spalten erreicht, beispielsweise wenn v=-123.4diese Matrix wie folgt lautet:

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

Also müssen wir es einfach machen sumund wir sind fertig.

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

Test Suite.

Erläuterung

• func f(s:String)- Definiert eine Funktion fmit einem expliziten String-Parameter s.

• let k=s.filter{"/"<$0}- Filtert die Ziffern: Mir ist aufgefallen, dass beide -und .kleinere ASCII-Werte als alle Ziffern haben und /zwischen ., -und liegen 0. Daher habe "/"ich, wie in meiner Python-Antwort , nur überprüft, ob das Zeichen kleiner als das aktuelle ist.

• print(...) - Druckt das Ergebnis.

• Float(s)!*Float(k.count)- Wandelt sowohl den String als auch die Anzahl der Stellen in Float um und multipliziert sie (Swift erlaubt keine Float- und Int-Multiplikation :()). Also addiert es die Anzahl xmal, wo xist die Anzahl der Ziffern, die es enthält.

• k.map{Int(String(repeating:$0,count:k.count))!- k.map{}Karten vorbeik den aktuellen Wert zu $0. String(repeating:$0,count:k.count)Nimmt jede Ziffer, erstellt einen String mit xidentischen Ziffern und Float(...)!wandelt ihn in eine Gleitkommazahl um.

• .reduce(0,+) - Erhält die Summe der obigen Liste.

• Und zum Schluss +die beiden Ergebnisse.

Nehmen wir ein Beispiel!

Sagen wir, unsere Saite ist "0.45". Zuerst filtern wir die Ziffern, damit wir übrig bleiben 0, 4, 5. Wir wandeln "0.45"auf Float und vermehren sich durch die Anzahl der Stellen: 0.45 * 3 = 1.35. Dann nehmen wir jede Stelle und machen es zu einem String zu wiederholen , dass die Ziffer , bis sie die Breite des Platzes füllt (wie viele Stellen gibt es): 0, 4, 5 -> 000, 444, 555. Wir fassen dies 000 + 444 + 555 = 999. Dann fügen wir nur die Ergebnisse zusammen: 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);}

2 Bytes gespart dank @Ian H.

Probieren Sie es online!

Voll / Formatierte Version:

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;

Als Rohr mit laufen lassen -nR.

Kann in PHP 7.1 zu Warnungen führen. Repace $c,$emit $c>0?$c:0,$ezu beheben.

Python 3 , 68 70 73 77 Bytes

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

Probieren Sie es online!

Durchläuft jedes Ziffernzeichen und wiederholt es um die Gesamtzahl der Ziffernzeichen, macht daraus eine Ganzzahl und fügt diese hinzu n. Auf diese Weise nwird dmal der horizontale Teil der Summe addiert , zusammen mit der Ziffernwiederholung, die der vertikale Teil ist. Ursprünglich verwendet, hat str.isdigitaber >"/"dank anderer in diesem Thread eine Menge Bytes gespart. Spart zwei Bytes, indem es nals String verwendet wird, aber die Ausgabe ist unordentlicher.

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

Probieren Sie es online!