재미 번호 (I 완전히 만이 도전을 만회하지 않았다)과 같이 생성된다 :

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

온라인으로 사용해보십시오

자바 스크립트 (ES6), 10 바이트

_=>(_+_)*_

인수가 아닌가 String아닌 인수로 호출해야합니다 Number.

용법:

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

@Quill 의 제안 덕분에 -3 바이트 .

자바 8, 29 26 25 21 바이트

신의 축복 람다

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

c-> 긴 코드 (c + ""+ 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

여기에서 테스트하십시오 .

이맥스, 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;};

파이썬 2.7, 21 바이트 :

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

글쎄, 이것은 내가 작성한 가장 짧은 시간 동안 가장 짧은 Python 답변이어야합니다. 원하는 이름을 지정한 다음 래핑 된 일반 함수처럼 호출하여 실행할 수있는 익명의 람다 함수입니다 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

2 단계 : 교체

:
$_$*:

이제 우리는 모든 것을 일치 :시키고 다시로 대체합니다 $_$*:. 물론 이번에 $_는 정수로 평가하지 않지만 (이 :: 22예제에서는) $*문자열에서 첫 번째 십진수 만 찾으므로 ( O자세한 사양에서) 자체에 연결된 입력으로 평가됩니다 . 우리는 될 겁니다 N*O콜론, 다음 O:

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

3 단계 : 경기

:

남은 것은 :단항에서 십진수로 변환하기 위해 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

파이썬, 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에서만 작동하지만 Bashecho 에는 <<<다음 대신 15 바이트가 사용 됩니다 .

echo $[$1$1*$1]

펄, 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

루아, 20 바이트

명령 행 인수를 받아서 STDOUT을 통해 출력

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

그리고 @LeakyNun이 코멘트에서 물었던 것처럼 ungolfed :)

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

파이크, 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을 그 힘으로 올리고 1을 더하십시오. 이것은 숫자와 자체를 연결하는 승수를 제공합니다. 그런 다음 곱하십시오.

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

Biden XVII 경 (1 바이트) 덕분입니다.

볼거리, 11 바이트

R I W I_I*I

이것은 유행성 이하선염의 특질이 매우 유용 할 수있는 드문 골프 도전 중 하나입니다. 첫째, 모든 변수는 문자열이며 모든 수학 방정식은 왼쪽에서 오른쪽으로 엄격하게 평가되므로 (PEMDAS가 아님) PEMDAS가하는 방식과 같이 = 9 대신 Mumps에서 1 + 2 * 4 = 12입니다. 따라서 (간신히) 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)을 사용하는 유행성 이하선염의 풍미는 stdin에 대한 캐리지 리턴을 반영하지 않기 때문에 입력 및 출력 번호가 연결된 것으로 나타납니다. 가독성을 높이거나 높이려면 2 바이트를 추가하고 수동 CR / LF를 추가해야합니다.

R I W !,I_I*I

그러나 도전 규칙에서 해당 요구 사항을 보지 못했기 때문에 더 짧은 코드에 능숙하다고 확신합니다. 내가 틀렸다면, 저에게 LART를 주시기 바랍니다 그리고 내 답변을 수정합니다. :-)

PowerShell, 25 , 18 바이트

PS가 파이프 라인을 얼마나 좋아하는지 상기시켜 준 TessellatingHeckler에게 감사합니다.

새로운 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 바이트를 절약했습니다.