这样创建一个无趣的数字（我完全没有为这个挑​​战所弥补）：

1. 取正整数N
2. 通过在N的末尾添加N的数字来创建新的数字O
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个字节

_=>(_+_)*_

需要使用参数a String而不是a 来调用Number。

用法：

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

-3个字节，感谢@Quill的建议。

Java 8，29 26 25 21字节

上帝保佑lambda

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

c-> Long.decode（c +“” + c）* c;

vim，11岁

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

crcrcrcr ...

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答案。这是一个匿名的lambda函数，可以通过将其命名为所需的任意名称，然后像包裹在中的普通函数一样调用它来执行print()。例如，如果您的输入为12，并且函数被命名为H，则这将称为print(H(12))。

在线尝试！（爱迪生）

请注意，这仅适用于等于或大于等于的值，9223372036854775807因为任何更高的值都repr()将a L放在整数的末尾。因此，对于大于的值9223372036854775807，将使用以下24字节版本：

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

在线尝试！（爱迪生）

果冻，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字节，没有数学函数），@ LeakyNun节省了16个字节，@ FryAmTheEggman节省了1个字节，@ TobySpeight节省了4个字节：

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 20字节

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

对于大型输入，会有点慢，因为在最后一个阶段之前，结果以一元表示。

在线尝试！（第一行启用换行分隔的测试套件。）

说明

我将使用2输入作为示例（因为一元表示形式对于较大的输入会有点笨拙）。

阶段1：替代

^
$_$*: $_

通过匹配字符串的开头，^我们可以简单地添加一些内容。$_指输入字符串本身，$*:表示我们插入了许多冒号。这样我们得到：

:: 22

第二阶段：替代

:
$_$*:

现在，我们将每次匹配都:替换为$_$*:。当然，这次$_不会求整数（:: 22在我们的示例中为整数），而是$*查找字符串中的第一个小数，因此，它求和连接到自身的输入（O在Challenge规范中）。我们将以N*O冒号结尾，然后是O：

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

第三阶段：比赛

:

剩下的全部工作就是将:s从一元转换为十进制，这正是此阶段的工作。

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 /八度，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中有效，但是在Bash中使用15个字节echo代替<<<：

echo $[$1$1*$1]

Perl，11个字节

$_*=$_ x2

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

和@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像往常一样使用堆栈。

完整程序

这是我用于测试的内容：

#!/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

感谢拜登十七世（1字节）。

腮腺炎，11字节

R I W I_I*I

这是罕见的高尔夫挑战之一，腮腺炎的特质可以派上用场。首先，所有变量都是字符串，并且所有数学方程式都是从左到右严格求值的（例如：不是PEMDAS），因此，在Mumps中1 + 2 * 4 = 12而不是PEMDAS的方式是= 9。因此，（勉强）取消高尔夫球：

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

请注意-因为我正在使用的流行性腮腺炎（InterSystems Ensemble）的风格不会呼应stdin的回车符，因此输入和输出编号将显示为串联。要纠正该错误/提高可读性，您需要添加两个字节并添加一个手动CR / LF，因此：

R I W !,I_I*I

但是，由于我没有在挑战规则中看到该要求，所以我很确定自己对较短的代码很满意。如果我弄错了，请随时告诉我，我将修改答案。:-)

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

测试（另存为boring.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

编辑：感谢@TessellatingHeckler，节省了7个字节。感谢@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ，又节省了2个字节。