Bir ilginç olmayan sayı (Tamamen sadece bu meydan okuma için makyaj yoktu) şöyle oluşturulur:

1. Olumlu bir tamsayı N alın
2. N sonuna N rakamını ekleyerek yeni bir O numarası oluşturun.
3. Son ilgi çekici sayı O * N'dir.

Örneğin N = 12 için:

1. O = 1212
2. O * N = 1212 * 12
3. Son numara 14544

Giriş

Olumlu bir tamsayı N (N> 0) veya dilinizin karşılığı. Yanlış giriş yapmak zorunda değilsiniz.

Çıktı

İlgili ilginç sayı.

Test durumları

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

puanlama

Bayt'taki en kısa kod kazanır.

05AB1E , 3 bayt

Ы*

Açıklaması

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Çevrimiçi deneyin

JavaScript (ES6), 10 bayt

_=>(_+_)*_

Bir argümanla Stringdeğil , a ile çağrılmalıdır Number.

Kullanımı:

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

@ Quill'in önerisi sayesinde -3 bayt .

Java 8, 29 26 25 21 Bayt

Tanrı lambda'yı korusun

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

c> Long.decode (c + "" + c) '* C;

vim, 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 bayt

*s+`

Açıklama:

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

Burada test et .

Emacs, 17 bayt

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

açıklama

• (*SPACE(*noktaya ekler (sayıdan önce);
• C-SPACEC-EM-Y Numarayı seçin ve kopyalayın;
• SPACE noktaya bir boşluk karakteri ekler (sayıdan sonra);
• C-YC-Y noktadaki sayının iki katı kadar yapıştırır;
• ))sonunda ekler ;
• C-J satırı bir LISP ifadesi olarak yorumlar ve sonucunu yazdırır.

exemple

Bir boru tarafından temsil edilen imleç ( |)

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

Sonuç

(* 174 174174)
30306276|

C #, 19 23 bayt

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

Dizeler olmadan, 47 bayt

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

Python 2.7, 21 bayt:

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

Bu, şimdiye kadarki en kısa sürede yazdığım en kısa Python cevabı olmalı. İstediğiniz herhangi bir şeyi adlandırarak ve sonra içine sarılmış normal bir işlev olarak çağırarak çalıştırılabilen adsız bir lambda işlevidir print(). Mesela, eğer girişiniz 12ve fonksiyon isimlendirilmişse H, buna şöyle denirdi print(H(12)).

Çevrimiçi Deneyin! (Ideone)

Bunun sadece 9223372036854775807herhangi bir daha yüksek değere eşit ve onlarla eşit olan değerler için işe yaradığını ve tamsayının sonuna repr()bir değer koyduğunu unutmayın L. Bu nedenle, daha büyük değerler için 9223372036854775807, bu 24 baytlık sürümü çalışanı olacaktır:

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

Bunu Çevrimiçi Deneyin! (Ideone)

Jöle, 4 Bayt

;DḌ×

Çevrimiçi deneyin

açıklama

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

Önceki sürüm (48 bayt, matematik işlevi yok), @LeakyNun sayesinde 16 bayt, @FryAmTheEggman sayesinde 1 bayt, @TobySpeight sayesinde 4 bayt sayesinde:

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

Çağrı f()bir argüman, sayı ile ve ilgili ilginç sayısını döndürür.

Test programı

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

Test sonuçları:

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

Çevrimiçi deneyin!

Dyalog APL , 7 bayt

⊢×#⍎⍕,⍕

⍕ dize gösterimi

⍕, dize gösterimi hazırla

#⍎ sayıya çevir (kök ad alanında)

⊢× orijinal numara ile çarp

J, 7 bayt

*,~&.":

açıklama

*,~&.":  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

Retina , 27 20 bayt

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

Büyük girdiler için biraz yavaş olur çünkü son aşamadan önce sonuç tekdüze olarak gösterilir.

Çevrimiçi deneyin! (İlk satır satır besleme ile ayrılmış bir test takımı sağlar.)

açıklama

2Örnek bir girdi olarak kullanacağım (çünkü tek biçimli gösterimler daha büyük girdiler için biraz hantallaşıyor).

Aşama 1: Değiştirme

^
$_$*: $_

Dizenin başlangıcını eşleştirerek ^bazı şeyleri hazırlarız. $_giriş dizgisinin kendisine atıfta bulunur ve $*:bu kadar fazla virgül ekleriz. Yani biz alırız:

:: 22

Aşama 2: Değiştirme

:
$_$*:

Şimdi her birini eşleştiriyoruz :ve onunla değiştiriyoruz $_$*:. Elbette, bu süre $_bir tamsayı olarak değerlendirilmez (ancak :: 22örneğimize göre), ancak $*yalnızca dizedeki ilk ondalık basamağı arar, bu nedenle bu kendi kendine birleştirilmiş girdiyi değerlendirir ( Ozorluk şartnamesinde). Sonunda N*Oiki nokta üst üste konacağız, ardından O:

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

Aşama 3: Eşleşme

:

Geriye kalan tek şey :, saryerden ondalık basamağa dönüştürmek için s saymaktır , bu tam da bu aşamada yapılan şeydir.

CJam , 8 bayt

ri_`_+i*

Çevrimiçi deneyin!

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

Jöle, 8 6 bayt

ŒṘẋ2v×

Çevrimiçi deneyin!

açıklama

ŒṘẋ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 bayt

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

Çizgiyi 2 ile çarparak kendisiyle çarpma

Brachylog , 7 bayt

:?c:?*.

açıklama

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

Python, 42 bayt

Dizeler olmadan saf aritmetik yaklaşım!

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

Ideone!

Matlab / Octave, 20 bayt

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

Bu, girişi bir dizge olarak alan anonim bir işlevdir.

Örnek kullanım:

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

Veya çevrimiçi olarak ideone ile deneyin .

açıklama

Kod, giriş dizesini iki kez, ardından karakteri *(ASCII kodunu 42 olan), sonra dizeyi tekrar birleştirerek bir dize oluşturur . Birleştirilmiş dize daha sonra değerlendirilir.

MATL , 6 bayt

tVthU*

Çevrimiçi deneyin!

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

zsh, 13 bayt

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

Komut satırı argümanı olarak girdi alır, STDOUT'a çıkar.

Bu sadece zsh olarak çalışır, ancak Bashecho yerine 15 bayt kullanılarak <<<:

echo $[$1$1*$1]

Perl, 11 bayt

$_*=$_ x2

+ pve lbayrakları.

(koş perl -ple '$_*=$_ x2')

Boru sayesinde -2 bayt.

Excel VBA, 35 Bayt

Alt numara ile çağrılır, msgbox cevap verir

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

Alternatif Excel VBA, 42 Bayt

Formülde verilen sayı cevap verir.

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

Lua, 20 Bayt

Bir komut satırı argümanına girer ve STDOUT aracılığıyla çıkar

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

Ve @ LeakyNun unungolfed yorumunda istedi :)

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 bayt

`+b*

Burada dene!

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

Ayrıca dize girişli 5 bayt

+bRb*
+]mbB

PHP, 25 24 bayt

Kısa açılış etiketleri şaşırtıcı derecede az sayıda golf mücadelesi için faydalıdır, neyse ki bunlardan biridir. Ne yazık ki operatör önceliği, onları çok sayıda parantez içinde yapmanız gereken sıranın tersidir.

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

düzenleme: Yine de nasıl parantez kullandığımı görünce, işlemlerin yazılı sırasını değiştirerek birleştirme operatörünü etkin bir şekilde atlayabilirim.

DC, 11 10 bayt

ddZAr^1+**

Ben biliyordum sonunda ben bir kullanım bulacağını Zkomuta!

Operasyon oldukça basittir - rakamları sayın, bu güce 10 yükseltin ve bir tane ekleyin. Bu, sayıyı kendisiyle birleştiren bir çarpan verir. Sonra sadece çarpın.

G / Ç, dc için her zamanki gibi yığını kullanır.

Tam program

Testlerde kullandığım şey buydu:

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

Ekstra iki komut bize boru hattı I / O verir.

Testler

$ 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

Teşekkürler Sir Biden XVII (1 byte) nedeniyle.

Kabakulak, 11 bayt

R I W I_I*I

Bu, Kabakulak'ın kendine has özelliklerinin çok kullanışlı olabileceği nadir golf mücadelelerinden biridir. Birincisi, tüm değişkenler dizgedir ve tüm matematik denklemleri soldan sağa (PEMDAS'ta olduğu gibi) kesinlikle değerlendirilir, bu nedenle Kabakulak'ta PEMDAS'ın yerine 9 yerine 1 + 2 * 4 = 12 olur. Yani, (zar zor) ungolfed:

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

Dikkatli bir şekilde kullanıyorum - kullandığım Kabakulak tadı (InterSystems Ensemble), stdin için vagon dönüşünü yankılamadığından, giriş ve çıkış numaraları bir araya gelecektir. Bunu düzeltmek / okunabilirliği artırmak için, iki byte eklemeniz ve böylece bir manuel CR / LF eklemeniz gerekir.

R I W !,I_I*I

Ancak, bu şartı mücadelenin kurallarında görmedim, kısa kod konusunda iyi olduğumdan eminim. Eğer hatalıysam, lütfen bana LART çekinmeyin ve cevabımı değiştiririm. :-)

PowerShell, 25 , 18 bayt

Teşekkürler TessellatingHeckler bana PS'nin boru hattını ne kadar sevdiğini hatırlattı.

Yeni 18 bayt:

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

Eski 25 bayt:

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

Açıklama:

# 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

Test (sıkıcı olarak kaydedin.ps1):

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

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

Kesinlikle kazanan cevap değil, ama ne olursa olsun eğlenceli!

Toplu, 27 20 18 bayt

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

Düzenleme: @TessellatingHeckler sayesinde 7 bayt kaydedildi. @ EʀɪᴋᴛʜᴇGᴏʟғᴇʀ sayesinde 2 bayt daha kaydedildi.