So entsteht eine uninteressante Zahl (die ich nur für diese Herausforderung völlig wettgemacht habe):

1. Nehmen Sie eine positive ganze Zahl N
2. Erstellen Sie eine neue Zahl O, indem Sie die Ziffern von N am Ende von N hinzufügen
3. Die letzte uninteressante Zahl ist O * N

Zum Beispiel für N = 12:

1. O = 1212
2. O * N = 1212 * 12
3. Die endgültige Nummer ist 14544

Eingang

Eine positive ganze Zahl N (N> 0) oder das Äquivalent Ihrer Sprache. Sie müssen keine falschen Eingaben abfangen.

Ausgabe

Die entsprechende uninteressante Nummer.

Testfälle

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

Wertung

Kürzester Code in Bytes gewinnt.

05AB1E , 3 Bytes

Ы*

Erklärt

Ð    # triplicate input
 «   # conactenate
  *  # multiply

Probieren Sie es online aus

JavaScript (ES6), 10 Byte

_=>(_+_)*_

Muss mit dem Argument als aufgerufen werden String, nicht als Number.

Verwendungszweck:

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

-3 Bytes dank @Quills Vorschlag.

Java 8, 29 26 25 21 Bytes

Gott segne 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>

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 Bytes

*s+`

Erläuterung:

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

Teste es hier .

Emacs, 17 Bytes

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

Erläuterung

• (*SPACEfügt (*an Punkt (vor der Zahl) hinzu;
• C-SPACEC-EM-Y Wähle die Nummer aus und kopiere sie.
• SPACE fügt ein Leerzeichen am Punkt (nach der Zahl) ein;
• C-YC-Y fügt die doppelte Zahl am Punkt ein;
• )fügt )am Ende hinzu;
• C-J interpretiert die Zeile als LISP-Ausdruck und gibt das Ergebnis aus.

Beispiel

Cursor dargestellt durch eine Pipe ( |)

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

Ergebnis

(* 174 174174)
30306276|

C #, 19 23 Bytes

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

Ohne Zeichenketten 47 Bytes

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

Python 2.7, 21 Bytes:

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

Nun, dies muss die kürzeste Python-Antwort sein, die ich je in kürzester Zeit geschrieben habe. Es handelt sich um eine anonyme Lambda-Funktion, die ausgeführt werden kann, indem Sie einen beliebigen Namen vergeben und sie dann wie eine normale Funktion aufrufen print(). Wenn Ihre Eingabe beispielsweise lautet 12und die Funktion benannt wurde H, würde dies so heißen print(H(12)).

Probieren Sie es online! (Ideone)

Beachten Sie, dass dies nur für Werte bis und gleich 9223372036854775807einem höheren Wert funktioniert und repr()ein Lam Ende der Ganzzahl steht. Daher ist 9223372036854775807diese 24-Byte- Version für Werte größer als die folgende:

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

Versuchen Sie dies online! (Ideone)

Gelee, 4 Bytes

;DḌ×

Probieren Sie es online aus

Erläuterung

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

Vorherige Version (48 Byte, keine mathematischen Funktionen), 16 Byte dank @LeakyNun, 1 Byte dank @FryAmTheEggman, 4 Byte dank @TobySpeight gespeichert:

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

Rufen Sie f()mit einem Argument die Nummer auf, und sie gibt die entsprechende uninteressante Nummer zurück.

Testprogramm

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

Testergebnisse:

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

Probieren Sie es online!

Dyalog APL , 7 Bytes

⊢×#⍎⍕,⍕

⍕ String-Darstellung

⍕, Zeichenfolgendarstellung voranstellen

#⍎ in Zahl umwandeln (im Root-Namespace)

⊢× multiplizieren Sie mit der ursprünglichen Zahl

J, 7 Bytes

*,~&.":

Erläuterung

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

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

Wird bei großen Eingaben etwas langsam, da das Ergebnis vor der letzten Stufe unär dargestellt wird.

Probieren Sie es online! (Die erste Zeile aktiviert eine durch Zeilenvorschub getrennte Testsuite.)

Erläuterung

Ich werde 2als Beispiel eine Eingabe verwenden (da die unären Darstellungen für größere Eingaben etwas unhandlich werden).

Stufe 1: Substitution

^
$_$*: $_

Indem ^wir den Anfang der Zeichenkette mit abgleichen, stellen wir einfach ein paar Dinge voran. $_bezieht sich auf die Eingabezeichenfolge selbst und $*:bedeutet, dass wir so viele Doppelpunkte einfügen. So bekommen wir:

:: 22

Stufe 2: Substitution

:
$_$*:

Jetzt passen wir es immer :wieder durch $_$*:. Natürlich wird diese Zeit $_nicht als Ganzzahl ausgewertet ( :: 22in unserem Beispiel jedoch als Ganzzahl ), sondern es wird $*nur nach der ersten Dezimalstelle in der Zeichenfolge gesucht. Dies ergibt die Eingabe, die mit sich selbst verknüpft ist ( Oin der Challenge-Spezifikation). Wir werden mit N*ODoppelpunkten enden , gefolgt von O:

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

Stufe 3: Spiel

:

Alles, was übrig bleibt, ist das Zählen der :s, um von unär zurück zu dezimal zu konvertieren, was genau das ist, was diese Stufe tut.

CJam , 8 Bytes

ri_`_+i*

Probieren Sie es online!

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

Gelee, 8 6 Bytes

ŒṘẋ2v×

Probieren Sie es online!

Erläuterung

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

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

Setzen Sie die Linie auf 2 von sich selbst multipliziert mit sich selbst

Brachylog , 7 Bytes

:?c:?*.

Erläuterung

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

Python, 42 Bytes

Rein rechnerisch, ohne Fäden!

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

Ideone es!

Matlab / Octave, 20 Bytes

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

Dies ist eine anonyme Funktion, die die Eingabe als Zeichenfolge verwendet.

Beispiel Verwendung:

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

Oder versuchen Sie es online mit ideone .

Erläuterung

Der Code erstellt eine Zeichenfolge, indem er die Eingabezeichenfolge zweimal verkettet, dann das Zeichen *(mit ASCII-Code 42) und dann die Zeichenfolge erneut. Die verkettete Zeichenfolge wird dann ausgewertet.

MATL , 6 Bytes

tVthU*

Probieren Sie es online!

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

zsh, 13 Bytes

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

Nimmt Eingaben als Befehlszeilenargument und gibt sie an STDOUT aus.

Dies funktioniert nur in zsh, aber hier ist 15 Bytes in Bash verwendet echostatt <<<:

echo $[$1$1*$1]

Perl, 11 Bytes

$_*=$_ x2

+ die pund lFlags.

(renn mit perl -ple '$_*=$_ x2')

-2 Bytes dank Pipe.

Excel VBA, 35 Bytes

Unter mit der Nummer angerufen, gibt msgbox Antwort zurück

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

Alternatives Excel VBA, 42 Bytes

Die in der Formel angegebene Zahl gibt die Antwort zurück.

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

Lua, 20 Bytes

Übernimmt ein Befehlszeilenargument und gibt es über STDOUT aus

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

Und ungolfed wie @LeakyNun im Kommentar gefragt :)

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 Bytes

`+b*

Probieren Sie es hier aus!

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

Auch 5 Bytes mit String-Eingaben

+bRb*
+]mbB

PHP, 25 24 Bytes

Kurze Eröffnungsmarken sind nützlich für überraschend wenige Golfherausforderungen, zum Glück ist dies eine davon. Leider ist die Rangfolge der Operatoren das Gegenteil der Reihenfolge, in der Sie sie ausführen müssen, sodass viele Klammern erforderlich sind.

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

edit: Mir ist aufgefallen, dass ich, da ich eh Klammern verwende, den Verkettungsoperator effektiv überspringen kann, indem ich die Reihenfolge der Operationen ändere.

Gleichstrom, 11-10 Bytes

ddZAr^1+**

Ich wusste, dass ich irgendwann eine Verwendung für den ZBefehl finden würde!

Die Bedienung ist recht einfach: Zählen Sie die Ziffern, nehmen Sie 10 hoch und addieren Sie eine. Dies ergibt einen Multiplikator, der die Zahl mit sich selbst verkettet. Dann multiplizieren Sie einfach.

I / O verwendet den Stack wie gewohnt für DC.

Volles Programm

Das habe ich für die Tests verwendet:

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

Die zwei zusätzlichen Befehle geben uns Pipeline-E / A.

Tests

$ 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

Dank gebührt Sir Biden XVII (1 Byte).

Mumps, 11 Bytes

R I W I_I*I

Dies ist eine der seltenen Golfherausforderungen, bei denen die Besonderheiten von Mumps sehr nützlich sein können. Erstens sind alle Variablen Zeichenfolgen, und alle mathematischen Gleichungen werden streng von links nach rechts ausgewertet (wie in: nicht PEMDAS), sodass 1 + 2 * 4 = 12 in Mumps anstelle von = 9 wie in PEMDAS. Also (kaum) ungolfed:

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

Ein Wort der Vorsicht - da die von mir verwendete Variante von Mumps (InterSystems Ensemble) nicht den Wagenrücklauf für stdin wiedergibt, werden die Eingabe- und Ausgabenummer verkettet angezeigt. Um dies zu korrigieren / die Lesbarkeit zu verbessern, müssen Sie zwei Bytes hinzufügen und ein manuelles CR / LF hinzufügen.

R I W !,I_I*I

Da ich diese Anforderung jedoch nicht in den Regeln der Challenge gesehen habe, bin ich mir ziemlich sicher, dass ich mit dem kürzeren Code gut umgehen kann. Wenn ich mich irre, wenden Sie sich bitte an LART mich und ich werde meine Antwort ändern. :-)

PowerShell, 25 , 18 Byte

Vielen Dank an TessellatingHeckler, der mich daran erinnert hat, wie sehr PS die Pipeline liebt.

Neue 18 Bytes:

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

Alte 25 Bytes:

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

Erläuterung:

# 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

Testen (als boring.ps1 speichern):

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

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

Auf keinen Fall die beste Antwort, aber trotzdem viel Spaß!

Batch, 27 20 18 Bytes

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

Bearbeiten: 7 Bytes dank @TessellatingHeckler gespeichert. Weitere 2 Bytes dank @ E 2Gᴏʟғᴇʀ gespeichert.