ผู้คนต่างบอกฉันว่าจตุรัสของตัวเลขนั้นคือจำนวนคูณด้วยตัวมันเอง เห็นได้ชัดว่าเป็นเท็จ วิธีที่ถูกต้องในการจัดตารางจำนวนคือการทำให้มันเป็นสี่เหลี่ยมโดยการซ้อนมันไว้ด้านบนของตัวเองจำนวนครั้งเท่ากับจำนวนตัวเลขที่มีและจากนั้นอ่านตัวเลขทั้งหมดจากตารางผลลัพธ์ทั้งในแนวนอน (จาก จากซ้ายไปขวาเท่านั้น) และแนวตั้ง (จากบนลงล่างเท่านั้น) จากนั้นเพิ่มเข้าด้วยกัน ดังนั้นสำหรับหมายเลข 123 คุณต้องสร้างตารางก่อน:

123
123
123

จากนั้นคุณนำแถวและคอลัมน์ทั้งหมดออกจากสแควร์แล้วเพิ่มเข้าด้วยกัน:

123+123+123+111+222+333

ซึ่งให้ผลกับ1035เรา

สำหรับตัวเลขลบคุณสแต็คตามปกติ (โปรดจำไว้ว่าคุณนับจำนวนหลักเท่านั้นดังนั้นเครื่องหมายลบจะไม่รวมอยู่ในความยาว) จากนั้นอ่านตัวเลขแนวนอนตามปกติ (พร้อมเครื่องหมายลบ) แล้วละเว้นสัญญาณลบสำหรับ ตัวเลขแนวตั้ง ดังนั้นสำหรับจำนวนที่-144เราได้รับตาราง:

-144
-144
-144

ซึ่งให้เรา-144-144-144+111+444+444ซึ่งเท่ากับ567

สำหรับตัวเลขที่มีเพียงหนึ่งหลักสี่เหลี่ยมจะเท่ากับจำนวนสองเท่าเสมอ (อ่านครั้งเดียวในแนวนอนและแนวตั้งหนึ่งครั้ง) ดังนั้น4ให้เรา

4

ซึ่งจะช่วยให้เราซึ่งเท่ากับ 4+48

สำหรับตัวเลขที่มีส่วนทศนิยมให้ตั้งสแต็กตามปกติ (โปรดจำไว้ว่าเฉพาะตัวเลขที่นับในจำนวนครั้งที่คุณสแต็กจำนวนเท่านั้นดังนั้นจะไม่นับจำนวนทศนิยม) และละเว้นสัญลักษณ์ทศนิยมเมื่ออ่านตัวเลขแนวตั้ง ตัวอย่างเช่นจำนวน244.2ทำให้เรา

244.2
244.2
244.2
244.2

ซึ่งจะช่วยให้เราซึ่งเท่ากับ244.2+244.2+244.2+244.2+2222+4444+4444+222214308.8

เศษส่วนหรือจำนวนเชิงซ้อนไม่สามารถยกกำลังสอง

งานของคุณ:

ฉันเบื่อที่จะยกกำลังสองของตัวเลขด้วยมือของฉันดังนั้นฉันตัดสินใจที่จะทำให้กระบวนการเป็นไปโดยอัตโนมัติ เขียนโปรแกรมหรือฟังก์ชั่นที่รับค่าทศนิยมหรือสตริงตามที่คุณต้องการเป็นอินพุตและส่งกลับผลลัพธ์ของการยกกำลังสองในแบบของฉัน

ตัวอย่าง:

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

เกณฑ์การให้คะแนน:

มือของฉันกำลังคับแคบจากการเขียนสแควร์ทั้งหมดเหล่านั้นและคอมพิวเตอร์ของฉันไม่สนับสนุนการคัดลอก / วางดังนั้นรายการที่มีรหัสน้อยที่สุดสำหรับฉันที่จะพิมพ์ (วัดเป็นไบต์ด้วยเหตุผลบางอย่าง?) ชนะ!

05AB1E , 7 ไบต์

þSDg×+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

เยลลี่ ,  13  12 ไบต์

fØDẋ€L$ŒV+VS

ลิงก์ monadic ยอมรับรายการของอักขระ (ตัวเลขทศนิยมที่มีรูปแบบที่ดีศูนย์นำหน้าเดียวเป็นข้อกำหนดสำหรับ-1 <n <1 ) และส่งกลับตัวเลข

ลองออนไลน์!

14 ไบต์ที่จะยอมรับและตัวเลขผลตอบแทน (input จำกัด ที่+/- 10 ^-5โดย):ŒṘŒṘfØDẋ€L$ŒV+⁸S

อย่างไร?

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 ไบต์

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

อินพุตถูกใช้เป็นสตริง

ลองออนไลน์!

มันทำงานอย่างไร

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 ไบต์

o\d
l
¬xpV +V*Ng

ทดสอบออนไลน์!

คำอธิบาย

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 ไบต์

บันทึกแล้ว 9 ไบต์ด้วย @TheLethalCoder
บันทึกอีก 8 ไบต์ด้วย @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;}

ลองออนไลน์!

รับค่าสตริงเป็นอินพุตและเอาต์พุตตัวเลข 'squared' เป็นทศนิยม

รหัสนี้ตามอัลกอริทึมต่อไปนี้:

1. สร้างสตริงใหม่จากอินพุต แต่ไม่มีจุดทศนิยมและสัญลักษณ์เพื่อให้เราสามารถรับความยาวและตัวเลขสำหรับคอลัมน์จากที่นั่น

2. คำนวณค่าอินพุทคูณความยาวของสตริงที่เราสร้าง ณ จุดที่ 1

3. สำหรับแต่ละคอลัมน์ใน 'สแควร์' ของเราสร้างสตริงใหม่ที่มีหมายเลขคอลัมน์และความยาวแถวและเพิ่มลงในผลลัพธ์ของเรา

ตัวอย่าง:

การป้อนข้อมูล: -135.5

1. ถ้าเราเปลี่ยนจุดทศนิยมและสัญลักษณ์ที่เราได้รับสตริงที่มีความยาวของ13554
2. อินพุตครั้งที่ -135.5 * 4 = -5424:
3. 
   1111ตอนนี้เราสร้างสายใหม่สำหรับแต่ละคอลัมน์แยกพวกเขาและพวกเขาที่จะเพิ่มผลของเรา: 3333, 5555, 5555,

หากเรารวมตัวเลขเหล่านี้เข้าด้วย15012กันเราจะได้ผลลัพธ์ซึ่งเป็นสิ่งที่โปรแกรมของเราจะส่งออก

Brachylogขนาด 23 ไบต์

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

ลองออนไลน์!

Brachylog ลอยได้ไม่ดี ...

คำอธิบาย:

{∋ịṫ}ᶠ⟨≡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 ไบต์

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

รับสตริงและส่งคืนตัวเลข ลองออนไลน์!

คำอธิบาย

มันค่อนข้างน่ารำคาญที่ฟังก์ชั่นการแยกวิเคราะห์ในตัวrให้ข้อผิดพลาดในการแยกวิเคราะห์อินพุตที่ไม่ถูกต้องแทนที่จะส่งคืนค่าเริ่มต้นซึ่งหมายความว่าฉันต้องกรองคอลัมน์ที่ประกอบด้วยตัวเลขที่ไม่ใช่ตัวเลขอย่างชัดเจน ถ้ามันคืนค่า 0 จากอินพุตที่มีรูปแบบไม่ถูกต้องฉันสามารถปล่อยfΛ±และบันทึกได้ 3 ไบต์

§+ȯṁ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 ไบต์

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 ไบต์

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

ชุดทดสอบ

แนวทางที่สองคือพอร์ตไปยัง Python 3 ซึ่งได้แรงบันดาลใจจากโซลูชันของ @ officialaimm

Python 2 , 81 74 ไบต์

-7 ไบต์ขอบคุณ @Mr Xcoder :'/'<i

• รับจำนวนเต็มหรือลอยส่งกลับค่าทศนิยม

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

ลองออนไลน์!

คำอธิบาย:

Say 123.45ถูกกำหนดให้เป็นอินพุต [i for i in`x`if"/"<x]ให้รายการของจำนวนเต็ม stringified ['1','2','3','4','5'](ซึ่งก็คือz) ตอนนี้เราย้ำผ่าน[x]+zเช่น[123.45,'1','2','3','4','5']คูณแต่ละองค์ประกอบโดยlen(z)ที่นี่5และแปลงแต่ละลอย (เพื่อให้สตริงยังแปลงตาม) [617.25,11111.0,22222.0,33333.0,44444.0,55555.0]ยอม ในที่สุดเราคำนวณและได้รับsum(...)167282.25

JavaScript, 75 62 ไบต์

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

ลองออนไลน์

ต้องขอบคุณ -2 by Arnauld
-5 bytes ขอบคุณShaggy (ฉันแม้ว่าฟังก์ชั่นจะต้องได้รับตัวเลข แต่ตอนนี้ฉันเห็นคำตอบอื่น ๆ มากมายที่ได้รับสายอักขระ)

Perl 5 , 37 33 + 1 (-p) = 38 34 ไบต์

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

ลองออนไลน์!

ใช้เทคนิคบางอย่างจากรหัสของ Dom เพื่อโกน 4 ไบต์

อธิบาย:

@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

เยลลี่ขนาด 17 ไบต์

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

ลองออนไลน์!

Pyth, 18 ไบต์

s+RvQsM*RF_lB@jkUT

ลองที่นี่

Pyth , 21 20 ไบต์

K@jkUTQ+smv*lKdK*lKv

ชุดทดสอบ

ใช้แนวทางที่แตกต่างอย่างสิ้นเชิงจากคำตอบของ @ EriktheOutgolferซึ่งช่วยให้ฉันเล่นกอล์ฟ 1 ไบต์ในการแชทตั้งแต่ 22 ถึง 21

คำอธิบาย

K@jkUTQ+s.ev*lKbK*lKv

K @ jkUTQ - กรองตัวเลขและกำหนดให้กับตัวแปร K
         m - แผนที่ วนซ้ำผ่านตัวเลขด้วยตัวแปร d
           v - ประเมิน (แปลงเป็นลอย)
            * lKd - คูณจำนวนสตริงแต่ละหลักด้วยความยาวของ K
        s - ผลรวม
       + - รวม
                 * lKvQ - คูณจำนวนด้วยความยาวของตัวเลข String

ระดับเสียงคู่ , 100 82 ไบต์

ขอบคุณ @TomCarpenter มากสำหรับการสอนฉันว่างานที่ได้รับมีค่าตอบแทนและช่วยฉัน18ไบต์!

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

ลองออนไลน์!

Ungolfed / คำอธิบาย

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

วิธีการทำงานนี้คือโดยพื้นฐานแล้วเราจำเป็นต้องเพิ่มจำนวนnครั้งแล้วเพิ่มผลรวมของคอลัมน์ ข้อสรุปs' * logspace(0,n-1,n)บรรลุผลรวมของคอลัมน์เช่นถ้าv=-123.4เมทริกซ์ที่จะได้รับ:

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

ดังนั้นเราต้องทำsumมันให้เสร็จ

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

ชุดทดสอบ

คำอธิบาย

• func f(s:String)- กำหนดฟังก์ชั่นที่มีพารามิเตอร์สตริงอย่างชัดเจนfs

• let k=s.filter{"/"<$0}- กรองตัวเลข: ผมสังเกตเห็นว่าทั้งสอง-และ.มีขนาดเล็ก ASCII ค่ากว่าตัวเลขทั้งหมดและ/อยู่ระหว่าง., และ- 0ดังนั้นฉันเพิ่งตรวจสอบว่า"/"ตัวละครมีขนาดเล็กกว่าตัวละครตัวเดิมอย่างที่ฉันเคยทำในคำตอบของ Python

• print(...) - พิมพ์ผลลัพธ์

• Float(s)!*Float(k.count)- แปลงทั้งสตริงและจำนวนหลักเป็นโฟลตและคูณมัน (Swift ไม่อนุญาตการคูณด้วยโฟลตและ Int :() ดังนั้นมันจึงเพิ่มจำนวนxครั้งโดยที่xจำนวนหลักประกอบด้วย

• k.map{Int(String(repeating:$0,count:k.count))!- k.map{}แผนที่มากกว่ามูลค่าปัจจุบันk ใช้แต่ละหลักสร้างสตริงของตัวเลขที่เหมือนกันและแปลงเป็นตัวเลขทศนิยม$0String(repeating:$0,count:k.count)xFloat(...)!

• .reduce(0,+) - รับผลรวมของรายการด้านบน

• และในที่สุดก็+สรุปผลลัพธ์ทั้งสอง

ลองยกตัวอย่าง!

บอกว่า String "0.45"ของเราคือ 0, 4, 5ปิดครั้งแรกที่เรากรองตัวเลขดังนั้นเราจะเหลือ เราแปลงที่จะลอยและคูณด้วยจำนวนตัวเลข:"0.45" 0.45 * 3 = 1.35จากนั้นเราก็ใช้เวลาในแต่ละหลักและทำให้มันกลายเป็น String ซ้ำหลักนั้นจนกว่าจะเติมความกว้างของตาราง (วิธีการหลายตัวเลขมี) 0, 4, 5 -> 000, 444, 555ไปนี้: เราสรุปสิ่งนี้, 000 + 444 + 555 = 999. จากนั้นเราเพียงเพิ่มผลลัพธ์เข้าด้วยกัน: 1.35 + 999 = 1000.35.

C #, 139 137 ไบต์

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 ไบต์ต้องขอบคุณ @Ian H.

ลองออนไลน์!

เวอร์ชันเต็ม / ฟอร์แมต:

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 ไบต์

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

PHP, 78 88 +1 ไบต์

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

-nRทำงานเป็นท่อด้วย

อาจให้คำเตือนใน PHP 7.1 ทำซ้ำ$c,$eด้วย$c>0?$c:0,$eเพื่อแก้ไข

Python 3 , 68 70 73 77ไบต์

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

ลองออนไลน์!

nลูปมากกว่าตัวละครหลักทุกคนและซ้ำด้วยจำนวนของตัวละครหลักโดยรวมทำให้เป็นจำนวนเต็มและเพิ่มที่ วิธีนี้nจะเพิ่มdเวลาส่วนแนวนอนของผลรวมพร้อมกับการทำซ้ำหลักซึ่งเป็นส่วนแนวตั้ง เริ่มแรกใช้str.isdigitแต่>"/"ขอบคุณผู้อื่นในเธรดนี้บันทึกเป็นจำนวนมาก บันทึกสองไบต์โดยการใช้nเป็นสตริง แต่ผลลัพธ์จะเป็น messier

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

ลองออนไลน์!