จำนวนจืด (ซึ่งผมโดยสิ้นเชิงไม่ได้ทำขึ้นเพียงสำหรับความท้าทายนี้) จะถูกสร้างขึ้นเช่นนี้

1. รับจำนวนเต็มบวก N
2. สร้างหมายเลขใหม่ O โดยเพิ่มตัวเลขของ N ที่ส่วนท้ายของ N
3. หมายเลขที่ไม่น่าสนใจสุดท้ายคือ O * N

ตัวอย่างเช่นสำหรับ N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. หมายเลขสุดท้ายคือ 14544

อินพุต

จำนวนเต็มบวก N (N> 0) หรือเทียบเท่าภาษาของคุณ คุณไม่จำเป็นต้องรับอินพุตที่ไม่ถูกต้อง

เอาท์พุต

หมายเลขที่ไม่น่าสนใจที่สอดคล้องกัน

กรณีทดสอบ

  1 -> 11
  2 -> 44
  3 -> 99
 10 -> 10100
174 -> 30306276

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

รหัสที่สั้นที่สุดในไบต์ชนะ

05AB1E , 3 ไบต์

Ы*

อธิบาย

Ð    # triplicate input
 «   # conactenate
  *  # multiply

ลองออนไลน์

JavaScript (ES6), 10 ไบต์

_=>(_+_)*_

จะต้องมีการเรียกว่ามีการโต้แย้งว่าเป็นไม่ได้StringNumber

การใช้งาน:

(_=>(_+_)*_)('3')
99

-3 ไบต์ขอบคุณคำแนะนำของ@Quill

Java 8, 29 26 25 21 Bytes

ขอให้พระเจ้าคุ้มครองแลมบ์ดา

c->new Long(c+""+c)*c

c-> Long.decode (c + "" + c) * ค;

เป็นกลุ่ม 11

C<C-r>=<C-r>"<C-r>"*<C-r>"<cr>

crcrcrcrcr ...

C       change (delete and enter insert mode) until the end of the line
<C-r>=  insert an expression via the special "expression register"
<C-r>"  insert the contents of the default register (what we just C'd)
<C-r>"  ... again
*       multiplied by
<C-r>"  the input (again)
<cr>    insert the result of this expression

Pyth, 5 4 ไบต์

*s+`

คำอธิบาย:

    Q    input
   `     representation, basically str(Q)
  +  Q   add Q to its own string form
 s       parse int
*     Q  multiply by input
         print

ทดสอบได้ที่นี่

Emacs ขนาด 17 ไบต์

(*SPACEC-SPACEC-EM-YSPACEC-YC-Y)C-J

คำอธิบาย

• (*SPACEเพิ่ม(*ที่จุด (ก่อนหมายเลข);
• C-SPACEC-EM-Y เลือกและคัดลอกหมายเลข
• SPACE เพิ่มอักขระช่องว่างที่จุด (หลังหมายเลข);
• C-YC-Y วางสองเท่าของจำนวนที่จุด;
• )เพิ่ม)ในตอนท้าย;
• C-J ตีความบรรทัดเป็นนิพจน์ LISP และพิมพ์ผลลัพธ์

กันตัวอย่าง

เคอร์เซอร์ถูกแสดงโดยไพพ์ ( |)

• |174
• (*SPACE (* |174
• C-SPACEC-EM-Y (* 174|
• SPACE (* 174 |
• C-YC-Y (* 174 174174|
• ) (* 174 174174)|
• C-J

ผลลัพธ์

(* 174 174174)
30306276|

C #, 19 23 ไบต์

n=>int.Parse(""+n+n)*n;

ไม่มีสตริง 47 ไบต์

n=>{int i=1;while(i<=n)i*=10;return(i+1)*n*n;};

Python 2.7, 21 ไบต์:

lambda f:int(`f`*2)*f

นี่ต้องเป็นคำตอบที่สั้นที่สุดของ Python ที่ฉันเคยเขียนในเวลาที่สั้นที่สุด print()มันเป็นฟังก์ชั่นแลมบ์ดาที่ไม่ระบุชื่อที่สามารถดำเนินการโดยการตั้งชื่ออะไรที่มันที่คุณต้องการแล้วเรียกมันเหมือนการทำงานตามปกติในห่อ ตัวอย่างเช่นถ้าใส่ของคุณเป็น12และฟังก์ชั่นเป็นชื่อนี้นี้จะเรียกว่าเหมือนHprint(H(12))

ลองออนไลน์! (Ideone)

โปรดทราบว่านี่ใช้งานได้เฉพาะกับค่าที่สูงขึ้นและเท่ากัน9223372036854775807ตั้งแต่ค่าที่สูงกว่าใด ๆ และrepr()ใส่ a Lไว้ที่ส่วนท้ายของจำนวนเต็ม ดังนั้นสำหรับค่ามากกว่า9223372036854775807นี้24 ไบต์รุ่นจะเป็นหนึ่งที่ทำงาน:

lambda f:int(str(f)*2)*f

ลองใช้ออนไลน์! (Ideone)

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

;DḌ×

ลองออนไลน์

คำอธิบาย

;DḌ×    Main link. argument : N

 D      Decimal; Yield the digits of N
;       Concatenate N and its digits
  Ḍ     Convert to integer; We get O
   ×    Multiply O and N

C, 70 68 54 53 52 44

f(n){return(pow(10,(int)log10(n)+1)*n+n)*n;}

รุ่นก่อนหน้า (48 ไบต์ไม่มีฟังก์ชั่นคณิตศาสตร์) บันทึก 16 ไบต์ด้วย @LeakyNun, 1 ไบต์ขอบคุณ @FryAmTheEggman, 4 ไบต์ขอบคุณ @TobySpeight:

f(n,d,i){for(i=d=n;d;d/=10)i*=10;return(i+n)*n;}

การโทรf()ด้วยอาร์กิวเมนต์หนึ่งหมายเลขและส่งคืนหมายเลขที่ไม่เกี่ยวข้อง

โปรแกรมทดสอบ

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    while (*++argv) {
        int n = atoi(*argv);
        printf("%d -> %d\n", n, f(n));
    }
    return 0;
}

ผลการทดสอบ:

$ ./84712 1 2 3 4 10 174
1 -> 11
2 -> 44
3 -> 99
4 -> 176
10 -> 10100
174 -> 30306276

ลองออนไลน์!

Dyalog APL ขนาด 7 ไบต์

⊢×#⍎⍕,⍕

⍕ การเป็นตัวแทนสตริง

⍕, การแทนค่าสตริงเสริม

#⍎ ทำให้เป็นตัวเลข (ในรูทเนมสเปซ)

⊢× คูณด้วยหมายเลขเดิม

J, 7 ไบต์

*,~&.":

คำอธิบาย

*,~&.":  Input: n
     ":  Format n as a string
 ,~&.    Reflect and join the string to make "nn"
         and parse the string to get a number
*        Multiply that number by n

เรติน่า27 27ไบต์

^
$_$*: $_
:
$_$*:
:

รับบิตช้าสำหรับอินพุตขนาดใหญ่เนื่องจากก่อนหน้าสเตจสุดท้ายผลลัพธ์จะถูกแสดงด้วย unary

ลองออนไลน์! (บรรทัดแรกเปิดใช้งานชุดทดสอบที่แยกบรรทัดด้วยฟีด)

คำอธิบาย

ฉันจะใช้2เป็นตัวอย่างการป้อนข้อมูล (เนื่องจากการเป็นตัวแทน unary ได้รับบิตเทอะทะสำหรับอินพุตขนาดใหญ่)

ด่าน 1: การเปลี่ยนตัว

^
$_$*: $_

โดยการจับคู่จุดเริ่มต้นของสตริงกับ^เราเพียงแค่เติมบางสิ่ง $_อ้างถึงสตริงอินพุตของตัวเองและ$*:หมายความว่าเราแทรกโคลอนจำนวนมาก ดังนั้นเราจึงได้รับ:

:: 22

ด่าน 2: การเปลี่ยนตัว

:
$_$*:

ตอนนี้เราให้ตรงกับทุกครั้งและอีกครั้งแทนที่ด้วย: $_$*:แน่นอนว่าเวลานี้$_ไม่ได้ประเมินเป็นจำนวนเต็ม (แต่เป็น:: 22ตัวอย่างของเรา) แต่$*เพียงแค่มองหาทศนิยมแรกในสตริงดังนั้นสิ่งนี้จะประเมินการป้อนข้อมูลที่เชื่อมต่อกับตัวเอง ( Oในสเปคความท้าทาย) เราจะจบลงด้วยN*Ocolons ตามด้วยO:

:::::::::::::::::::::::::::::::::::::::::::: 22

ด่าน 3: การแข่งขัน

:

สิ่งที่เหลืออยู่คือการนับ:s เพื่อแปลงจาก unary กลับเป็นทศนิยมซึ่งเป็นขั้นตอนนี้

CJam , 8 ไบต์

ri_`_+i*

ลองออนไลน์!

r     e# Read input
i     e# Convert to integer
_     e# Duplicate
`     e# Convert to string
_     e# Duplicate
+     e# Concatenate
i     e# Convert to integer
*     e# Multiply. Implicitly display

เยลลี่, 8 6 ไบต์

ŒṘẋ2v×

ลองออนไลน์!

คำอธิบาย

ŒṘẋ2v× - Main link. Left argument: the number to convert

     × - Multiply
    v  - an evaluation of the left argument
ŒṘ     - converted to string
  ẋ    - multiplied by
   2   - two and the left argument

Awk, 13 ไบต์

$0=($0$0)*$0

กำหนดเส้นเป็น 2 ของตัวเองคูณด้วยตัวเอง

Brachylogขนาด 7 ไบต์

:?c:?*.

คำอธิบาย

:?c      Concatenate Input to itself
   :?*.  Output is that concatenation times Input

Python ขนาด 42 ไบต์

วิธีการทางคณิตศาสตร์บริสุทธิ์โดยไม่ต้องสตริง!

f=lambda n,m=1:m<=n and f(n,m*10)or-~m*n*n

ไอเดียมัน!

Matlab / Octave ขนาด 20 ไบต์

@(x)eval([x x 42 x])

นี่คือฟังก์ชั่นที่ไม่ระบุชื่อที่รับอินพุตเป็นสตริง

ตัวอย่างการใช้:

>> f = @(x)eval([x x 42 x])
f = 
    @(x)eval([x,x,42,x])
>> f('12')
ans =
       14544

หรือลองออนไลน์กับ ideone

คำอธิบาย

รหัสสร้างสตริงโดยเชื่อมโยงสตริงอินพุตสองครั้งจากนั้นอักขระ*(ที่มีรหัส ASCII 42) จากนั้นสตริงอีกครั้ง สตริงที่ต่อกันจะถูกประเมินค่า

MATL , 6 ไบต์

tVthU*

ลองออนไลน์!

tV     % Input number implicitly. Duplicate and convert to string
th     % Duplicate and concatenate the two equal strings
U      % Convert to number
*      % Multiply

zsh, 13 ไบต์

<<<$[$1$1*$1]

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดรับคำสั่งเอาต์พุตไปยัง STDOUT

ใช้งานได้เฉพาะใน zsh แต่นี่คือ15 ไบต์ใน Bashโดยใช้echoแทน<<<:

echo $[$1$1*$1]

Perl, 11 ไบต์

$_*=$_ x2

+ the pและlค่าสถานะ

(วิ่งด้วยperl -ple '$_*=$_ x2')

-2 ไบต์ขอบคุณไปป์

Excel VBA ขนาด 35 ไบต์

ตำบลที่ถูกเรียกด้วยหมายเลข msgbox จะส่งคืนคำตอบ

Sub B(a)
MsgBox (a & a) * a
End Sub

Excel VBA สำรองขนาด 42 ไบต์

จำนวนที่กำหนดในสูตรส่งคืนคำตอบ

Function B(a)
B = (a & a) * a
End Function

Lua ขนาด 20 ไบต์

รับอาร์กิวเมนต์บรรทัดคำสั่งและส่งออกผ่าน STDOUT

a=...print((a..a)*a)

และ ungolfed ตามที่ @LeakyNun ถามในความคิดเห็น :)

a=...       -- alias for the first argument
print(
     (a..a) -- concatenate a with itself, equivalent to a:rep(2)
     *a)    -- multiply the resulting number by a

Pyke, 5 4 ไบต์

`+b*

ลองที่นี่!

`    -    str(input)
 +   -   ^+input  (convert to string implicitly)
  b  -  int(^)
   * - ^*input

ยัง 5 ไบต์ด้วยอินพุตสตริง

+bRb*
+]mbB

PHP, 25 24 ไบต์

แท็กเปิดสั้น ๆ มีประโยชน์สำหรับความท้าทายในการเล่นกอล์ฟที่น่าแปลกใจโชคดีที่นี่เป็นหนึ่งในนั้น น่าเสียดายที่ตัวดำเนินการอยู่ตรงข้ามกับลำดับที่คุณต้องทำในวงเล็บจึงจำเป็นต้องใช้จำนวนมาก

<?=($a=$argv[1])*"$a$a";

แก้ไข: ฉันรู้ว่าการเห็นว่าฉันใช้วงเล็บอย่างไรฉันสามารถข้ามตัวดำเนินการเรียงต่อกันได้อย่างมีประสิทธิภาพโดยการเปลี่ยนลำดับการดำเนินการเป็นลายลักษณ์อักษร

dc, 11 10 ไบต์

ddZAr^1+**

ฉันรู้ว่าในที่สุดฉันก็จะพบการใช้Zคำสั่ง!

การดำเนินการค่อนข้างง่าย - นับตัวเลขใช้เวลา 10 ยกกำลังนั้นและเพิ่มหนึ่ง นี่จะให้ตัวคูณที่เชื่อมโยงตัวเลขกับตัวมันเอง จากนั้นก็คูณ

I / O ใช้สแต็กตามปกติสำหรับ dc

โปรแกรมเต็มรูปแบบ

นี่คือสิ่งที่ฉันใช้สำหรับการทดสอบ:

#!/usr/bin/dc
?
ddZAr^1+**
p

คำสั่งพิเศษสองคำสั่งทำให้เรามี I / O

การทดสอบ

$ for i in 1 2 3 10 174; do printf '%d -> ' $i; ./84712.dc <<<$i; done
1 -> 11
2 -> 44
3 -> 99
10 -> 10100
174 -> 30306276

ขอบคุณเนื่องจาก Sir Biden XVII (1 ไบต์)

คางทูม 11 ไบต์

R I W I_I*I

นี่เป็นหนึ่งในความท้าทายของกอล์ฟที่หายากที่นิสัยแปลก ๆ ของคางทูมนั้นมีประโยชน์มาก ประการแรกตัวแปรทั้งหมดเป็นสตริงและสมการทางคณิตศาสตร์ทั้งหมดได้รับการประเมินจากซ้ายไปขวาอย่างเคร่งครัด (ดังใน: ไม่ใช่ PEMDAS) ดังนั้น 1 + 2 * 4 = 12 ในคางทูมแทนที่จะเป็น = 9 วิธีที่ PEMDAS จะทำ ดังนั้น ungolfed (เพิ่ง):

R I ;     Read from stdin to variable I
W I_I*I ; Write out I concatenated with I, then multiplied by I.

คำเตือน - เนื่องจากรสชาติของคางทูมที่ฉันกำลังใช้ (InterSystems Ensemble) ไม่ได้สะท้อน echo carriage return สำหรับ stdin จำนวนอินพุตและเอาต์พุตจะปรากฏขึ้นพร้อมกัน หากต้องการแก้ไข / เพิ่มความสามารถในการอ่านคุณจะต้องเพิ่มสองไบต์และเพิ่ม CR / LF ด้วยตนเองดังนี้:

R I W !,I_I*I

อย่างไรก็ตามเนื่องจากฉันไม่เห็นความต้องการนั้นในกฎของความท้าทายฉันค่อนข้างแน่ใจว่าฉันดีกับรหัสที่สั้นกว่า หากฉันเข้าใจผิดโปรดอย่าลังเลที่จะ LART ฉันและฉันจะแก้ไขคำตอบของฉัน :-)

PowerShell, 25 , 18 ไบต์

ขอบคุณ TessellatingHeckler สำหรับการเตือนฉันว่า PS รักไปป์ไลน์มากแค่ไหน

ใหม่ 18 ไบต์:

process{$_*"$_$_"}

เก่า 25 ไบต์:

param($a);[int]"$a$a"*$a

คำอธิบาย:

# new
process{$_*"$_$_"}
process{         } # runs code block once for each passed item
        $_*        # multiple the first parameter
           "$_$_"  # concatenate as a string for ease
                   # in this case, the order does the typecasting for us
# old
param($a);[int]"$a$a"*$a
param($a)                 # assigns the first passed parameter to variable $a
         ;                # line terminator
          [int]           # type cast string "$a$a" to int32
               "$a$a"     # convert $a$a to string for easy concatenation
                     *$a  # multiply by $a

การทดสอบ (บันทึกเป็นที่น่าเบื่อ. ps1):

# new
12 | .\boring.ps1
14544
174 | .\boring.ps1
30306276

# old
.\boring.ps1 12
14544
.\boring.ps1 174
30306276

ไม่ใช่คำตอบที่ชนะแน่นอน แต่สนุกโดยไม่คำนึงถึง!

แบตช์, 27 20 18 ไบต์

@cmd/cset/a%1%1*%1

แก้ไข: บันทึกแล้ว 7 ไบต์ด้วย @TessellatingHeckler บันทึกอีก 2 ไบต์ต้องขอบคุณ @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ