text:
Is it a sum-free set?
A set is sum-free if no two (not necessarily distinct) elements when added together are part of the set itself.
For example, {1, 5, 7} is sum-free, because all members are odd, and two odd numbers when added together are always even. On the other hand, {2, 4, 9, 13} is not sum-free, as either 2 + 2 = 4 or 4 + 9 = 13 add together to a member of the set.
Write a program or function that takes a set as input, and outputs a Truthy value if the set is sum-free, and Falsy otherwise.
Examples:
Sum-free:
{}
{4}
{1, 5, 7}
{16, 1, 4, 9}

Not sum-free:
{0}
{1, 4, 5, 7}
{3, 0}
{16, 1, 4, 8}

Can the set be an array/list?

@CᴏɴᴏʀO'Bʀɪᴇɴ Sure.

Related and related.

@FryAmTheEggman Except for {0}...

@FryAmTheEggman No clarification is necessary, you can logically derive that the empty set is sum free (no two elements when added together are part of the set itself, in fact, nothing is part of the set), and that any set containing one element is sum-free, except for {0}, as 0+0 is in the set.

Some more test cases might be nice!

Badly needs test cases. Are sets purely unique?

I'd be interested in your motivation for this concept. There's a related concept that you may or may not find more useful; let X denote a closure system. Call a subset A of X minimalistic iff for all proper subsets B of X, we have that cl(B) is a proper subset of cl(A). In other words, A is minimalistic iff it is minimal among those sets that generate its closure. Now make the set of natural numbers into a closure system as follows: if A is a subset of Nat, then cl(A) is the intersection of all subsets of Nat that include A and are closed under addition and 0. Question: is a subset

... of Nat is minimalistic with respect to this closure operator? Its clear that minimalistic implies sum-free. On the other hand {2,6} is an example of a sum-free set that isn't minimalistic. Here's the wikipedia link about closure systems.

is [0,1] sum free, not sum free, or undefined? (I.e.: what about repeats?)

@Titus 0+1 = 1, which is in the set, so, not sum free

@Lulhum That only applies if repeats are allowed. And that was my actual question. update: I just saw that orlp already has answered my question to FryAmTheEggman.

Can we assume the input is sorted?

@MartinEnder No. Sets are unordered without duplicates. You may take an array, tuple, etc, but not assume that it is sorted.

@orlp can you please update the question with some (lots) more test cases and clear spec and explanations about empty, length-1 and the { 0 1 } sets?

@cat The spec is clear. Examples I can add.

2+2=4 cannot be a valid addition in the set {2,4,9,13} as it has utilised two 2s. Or are duplicates allowed. And in that case {0} is sum free surely?

@george Adding the same element to itself is allowed. And {0} is not sum-free precisely for that reason: 0 + 0 = 0.

I think you should clarify that you mean the sum of two not necessarily distinct elements from the set.

Is this a NP-complete problem?

@palsch No, it's a O(n^2) simple loop.

Pyth - 8 5 bytes
Thanks to @FryAmTheEggman for saving me 3 bytes.
!@sM*

Test Suite.
!             Logical not. This makes the empty intersection true and vice versa.
 @    Q       Setwise intersection with input (implictly).
  sM          Map sum to all the pairs.
   *QQ        Get all pairs by doing cartesian product with input*input (implicit).

@FryAmTheEggman smart....

I just got the same answer, but then realized *QQ actually produces [1,1], which are two same elements, and should not appear in the map.

@busukxuan the question actually asks you to consider duplicates: 2 + 2 = 4 from OP. My answer before FryAmTheEggman's golf actually used .Combinations with replacement because of this.

@Maltysen Oh nice!

Python 2, 41 bytes
lambda s:s==s-{a+b for a in s for b in s}

s should be a Python set.
Fun fact: sum-free is an anagram of my name.

lambda s:not{a+b for a in s for b in s}&s is the same length. I can't find a way to shorten the negation, sadly.

Upvoted for anagram.

@feersum this is your question.

@FilipHaglund No, it's orlp's.

@mbomb007 If serious, yes. But, that can have a non-serious meaning: This is your question/You OWND the question/You beat everyone else here (Python). They didn't say "You are the OP."

Jelly, 5 bytes
ṗ3ḅ-P

Try it online!
How it works
ṗ3ḅ-P  Main link. Argument: A (array)

ṗ3     Take the third Cartesian power of A, i.e., generate all triplets that
       consist of elements of A.
  ḅ-   Convert each triplet from base -1 to integer.
       This maps [a, b, c] to a - b + c = (a + c) - b.
       If (a + c) belong to A, this will yield 0 for some b.
    P  Take the product of all resulting integers.

JavaScript, 86 42 41 bytes
n=>!n.some(m=>n.some(o=>n.includes(m+o)))

Thanks Cᴏɴᴏʀ O'Bʀɪᴇɴ for saving me a ton of bytes off parentheses/curly brackets. Also thanks Neil for pointing out that the function was returning the opposite boolean value than it should have.
I tried to cut down on bytes by redefining n.some but that doesn't work because it's a prototype function unfortunately. There might be a better solution with Array.prototype.map in JS but the some function is really fun.
I'm now wondering if there's a shorter way than .includes using something such as .indexOf and adding 1 (which would give it a truthy value if it contains the number).

Testing:
> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7]);
true
> (n=>!n.some(m=>n.some(o=>n.includes(m+o))))([1,5,7,12]);
false

Try n=>n.some(m=>n.some(o=>n.some(p=>m+o==p)))

@CᴏɴᴏʀO'Bʀɪᴇɴ Thanks! I had no idea I could omit the parentheses and braces.

No problem! it works because of the behaviour of the anonymous functions. Look at other ES6 answers around here, you'll learn quite a lot :)

Hello, and welcome to PPCG!

I dont know if it'll work but try: n=>(s=n.some)(m=>s(o=>s(p=>m+o==p)))

@Downgoat unfortunately, no - the .some function has to be on the Array. I tried this and got a TypeError: Array.prototype.some called on null or undefined.

The sense of this is wrong, it tells you if the set is not sum-free. Also, use n.contains(o+p) which saves you 2 bytes over the innermost some.

@Neil No idea how I missed the fact that it does the opposite, thanks for the correction. And there's no contains function in JS but there is includes which is the same and I assume is what you meant.

Sorry, yes, I meant includes (it was originally going to be called contains but some library has a conflicting definition).

Using ~n.indexOf(o+p) is equivalent to n.includes(o+p) but may lead to byte shaving in the future

MATL, 5 bytes
t&+m~

This outputs an array which is truthy if all entries are 1 and falsey otherwise. Here is a demo to show various truthy/falsey values in MATL.
Try it Online
Explanation
        % Implicitly grab input
t       % Duplicate
&+      % Compute sum of each element with every other element (2D Matrix)
m       % Check which members of the input are present in this matrix of sums
~       % Negate the result to yield a truthy value for sum-free sets
        % Implicitly display truthy/falsey value

Mathematica, 23 Bytes
{}==#⋂Tr/@#~Tuples~2&

I mistakenly edited your submission, but then rolled it back to the way it was. Sorry!

By the way, nice insight that no element had to be removed from the list before making tuples.

Please replace ∩ with ⋂ (U-22C2). The code right now isn't copypastable into Mathematica.

@LLlAMnYP Thanks, I had to manually find the unicode character since Mathematica automatically formats expressions when you copy them; I must have found the wrong one.

@ASimmons If you highlight the character in Mathematica and hit F1 it will show you the help page for that specific character which always contains the character's Unicode code point (in hexadecimal). It's really annoying though that you can't just copy it as Unicode. I think there's a solution for "copy as Unicode" somewhere on Mathematica.SE but IIRC it was far from trivial.

@MartinEnder Thanks for the advice. I did find that once but it's too complicated for me to reconstruct every time and it's usually easier to find the unicode characters than that code...

@MartinEnder There's a greasemonkey script for Firefox and a plugin for Chrome that adds buttons to the answer form in Mathematica.SE which convert things like [Alpha] in the answer box to the unicode characters. I usually paste code from Mathematica, select it and click that button to get the right Unicode characters.

@MartinEnder that tool is here.

@LLlAMnYP That looks really useful, thanks for the heads up! :)

Martin, You can copy Mathematica code as MathML.  Then paste it into your entry.  Then copy the desired character(s) from the display below and paste it into your entry.  Finally, remove the MathML code.

@DavidC the poster's comments under the specification imply that any set containing zero is not sum-free; he mentions specifically the set {0} and I believe the program above behaves as I'd expect given this interpretation!

you are correct!

Haskell, 32, 30 bytes
Simple solution:
f x=and[a+b/=c|a<-x,b<-x,c<-x]

Two bytes saved by @Lynn

f x=and[a+b/=c|a<-x,b<-x,c<-x] for 30 bytes.

J, 18 10 8 bytes
8 bytes saved thanks to miles, and 2 thanks to FrownyFrog!
-:]-.+/~

Matches the original list with the set difference of tabulated sums. This is equivalent to:
(-: (] -. +/~)) y

for input y. This translates to:
y -: (] -. +/~) y
y -: (y -. +/~ y)

+/~ returns a table of sums using y. For y =: 16 1 4 9, this gives:
   +/~ 16 1 4 9
32 17 20 25
17  2  5 10
20  5  8 13
25 10 13 18

Then, we use -., which produces a list consisting of all elements in y not in this table. If the list is sum-free, this will produce the same list. Then, -: checks for equality of lists, which produces the desired output.
Old, 18 bytes
[:-.[:>./^:_+/~e.]

+/~ creates a table of the values of the set added to itself, and e. checks if those members are in the original set. The rest of that is negating the maximal element.

-:]-.&,+/~ for 10 bytes using set difference -. and list matching -:

Ooo, very nice!

You don't need &, -. already works with cells of y.

@FrownyFrog Fascinating, TIL. Thanks!

Julia, 18 bytes
!x=x∩(x'.+x)==[]

Try it online!

Retina, 45 44 bytes
\d+
<$&$*1>
$
$`$`
M`(<1*)>.*<(1*>).*\1\2
^0

Input is a decimal list of comma-separated numbers. Output is 0 (falsy) or 1 (truthy).
Try it online! (The first line enables a linefeed-separated test suite.)
Explanation
Stage 1: Substitution
\d+
<$&$*1>

This converts all elements of the input to unary and wraps them in <...>. The purpose of the angle brackets is to distinguish a list containing only 0 from an empty list (since the unary representation of 0 is empty itself).
Stage 2: Substitution
$
$`$`

We repeat the string 3 times by append it twice at the end.
Stage 3: Match
M`(<1*)>.*<(1*>).*\1\2

We now try to find three numbers in the result such that the first two add up to the third. Those matches are counted (this doesn't actually count all such tuples, because matches cannot overlap, but if such a tuple exists it will be found). Hence, we get 0 for sum-free sets and something positive otherwise.
Stage 4: Match
^0

Since the previous stage gave the opposite of what we want, we negate the result by counting the matches of ^0 which is 1 for input 0 and 0 for everything else.

Clojure, 47 37 bytes
#(=(for[a % b % :when(%(+ a b))]a)[])

quite plain solution. uses list comprehension to find all elements which sum is equal to another element.
38 bytes variant:
#(every? nil?(for[a % b %](%(+ a b))))

Since in the challenge you are taking a set as your input, you can simply use the set to check for membership as in #(=(for[a % b % :when(%(+ a b))]a)[]) which can save 10 bytes

@miles oh wow, thanks, i did kinda ignore that fact and worked with lists.

Octave, 29 21 25 bytes
@(s)~[ismember(s,s+s') 0]

Thanks to Suever! It returns an array. I added 0 at the end to make [] become sum-free. To verify truthy and falsey in Octave, you can do this:
> f=@(s)~[ismember(s,s+s') 0]

> if f([]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([0]) "sum-free" else "not sum-free" end
ans = not sum-free

> if f([4]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([1 3]) "sum-free" else "not sum-free" end
ans = sum-free

> if f([2 4]) "sum-free" else "not sum-free" end
ans = not sum-free

An alternative that returns 0 or 1 is:
@(s)~numel(intersect(s+s',s))

You could change it to be @(s)~ismember(s+s',s) since arrays can be truthy/falsey

Ruby, 36 bytes
Constructs a cartesian product of the set against itself and finds the sum of all elements, then checks for intersection with the original set. Input is arrays, but in Ruby they have enough set operations to make it work out nicely anyways.
-1 byte over my original solution (used & instead of - and compared with []) because of inspiration from @feersum
Try it here!
->s{s-s.product(s).map{|x,y|x+y}==s}

Mathematica 63 62  42 bytes
This shorter version benefitted from A Simmons' submission. No element needs to be removed from the list before IntegerPartitions is applied.
If an element cannot be partitioned into two integers (each from the list), then IntegerPartitions[#,{2},#]=={} holds.  And checks whether this holds for every element in the list.  If so, the list is sum-free.
And@@(IntegerPartitions[#,{2},#]=={}&/@#)&

Examples
 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{2, 4, 9, 13}

False

 And@@(IntegerPartitions[#,{2},#]=={}&/@ #)&@{1, 5, 7}

True

There is a 2, but no odd numbers that differ by 2.
 And@@(IntegerPartitions[#,{2},#]=={}&/@#)&@{2, 3, 7, 11, 17, 23, 29, 37, 41, 47, 53, 59, 67, 71}

True

Do you have a defined somewhere else in your workbook? These expressions don't give the desired output when I evaluate them.

Thanks. That a should have been a #.  I corrected it and removed a superfluous @.

R, 39 36 bytes
w<-function(s)!any(outer(s,s,'+')%in%s)

Call as w(s), where s is the set (actually vector) of values. Here is the output for some test cases:
> w(numeric(0)) # The empty set
[1] TRUE
> w(0)
[1] FALSE
> w(1)
[1] TRUE
> w(c(1, 5, 7))
[1] TRUE
> w(c(2, 4, 9, 13))
[1] FALSE

Where c() is the concatenation function that takes a bunch of values and makes it a vector.
EDIT: Making it an anonymous function to save 3 bytes, thanks to @MickyT.
function(s)!any(outer(s,s,'+')%in%s)

Very nice.  You can post these as an unnamed function if you like.  That would save you 3 bytes.  eg function(s)!any(outer(s,s,'+')%in%s)

Perl 6,  24 21 20  19 bytes
{not any (@_ X+@_)X==@_}
{so all (@_ X+@_)X!==@_}
{not @_ (&)(@_ X+@_)}
{not @_∩(@_ X+@_)}

{!(@_∩(@_ X+@_))}
Input is any Positional value like a List.
( a Set is an Associative so you would have to call .keys on it. )
Test:
#! /usr/bin/env perl6
use v6.c;
use Test;

my @sum-free = (
  (),
  (4,),
  (1, 5, 7),
  (16, 1, 4, 9),
);

my @not-sum-free = (
  (0,),
  (1, 4, 5, 7),
  (3, 0),
  (16, 1, 4, 8),
);

my @tests = ( |(@sum-free X=> True), |(@not-sum-free X=> False) );

plan +@tests;

# store the lambda in lexical namespace for clarity
my &sum-free-set = {!(@_∩(@_ X+@_))}

for @tests -> $_ ( :key(@list), :value($expected) ) {
  is sum-free-set(@list), $expected, .gist
}

1..8
ok 1 - () => True
ok 2 - (4) => True
ok 3 - (1 5 7) => True
ok 4 - (16 1 4 9) => True
ok 5 - (0) => False
ok 6 - (1 4 5 7) => False
ok 7 - (3 0) => False
ok 8 - (16 1 4 8) => False

Racket, 58 bytes
(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))

Explanation:
(λ(l)(andmap(λ(m)(andmap(λ(n)(not(memq(+ n m)l)))l))l))
(λ(l)                                                 ) # Define a lambda function that takes in one parameter
     (andmap(λ(m)                                  )l)  # If for all m in l
                 (andmap(λ(n)                   )l)     # If for all n in l
                             (not(memq(+ n m)l))        # n + m is not in l

05AB1E, 9 5 bytes
Saved 4 bytes thanks to Magic Octopus Urn
ãOå_P

Try it online!
Explanation
ã       # cartesian product
 O      # sum
  å     # check each if it exists in input
   _    # logical negation
    P   # product

Is 0 really truthy in 05AB1E?

@Dennis I defined 0 as truthy for this challenge and anything else as falsy. Isn't that normally OK as long as it is unambiguous and OP hasn't specified a specific format?

This is our default interpretation of truthy/falsy.

@Dennis: Ah, too bad. sum-free = 0 and non-sum-free = "a sum" fitted nicely to the challenge imo. Seen a lot of other challenges which defined sums and similar non-standard values as true/false so I figured un-ambiguity was the default. I'll edit the answer then. Thanks for the heads up.

Try it online! is 5 bytes ãOåZ_ unless (as per usual) I missed something. I don't think you need the loop or the 2 (2 is default on lists). ãv¹yOåO_ for 1 byte less is definitely fine if the 5 byte is somehow wrong.

@MagicOctopusUrn: Thanks! Unsure if these commands worked this way back then, but they do now so thanks :) (I could just have missed it as well, I was pretty new to 05AB1E when I did this challenge)

Oh, didn't realize how old this is. Whoops!

Brachylog, 13 bytes
'(p:?+L:?x'L)

Explanation
'(          )  True if what's in the parentheses is impossible, false otherwise
  p            Get a permutation of Input
   :?+L        L is the list of element-wise sums of the permutation with Input
       :?x'L   There is at least one element of Input in L

Is [2:2] a subset of 2 elements of [2:4:9]?

@LeakyNun No, because 2 only appears once in [2:4:9].

Python, 40 bytes
lambda s:s^{a+b for a in s for b in s}>s

^ = symmetric difference, new set with elements in either sets but not both
> True if the left set is a superset of the right set.

This doesn't work for the empty set, though I don't know if that's required.

Well, wikipedia says (among other things) that  A is sum-free if the equation a + b = c has no solution with a, b, c ∈ A. With this definition, the empty set is not sum free, and my answer is correct. But I may be biased.

That definition implies that the empty set is sum-free, as there are no a, b and c in the empty set that satisfy the equation. The OP's newly added test cases support this.

APL, 8 bytes
⊢≡⊢~∘.+⍨

Explanation:
⊢         argument
 ≡        equals
  ⊢       argument
   ~      without
    ∘.+⍨  sums of its elements

Test:
      ( ⊢≡⊢~∘.+⍨ ) ¨ (1 5 7)(2 4 9 13)
1 0

Haskell, 30 bytes
f s=and[x+y/=z|x<-s,y<-s,z<-s]

I think there exists a shorter solution that's more interesting, but I haven't found it.
These are 33 and 34 bytes:
f s=and$((/=)<$>s<*>)$(+)<$>s<*>s
f s|q<-((-)<$>s<*>)=all(/=0)$q$q$s

does using elem on s and getting rid of the last part of the comprehsion work?

@Maltysen If you mean f s=and[notElem(x+y)s|x<-s,y<-s], that's 32. There's also f s=all(`notElem`s)$(+)<$>s<*>s for 31.

Actually, 7 bytes
;;∙♂Σ∩Y

Try it online!
;;∙♂Σ∩Y              Stack: [1,5,7]
;         duplicate         [1,5,7] [1,5,7]
 ;        duplicate         [1,5,7] [1,5,7] [1,5,7]
  ∙       cartesian product [1,5,7] [[1,1],[1,5],[1,7],[5,1],[5,5],[5,7],[7,1],[7,5],[7,7]]
   ♂Σ     sum each          [1,5,7] [2,6,8,6,10,12,8,12,14]
     ∩    intersect         []
      Y   negate            1

Maybe make your code more gender-equal? (♂)

Java, 67 bytes
s->!s.stream().anyMatch(p->s.stream().anyMatch(q->s.contains(p+q)))

Input is a Set<Integer>. Tests:
import java.util.Arrays;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

public class SumFree {
    public static void main(String[] args) {
        sumFree(s->!s.stream()
            .anyMatch(p->s.stream()
                .anyMatch(q->s.contains(p+q)))); // formatted to avoid wrapping
    }

    public static void sumFree(Function<Set<Integer>, Boolean> func) {
        test(func);
        test(func, 4);
        test(func, 1, 5, 7);
        test(func, 16, 1, 4, 9);
        test(func, 1, 4, 5, 7);
        test(func, 0);
        test(func, 3, 0);
        test(func, 16, 1, 4, 8);
    }

    public static void test(Function<Set<Integer>, Boolean> func, Integer... vals) {
        Set<Integer> set = Arrays.stream(vals).collect(Collectors.toSet());
        System.out.format("%b %s%n", func.apply(set), set);
    }
}

Output:
true []
true [4]
true [1, 5, 7]
true [16, 1, 4, 9]
false [0]
false [1, 4, 5, 7]
false [0, 3]
false [16, 1, 4, 8]

Vyxal, 30 bits1, 3.75 bytes
ẊṠ↔¬

Try it Online!
Ẋ    # cartesian product with itself
 Ṡ   # vectorized sums
  ↔  # intersection of this with the input
   ¬ # logical NOT

If inverted truthiness is allowed, the ¬ can be removed for 2.875 bytes, but the challenge specifically states "outputs a Truthy value if the set is sum-free, and Falsy otherwise."

PHP, 73 bytes
+8 to turn the snippet into a program, -8 on obsolete variables thanks to insertusernamehere
<?foreach($argv as$p)foreach($argv as$q)if(in_array($p+$q,$argv))die;echo 1;

prints 1 for true, empty output for false
usage: php <filename> <value1> <value2> ...
qualified function for testing (94 86): returns 1 or nothing
function f($a){foreach($a as$p)foreach($a as$q)if(in_array($p+$q,$a))return;return 1;}

tests
function out($a){if(!is_array($a))return$a;$r=[];foreach($a as$v)$r[]=out($v);return'['.join(',',$r).']';}
function cmp($a,$b){if(is_numeric($a)&&is_numeric($b))return 1e-2<abs($a-$b);if(is_array($a)&&is_array($b)&&count($a)==count($b)){foreach($a as $v){$w = array_shift($b);if(cmp($v,$w))return true;}return false;}return strcmp($a,$b);}
function test($x,$e,$y){static $h='<table border=1><tr><th>input</th><th>output</th><th>expected</th><th>ok?</th></tr>';echo"$h<tr><td>",out($x),'</td><td>',out($y),'</td><td>',out($e),'</td><td>',cmp($e,$y)?'N':'Y',"</td></tr>";$h='';}
$samples = [
    [], 1,
    [0], false,
    [1], 1,
    [0,1], false,
    [2, 4, 9, 13], false,
    [1,5,7], 1
];
while($samples)
{
    $a=array_shift($samples);
    $e=array_shift($samples);
    test($a,$e,f($a));
}

As you never use $i and $j you can discard $i=> as well as $j=> and save 8 bytes. Unfortunately code snippets are not valid answers. Make it a function or a full program and include that in your byte count and you're ready to go. :)

TSQL, 47 bytes
CREATE table T(a int)
INSERT T values(1),(5),(7),(12)

SELECT min(iif(a.a+b.a<>T.a,1,0))FROM T a,T b,T

Note: This will only run once, then the table needs to be deleted or dropped to run again. The fiddle editor doesn't allow creation of tables. Therefore the fiddle included in my answer uses 2 extra bytes to compensate for this - the fiddle version doesn't require cleanup.
Fiddle

Perl, 46 bytes
45 bytes code + 1 byte command line (-p)
$_="$_ $_ $_"!~/(\b\d++.*)((?1))(??{$1+$2})/

Uses a single regex match with Perl's support for 'code expressions' inside the regex to allow for evaluation within a match.
To get around the requirement that the input is unsorted, we repeat the input string three times. This guarantees that the result is after the two operands, and allows the same digit to be matched again (e.g. in the case of input 2 4).
Usage example:
echo "3 5 6 8" | perl -p entry.pl

Factor, 47 bytes
[ dup dup 2array [ Σ ] product-map ∩ { } = ]

∩ { } = is equivalent to but shorter than intersects?.
Σ is shorter than but equivalent to sum.

Thanks, math.unicode!
testing code:
USING: arrays kernel math.unicode sequences sequences.product ;
IN: sum-free

: sum-free? ( seq -- ? )
  dup dup 2array [ Σ ] product-map ∩ { } = ;

USING: tools.test sum-free ;
IN: sum-free.tests

{ t } [ { 5 7 9 } sum-free? ] unit-test
{ f } [ { 2 4 9 13 } sum-free? ] unit-test
{ t } [ { } sum-free? ] unit-test
{ f } [ { 0 } sum-free? ] unit-test
{ t } [ { 1 } sum-free? ] unit-test
{ f } [ { 0 1 } sum-free? ] unit-test

I'm only confident the first two are correct. It's unclear from the question what the rest should be, so I think it's fine for now.

Clojure, 34 bytes
#(not-any? %(for[i % j %](+ i j)))

I wrote this before noticing the earlier Clojure solution. Anyway, this one is more compact as it uses the input set as a pred function for not-any?.

05AB1E, 6 4 bytes
âOмQ

Try it online or verify all test cases.
Explanation:
â       # Take all pairs of the input-list
        #  i.e. [1,5,7] → [[1,1],[1,5],[1,7],[5,1],[5,5],[5,7],[7,1],[7,5],[7,7]]
        #  i.e. [1,4,5] → [[1,1],[1,4],[1,5],[4,1],[4,4],[4,5],[5,1],[5,4],[5,5]]
 O      # Sum all pairs
        #  i.e. [[1,1],[1,5],[1,7],[5,1],[5,5],[5,7],[7,1],[7,5],[7,7]]
        #    → [2,6,8,6,10,12,8,12,14]
        #  i.e. [[1,1],[1,4],[1,5],[4,1],[4,4],[4,5],[5,1],[5,4],[5,5]]
        #    → [2,5,6,5,8,9,6,9,10]
  м     # Remove all values in the input-list that are also in the list above
        #  i.e. [1,5,7] and [2,6,8,6,10,12,8,12,14] → ['1','5','7']
        #  i.e. [1,4,5] and [2,5,6,5,8,9,6,9,10] → ['1','4','']
   Q    # Is the current list still equal to the input-list?
        #  i.e. [1,5,7] and ['1','5','7'] → 1
        #  i.e. [1,4,5] and ['1','4',''] → 0

Prolog (SWI), 66 56 49 bytes
A/B:-member(A,B).
-L:- \+ (E/L,F/L,G is E+F,G/L).

Try it online!

Husk, 8 7 6 bytes
¬Sn´×+

Try it online!
-1 byte from Zgarb.
Same method as the Pyth solution.
Explanation
¬Sn´×+ implicit input
   ´   double: ´ f x = f x x
    ×+ map sum to all pairs
 S     hook: S f g x = f x (g x)
  n    intersection of sums with input
¬      negate

You can use × instead of ΣṪ.

@Zgarb added it in..

Scala 3, 52 37 bytes
Saved 15 bytes using lambda function.

s=>s==s.diff(for{a<-s;b<-s}yield a+b)

Attempt This Online!

Why not make it a lambda? Would save a few bytes

Thunno 2 !, 3 bytes
Ṗʂȯ

Try it online!
Explanation
Ṗʂȯ  # Implicit input
Ṗ    # Cartesian product
 ʂ   # Sum each
  ȯ  # Set intersection
     # Logical NOT
     # Implicit output

PowerShell 50 bytes
param($a)$a|%{$b=$_;$a|%{if($b+$_-in$a){1;break}}}

Where 1 is true and no output is false.
Though, if outputting multiple truthy values is allowed, then I could save 6 bytes:
param($a)$a|%{$b=$_;$a|%{if($b+$_-in$a){1}}}

But I will wordsmith myself and agree that the OP asked for 'a Truthy value'
Explanation:
param($a)$a|%{$b=$_;$a|%{if($b+$_-in$a){1;break}}}
param($a)                                          # assigns first passed parameter to variable $a
         $a|${                                   } # foreach $_ in $a
              $b=$_;                               # assign $_ to $b for access from further down the pipe
                    $a|%{                       }  # foreach $_ in $a
                         if($b+$_-in$a){       }   # if $a contains the value $b+$_
                                        1;         # implicit output of 1 (true)
                                          break    # exit the loops

Japt -!, 9 bytes
ø¡UË+XÃÃc

Try it online!
Unpacked & How it works
UøUmX{UmD{D+X} } c

Uø  Does the input array have any common element with...
UmX{  the input array mapped with...
UmD{    the input array mapped with...
D+X       sum of the two elements
}
}
c     ... flattened

The result is the opposite of what is requested, so -! flag is used to flip true and false.

7 bytes: øUc@m+X

Cjam, 10 bytes
__m*::+&!!

Not very golfed. If someone can help me shave off more bytes, please help!
Explanation:
__         Duplicate the list twice
  m*       Take the Cartesian Product of the two
    ::+    For every item in the list (which is a list in this case), sum the elements
       &   Take the intersection with the original list
        !! Logical-not twice; take the "truthness" of the value

Japt -!, 4 bytes
øUï+

Try it here

Arturo, 37 bytes
$->a->¬some? a'x->some? a=>[in?+x&a]

Try it

[Matlab] 38 bytes
assuming a is the input array (in form of a=[1 3 5]
sum(sum(ismember(diff(perms(a)),a)))>0

Nekomata + -e, 5 bytes
ᵒ+j∕=

Attempt This Online!
ᵒ+       Addition table
  j      Flatten
   ∕     Set minus
    =    Check equality

JavaScript (V8), 41 bytes
f=(x,p,q)=>x.every(t=>1/q?p+q-t:f(x,t,p))

Try it online!

C (clang), 66 bytes
i;f(*a,n,*r){*r=1;for(i=n*n*n;i--;)*r&=a[i/n%n]+a[i%n]!=a[i/n/n];}

Try it online!


text:
No Quine Built In? No Problem!
Are you tired of languages with built in quining techniques?
Your challenge, should you choose to accept it, is to add a built-in quine feature to the language of your choice.
Task
Given some programming language X, you should define

A language X′ that is a subset of X.
A quine command string Q.  (This is a string of your choice; it need not literally be “Q”.)

Now you have a new language Y, consisting of programs that are in X′ except that they may also contain copies of Q as if Q were a new built-in statement or function.  Your job is to implement this language Y, by writing

A compiler, written in X′, producing an output program B in X for each input program A in Y.

When B is run, it should behave like A would if all its copies of Q had been replaced with a statement in X that prints the source code of B.
You’ve therefore created a language Y that contains a quining builtin Q.
Rules

Your chosen language subset X′ must still satisfy the definition of a programming language.
The output programs B of your compiler must be proper quines.  You may not use quining builtins that may already be in X.
This is code golf, so the shortest code in bytes (defined as your language's default native encoding) wins.

What if the language has a builtin quine command, but we designate a different string as a new quine command?

It seems dubious, but what language do you have in mind?

Languages like Jolf, Actually, etc.

Is it clear what I am asking?

Yes, it is, for the most part

Ok, Thanks, I feel like an esolang like that with a built in quine may not be in the spirit of the challenge. A simple implementation would just find and replace the string for a new quine command into the old one. That being said if the implementation of such a thing is not too trivial I would accept it. Feel free to write one up, and message it to me and I can take a look.

@CᴏɴᴏʀO'Bʀɪᴇɴ Upon further review I have decided that you are permitted to define a new quine character, except the new quine operator must be implemented without use of the old one.

Is a quine flag cheating?

I would say yes

Totally confused, can you define it in terms of functions? i.e. if a quinine is (Compile(Source))() = Source what are you after?

The Q comand should output the compiled program

"... the compiled source of language Y" doesn't even make sense. I'm not sure whether the edited explanation is worse than the previous one, but it's certainly still far from clear.

I slightly tweaked it again. I however feel that while the challenge is hard to understand it certainly is doable as there are two answers to this question. @Peter Taylor

In that case maybe you can enlist the aid of Anders to write a clear spec - although I'm not convinced that he's understood what you want either. At least his CJam program doesn't behave as I would expect.

This got less clear with recent edits. The problem as I understand it is as follows. Given some programming language X, you are to define (1) a quine command string Q; (2) a language X′ that is a subset of X; (3) a compiler, written in X′, and producing an output program B in X for any input program A that is in X′ except in that A may also contain copies of Q. When B is run, it should behave like A would if all its copies of Q had been replaced with a statement in X that prints the source code of B. We’ve thus created a language Y (X′ augmented with Q) that contains a quining builtin Q.

@RohanJhunjhunwala, does that match your intention? If so you are welcome to edit it into the question, or I can.

@Anders Kaesorg yes that matches my intention

Is it now clear enough?

@RohanJhunjhunwala Since one can hide a fair amount of logic within the quine command string, this might be more interesting if the score were something like the sum of the length of the compiler and the length of the quine command string, rather than just the length of the compiler—what do you think?

yes if this question gets off of hold I would consider that. Do you think it deserves to be taken off of hold?

@RohanJhunjhunwala It’s on hold because people thought it was unclear, but I think the new wording will satisfy them. I voted to reopen.

@busukxuan are the new rule clarifications more accepatable and clear enough to warrant reopening?

@Connor O' Brien are the new rules more appropriate? I am interested in reopening this question

CJam, 7 bytes
qp":Q~"

The quine command string is Qp":Q~"o.  The language subset is programs that do not use the variable Q except as part of the quine command string.
Demo
Input program:
"I am a quine and my source is:
"oQp":Q~"o"
Have a nice day."o

Try it online
Output program:
"\"I am a quine and my source is:
\"oQp\":Q~\"o\"
Have a nice day.\"o"
:Q~

Try it online
Output of output program:
I am a quine and my source is:
"\"I am a quine and my source is:
\"oQp\":Q~\"o\"
Have a nice day.\"o"
:Q~
Have a nice day.

See comments on question: if you understand what OP is asking, perhaps you can edit the question to make it intelligible for the rest of us. Although note that I can't find any interpretation of the question which makes this answer correct: if I pass 1Q to your cross-compiler, the output is a program which prints 11Q, and I don't think "output" in the context of a full program can validly be interpreted as "place on the stack".

@PeterTaylor The quine command string I defined is Qp":Q~"o, not Q. 1Q is not valid in my defined language subset, because it uses the variable Q in a way that’s not part of the quine command string Qp":Q~"o.
If you pass 1Qp":Q~"o to the compiler, then as requested, you will get a program that pushes 1 onto the stack, then outputs its own source, then implicitly outputs the contents of the stack.

Java "only" 498 Bytes
The following java program takes in input as command line arguments.
class Q{
public static void main(String[]a){
System.out.println(a[0]);System.out.print("static char[]s={");a[2]+="}static void q(){System.out.print(\""+a[0]+"\\n\");System.out.print(\"static char[]s={\");for(char c:s)System.out.print((int) c+\",\");System.out.print(\"\\b};\\n"+a[1]+"\\n\");for(char c:s)System.out.print(c);System.out.print(\"\\n}\");}";for(char c:a[2].toCharArray())System.out.print((int) c+",");System.out.println("\b};");System.out.println(a[1]);System.out.print(a[2]+"\n}");
}}

In this case my language "X" is (a subset of) Java, and my Quine Command string "Q" is q();for each instance of q(); the output program will print its source. Input is restricted to only four lines, and any more or less results in undefined behavior. My golfed program technically follows these same restrictions. So my subset is programs that fit on four lines as shown and do not have a function called q or use any variable named s.
Sample Input
class sampleInput{//class def on this line
public static void main(String[]argument){//method header here and optional code although avoid putting code here
System.out.println("Hello World Of Quines");q();System.out.println("\n------------");q();/*Avoid comments on this line unless you use this format YOU MUST! put two braces on the next line*/
}}

Sample Output
class sampleInput{//class def on this line
static char[]s={83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,108,110,40,34,72,101,108,108,111,32,87,111,114,108,100,32,79,102,32,81,117,105,110,101,115,34,41,59,113,40,41,59,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,108,110,40,34,92,110,45,45,45,45,45,45,45,45,45,45,45,45,34,41,59,113,40,41,59,47,42,65,118,111,105,100,32,99,111,109,109,101,110,116,115,32,111,110,32,116,104,105,115,32,108,105,110,101,32,117,110,108,101,115,115,32,121,111,117,32,117,115,101,32,116,104,105,115,32,102,111,114,109,97,116,32,112,117,116,32,116,119,111,32,98,114,97,99,101,115,32,111,110,32,116,104,101,32,110,101,120,116,32,108,105,110,101,42,47,125,115,116,97,116,105,99,32,118,111,105,100,32,113,40,41,123,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,34,99,108,97,115,115,32,115,97,109,112,108,101,73,110,112,117,116,123,47,47,99,108,97,115,115,32,100,101,102,32,111,110,32,116,104,105,115,32,108,105,110,101,92,110,34,41,59,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,34,115,116,97,116,105,99,32,99,104,97,114,91,93,115,61,123,34,41,59,102,111,114,40,99,104,97,114,32,99,58,115,41,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,40,105,110,116,41,32,99,43,34,44,34,41,59,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,34,92,98,125,59,92,110,112,117,98,108,105,99,32,115,116,97,116,105,99,32,118,111,105,100,32,109,97,105,110,40,83,116,114,105,110,103,91,93,97,114,103,117,109,101,110,116,41,123,47,47,109,101,116,104,111,100,32,104,101,97,100,101,114,32,104,101,114,101,32,97,110,100,32,111,112,116,105,111,110,97,108,32,99,111,100,101,32,97,108,116,104,111,117,103,104,32,97,118,111,105,100,32,112,117,116,116,105,110,103,32,99,111,100,101,32,104,101,114,101,92,110,34,41,59,102,111,114,40,99,104,97,114,32,99,58,115,41,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,99,41,59,83,121,115,116,101,109,46,111,117,116,46,112,114,105,110,116,40,34,92,110,125,34,41,59,125};
public static void main(String[]argument){//method header here and optional code although avoid putting code here
System.out.println("Hello World Of Quines");q();System.out.println("\n------------");q();/*Avoid comments on this line unless you use this format put two braces on the next line*/}static void q(){System.out.print("class sampleInput{//class def on this line\n");System.out.print("static char[]s={");for(char c:s)System.out.print((int) c+",");System.out.print("\b};\npublic static void main(String[]argument){//method header here and optional code although avoid putting code here\n");for(char c:s)System.out.print(c);System.out.print("\n}");}
}

Haskell, 35 bytes
main=interact(\s->s++"q="++show s)

Includes a trailing newline.  The quine command string is (putStr$q++"q="++show q).  The language subset is programs with a trailing newline that do not use the variable q except as part of the quine command string.
Demo
Input program:
main = do
  putStrLn "I am a quine and my source is:"
  (putStr$q++"q="++show q)
  putStrLn "\nHave a nice day."

Output program:
main = do
  putStrLn "I am a quine and my source is:"
  (putStr$q++"q="++show q)
  putStrLn "\nHave a nice day."
q="main = do\n  putStrLn \"I am a quine and my source is:\"\n  (putStr$q++\"q=\"++show q)\n  putStrLn \"\\nHave a nice day.\"\n"

Output of output program:
I am a quine and my source is:
main = do
  putStrLn "I am a quine and my source is:"
  (putStr$q++"q="++show q)
  putStrLn "\nHave a nice day."
q="main = do\n  putStrLn \"I am a quine and my source is:\"\n  (putStr$q++\"q=\"++show q)\n  putStrLn \"\\nHave a nice day.\"\n"
Have a nice day.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
Print a bunch of uninteresting numbers!
An uninteresting number (which I totally didn't make up only for this challenge) is created like this:

Take a positive integer N
Create a new number O by adding the digits of N at the end of N
The final uninteresting number is O*N

For example for N=12:

O = 1212
O*N = 1212 * 12
Final number is 14544

Input
A positive integer N (N > 0) or your language's equivalent. You don't have to catch incorrect input.
Output
The corresponding uninteresting number.
Test cases
  1 -> 11
  2 -> 44
  3 -> 99
 10 -> 10100
174 -> 30306276

Scoring
Shortest Code in Bytes wins.

Does this mean that floats more than zero are also valid inputs? Or are only integers valid?

R.Kap: No, only whole numbers. Everything else would need a lot of specification. :)

Both positive and negative? Or only positive?

No, only positive.

@R.Kap can be anything as long as it's > 0 :p

There must be a relevant OEIS entry...

@MKII Can be described as 11n^2 for 1-digit-numbers. Otherwise no.

@MKII Sadly, no there is not.

@Seims It was a joke, based on the "uninsteresting" name

@MKII my bad, i don't speak joke

Is taking the number as a string argument bending the rules a bit too much?

^^  I was just about to ask the same

Go ahead, bend the rules! :P

For those who didn't understand my post: https://en.wikipedia.org/wiki/Interesting_number_paradox

@MKII I checked there isn't :(

This reminds me of the proof that there are no non-interesting natural numbers.  By counterexample, suppose there are some non-interesting natural numbers.  Let n be the least of those.  Then n is the smallest non-interesting natural number, which is interesting.  Thus n is not non-interesting, which is a contradiction.  Thus, there are no non-interesting natural numbers.

Could we take input as a unit type which coerces to an integer?

Never mind, someone already posted exactly what I had in mind, good job @DomHastings

@JoshuaTaylor only if non-interesting is defined that specific way. you could just define it so it doesn't lead to a paradox :P

05AB1E, 3 bytes
Ð«*

Explained
Ð    # triplicate input
 «   # conactenate
  *  # multiply

Try it online

Ahh, nice! Ninja'd me by seconds :p.

@Adnan Hehe. Revenge for that time you did it to me :P

@Emigna Nice job! Didn't think this could be THIS short.

3 operations, 3 bytes, I don't think you could make it any shorter than that.

@youtubefreak It seems unlikely. If a language by default takes the same input multiple times if no more input exist it would be possible with a 2 byte solution, assuming it had 1 byte operations for concat and multiplication as well as the possibility to interpret datatypes correctly for those types.

Wait... So concatenate works for int? Cool!

@busukxuan Yep. Concatenate automatically converts the number to str and * interprets the string as a number. Very useful :)

@Emigna So pyth loses because it overloads too much lol

@busukxuan Yeah, a combination of Pyth and 05AB1E could have done it in 2 bytes :)

What encoding does 05AB1E use?

@AshBurlaczenko 05AB1E uses the CP-1252 encoding.

JavaScript (ES6), 10 bytes
_=>(_+_)*_

Needs to be called with the argument as a String, not a Number.
Usage:
(_=>(_+_)*_)('3')
99

-3 bytes thanks to @Quill's suggestion.

If you can pass the parameter as a string you can cut two bytes off this solution: _=>(_+_)*+_

How exactly does this work? If I understand correctly, are you using _ as an arbitrary character for a variable? (PS - (_+_) totally looks like a butt)

@charredgrass $ would also work

@charredgrass the => defines a function with _ as the named argument. So I could have used $ (as @cat said) or a letter, but in my original version I was going for more ASCII art than anything else!

type casting abuse eleven

Out of interest, the best I could do purely mathematically was 30 bytes in ES7 n=>(1+10**-~Math.log10(n))*n*n (sadly -~ have higher precedence than **) or 31 in ES6 n=>-~\1e${-~Math.log10(n)}`nn. Even recursion took me 32 bytes: f=(n,m=1)=>n<m?-~mnn:f(n,m*10)`

Java 8, 29 26 25 21  Bytes
God bless lambda
c->new Long(c+""+c)*c

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

You gotta love Java; even with lambdas of Java 8 and one of the shortest Java answers ever here on codegolf, it's still outgolfed by all other current answers. xD

java is bae, lambda is bae

@KevinCruijssen i still have a hope, one day java will win codegolf contest

After your edit you outgolfed @MartinEnder with his Retina answer by 1 byte! o.Ô

@KevinCruijssen but still not enough to win or at least beat python:(

Why not Int.decode?

Also, do you need the semicolon?

@DavidConrad I'm not sure, do i need it?

This is not a valid Java program. It doesn't compile.

@pts you are correct, this is not a java program, it is single java function written using lambda notation.

I'm not completely sure, but I've submitted an answer before where I didn't include the semicolon on the rationale that the lambda could be passed to a method taking (in this case) a Function<Int, Int> parameter, in which case it wouldn't be immediately followed by a semicolon. (Sorry to not check back and reply sooner.) http://codegolf.stackexchange.com/a/84991/794

Aaaah! Except I had a complete brain fart and led you astray when I suggested Int.decode. Of course it's Integer.decode, and Long.decode is shorter. But I really don't think you need to count the semicolon. Anyway, sorry!

@DavidConrad hmm... if i don't need semicolon, can reduce some of my other java 8 solutions, thanks for tip:) and about your Int suggestion. i feel like idiot, i update it without thinking about it, or checking:) reason why i used long in first place was to avoid using Integer, but thanks anyway

Yeah, I feel like an idiot, too. I've been using some other languages recently, like Scala, where there is a capital-I Int type, although even there you have to write Integer.decode.

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

11 what? bytes?

@Insane Bytes if you call it from the command line, keystrokes if you do it directly from vim. I usually omit the unit from my vim answers because it can be either one.

http://v.tryitonline.net/#code=QxI9EiISIioSIgo&input=MTI To bad <C-r> is unprintable.

Is <C-r> a carriage return?

@CaptainMan No, <C-r> is control plus r. Carriage return is <cr>.

Pyth, 5 4 bytes
*s+`

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

Test it here.

Emacs, 17 bytes
(*SPACEC-SPACEC-EM-YSPACEC-YC-Y)C-J
Explanation

(*SPACE adds (*  at point (before the number);
C-SPACEC-EM-Y Select and copy the number;
SPACE adds a space character at point (after the number);
C-YC-Y pastes two times the number at point;
) adds ) at the end;
C-J interprets the line as a LISP expression and prints its result.

Exemple
Cursor represented by a pipe (|)

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

Result
(* 174 174174)
30306276|

Hi, and welcome to PPCG! Nice first post!

Python 2.7, 21 bytes:
lambda f:int(`f`*2)*f

Well, this has to be the shortest Python answer I have ever written in the shortest amount of time ever. It's an anonymous lambda function that can be executed by naming it anything you want and then calling it like a normal function wrapped in print(). For instance, if your input is 12, and the function was named H, this this would be called like print(H(12)).
Try It Online! (Ideone)
Note that this only works for values up and equal to 9223372036854775807 since any higher value and repr() puts a L at the end of the integer. Therefore, for values greater than 9223372036854775807, this 24 byte version would be the one that works:
lambda f:int(str(f)*2)*f

Try This Online! (Ideone)

I still find Phytons String operations magical...

@Seims in what way?

String multiplication and addition. Haven't seen that often.

@Seims I guess you mostly deal with static languages then?

@busukxuan Call me a noob if you want :^)

@Seims Nah, more likely I'm the noob here :P Anyway this is almost gonna become a chat so I guess we stop here xD

It should be noted that this only works for values up to 9223372036854775807, since any higher and repr(f) would have an L at the end. See example.

@mbomb007 I see. Well then, in that case, lambda f:int(str(f)*2)*f seems to be the best choice for numbers higher than that.

It's sad that a third of this answer is Python's verbose lambda syntax

C#, 19 23 bytes
n=>int.Parse(""+n+n)*n;

Without strings, 47 bytes
n=>{int i=1;while(i<=n)i*=10;return(i+1)*n*n;};

This is a snippet, not a full program or function. It would be valid with e.g. (n)=>{int.Parse(""+n+n)*n}2

@cat better? do I need the trailing ;?

I don't know. See also Defaults for Code Golf and Tips for golfing in C#

Jelly, 4 Bytes
;DḌ×

Try it online
Explanation
;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

It's a really happy winking face with a goatee! ;DDx

In which encoding does Ḍ take only 1 byte? Usually we use UTF-8, in which it takes 3 (and the × takes 2, but it is 1 byte in e.g. ISO8859-1).

@o11c Jelly uses its own custom code page where these characters are one byte each.

J, 7 bytes
*,~&.":

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

+1. I couldn't even think that Under is working properly with string concatenation. What a great discovery for me! Thank you.

Sadly, I think this should be in parenthesis, since it's a hook that is not working if typed directly * ,~ &.": n, and can't be used in formation of other verbs either.

@dahnoak Here at PPCG, we only have to specify what is needed for a function, and so the above is all that is necessary to create a function in J. Then to invoke it using some input as an argument, it will either be in parentheses or stored in a variable.

Ah, I got this, ty.

C, 70 68 54 53 52 44
f(n){return(pow(10,(int)log10(n)+1)*n+n)*n;}

Previous version (48 bytes, no math functions), saved 16 bytes thanks to @LeakyNun, 1 byte thanks to @FryAmTheEggman, 4 bytes thanks to @TobySpeight:
f(n,d,i){for(i=d=n;d;d/=10)i*=10;return(i+n)*n;}

Call f() with one argument, the number, and it returns the corresponding uninteresting number.
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 results:
$ ./84712 1 2 3 4 10 174
1 -> 11
2 -> 44
3 -> 99
4 -> 176
10 -> 10100
174 -> 30306276

Try it online!

f(n){int b=1;while(a)b*=10,a/=10;return(n+n*b)*n;}

This shouldn't work properly without including math.h, but you get away with it in GCC, where log10() and pow() are built-in, and the compiler merely warns about "incompatible implicit declaration of built-in function" rather than assuming (as it should) that they both return int.

@Leaky - you didn't put anything into a...

It's nice to see another answer that stays entirely within the arithmetic world (not doing string concatenation).  :-)

@Toby - String concatenation in C is incompatible with golfing. ;-)

43 bytes: i;f(n){return(pow(10,i=log10(n)+1)*n+n)*n;}

CJam, 8 bytes
ri_`_+i*

Try it 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

I was about to suggest not converting to in then immediately back to string but the naive approach (i.e. having never used CJam before) is r__+i\i*, which is the same length.

@QPaysTaxes Ah nice. I noticed the same thing as you: why first convert it to int and then back to string again. I also never used CJam and didn't really look close enough at all the possible operators, so I was unable to find a solution on first glance. Thanks for sharing your approach without converting it back to string, even though it's the same byte-length.

If there was a way to apply an operation to the whole stack in two bytes, it would be a byte shorter (something like r__+si*, where s is "apply this operation over the stack"), but I don't see anything like that

Dyalog APL, 7 bytes
⊢×#⍎⍕,⍕

⍕ string representation
⍕, prepend string representation
#⍎ make into number (in root namespace)
⊢× multiply by original number

Those wrecked TIE fighters are funny!

@LuisMendo http://www.dyalog.com/blog/2015/12/apl-puns/

The fork awakens :-D

I'm pretty sure those aren't bytes in any encoding, since they're not letterlike or very common.

@o11c Did you check out the preemptive link for the word "bytes", viz. http://meta.codegolf.stackexchange.com/a/9429/43319.

@Adám So languages can just make up new character sets, that no one can verify easily since they're not part of the standard iconv tables?

@o11c They can make up new codepages, but they must be well-defined before challenge-submission. See an example here of someone about to do just that. And here is an example of someone who already did it.

@o11c The character set doesn't really matter - it's just a way to represent the bytes. The sequence of bytes is the part that matters for us, since everything is scored in bytes.

Retina, 27 20 bytes
^
$_$*: $_
:
$_$*:
:

Gets a bit slow for large inputs, because before the last the stage the result is represented in unary.
Try it online! (The first line enables a linefeed-separated test suite.)
Explanation
I'll use 2 as an example input (because the unary representations get a bit unwieldy for larger inputs).
Stage 1: Substitution
^
$_$*: $_

By matching the beginning of the string with ^ we simply prepend some stuff. $_ refers to the input string itself and $*: means we insert that many colons. So we get:
:: 22

Stage 2: Substitution
:
$_$*:

Now we match every : and again replace it with $_$*:. Of course, this time $_ doesn't evaluate to an integer (but to :: 22 in our example), but $* just looks for the first decimal in the string, so this evaluates to the input concatenated to itself (O in the challenge specification). We'll end up with N*O colons, followed by O:
:::::::::::::::::::::::::::::::::::::::::::: 22

Stage 3: Match
:

All that's left is counting the :s to convert from unary back to decimal, which is exactly what this stage does.

Ooh, so close to being as long as Java. Outgolfed it by just 2 bytes. +1

@R.Kap Actually, Java 8 outgolfed it after removing 3 bytes! o.Ô

Sorry, Java....

Jelly, 8 6 bytes
ŒṘẋ2v×

Try it online!
Explanation
ŒṘẋ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

I don't think you need either of those ³s.

Awk, 13 bytes
$0=($0$0)*$0

Set the line to 2 of itself multiplied by itself

I don't know about all AWK's but $0*=$0$0 works with GAWK, which is the same idea just a couple bytes shorter.

Lua, 20 Bytes
Takes in a command-line argument, and outputs via STDOUT
a=...print((a..a)*a)

And ungolfed as @LeakyNun asked in the comment :)
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

That can be a nice demonstration of type coercion... if you add the explanation in.

Brachylog, 7 bytes
:?c:?*.

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

Matlab / Octave, 20 bytes
@(x)eval([x x 42 x])

This is an anonymous function that takes the input as a string.
Example use:
>> f = @(x)eval([x x 42 x])
f =
    @(x)eval([x,x,42,x])
>> f('12')
ans =
       14544

Or try it online with ideone.
Explanation
The code builds a string by concatenating the input string twice, then the character * (that has ASCII code 42), then the string again. The concatenated string is then evaluated.

What does 42 mean?

@LeakyNun It's the Answer to the Ultimate Question of Life, the Universe, and Everything". Also, it happens to be the ASCII code for *

Ah. I was searching for something like the 42th function.

The code simply builds a string by concatenating the input string twice, then *, then the string again. The concatenated string is then evaluated. I'll edit that into the answer

Python, 42 bytes
Pure arithmetic approach, without strings!
f=lambda n,m=1:m<=n and f(n,m*10)or-~m*n*n

Ideone it!

MATL, 6 bytes
tVthU*

Try it 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]

Takes input as a command line argument, outputs to STDOUT.
This only works in zsh, but here's 15 bytes in Bash using echo instead of <<<:
echo $[$1$1*$1]

Perl, 11 bytes
$_*=$_ x2

+ the p and l flags.
(run with perl -ple '$_*=$_ x2')
-2 bytes thanks to pipe.

Save two bytes: $_*=$_ x2

I don't think you need -l

@BradGilbertb2gills Yes I need it because without it, $_ x2 will produce ...\n...\n which when converted as a number by perl ends at the first \n

I was testing it with both Perl 5 and 6, and didn't notice that I forgot to remove the 6.

Excel VBA, 35 Bytes
Sub called with number, msgbox returns answer
Sub B(a)
MsgBox (a & a) * a
End Sub

Alternative Excel VBA, 42 Bytes
Number given in formula, returns answer.
Function B(a)
B = (a & a) * a
End Function

Think about a MsgBox and a Sub. It will save you 13 Byte, if I count correctly

I would need some form of input box to get the value, no?

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

That requires another sub to pass the value, I'm not sure that's allowed in golf.

The Function must be called too ;)

If the characters for calling the sub/function are counted then the function would be shorter.

This doesn't count. See all the other answers

Pyke, 5 4 bytes
`+b*

Try it here!
`    -    str(input)
 +   -   ^+input  (convert to string implicitly)
  b  -  int(^)
   * - ^*input

Also 5 bytes with string inputs
+bRb*
+]mbB

PHP, 25 24 bytes
Short opening tags are useful for surprisingly few  golfing challenges, luckily this is one of them.
Unfortunately operator precedence is the opposite of the order you need to do them in so lots of brackets are needed.
<?=($a=$argv[1])*"$a$a";

edit: I realised that seeing as how I'm using brackets anyway I can effectively skip the concatenation operator by changing the written order of the operations around.

dc, 11 10 bytes
ddZAr^1+**

I knew that eventually I would find a use for the Z command!
Operation is fairly simple - count the digits, take 10 raised to that power and add one.  This gives a multiplier that concatenates the number with itself.  Then just multiply.
I/O uses the stack, as usual for dc.
Full program
This is what I used for the tests:
#!/usr/bin/dc
?
ddZAr^1+**
p

The two extra commands give us pipeline I/O.
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

Thanks are due to Sir Biden XVII (1 byte).

You can substitute A for 10 to save a byte. Well done!

PowerShell, 25, 18 bytes
Thank you TessellatingHeckler for reminding me how much PS loves the pipeline.
New 18 bytes:
process{$_*"$_$_"}

Old 25 bytes:
param($a);[int]"$a$a"*$a

Explanation:
# 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

Testing (save as boring.ps1):
# new
12 | .\boring.ps1
14544
174 | .\boring.ps1
30306276

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

Definitely not the winning answer, but fun regardless!

If you put the variables the other way around, int * string will implicitly cast the string to an int, and you can save 5 bytes of casting. process{$_*"$_$_"} is 18 bytes, and takes input from "stdin" (i.e. the pipeline), e.g. 174|script.ps1

Hmmm... Interesting point. I can also switch them using my same structure and achieve the same result: param($a);$a*"$a$a"

Err, I take that back, mine is one byte longer!

@TessellatingHeckler Careful with that answer, since PowerShell's REPL environment doesn't qualify for the program or function default. Something like param($n)$n*"$n$n" (what Darth had, without the ;) is the same length and isn't a REPL.

@TimmyD why doesn't a test.ps1 file which reads from the pipeline count? Does a bash shell script reading from stdin not count either?

@TessellatingHeckler Hrm. Perhaps a Meta question should be posed.

R, 28 27 bytes
Edit: -1 byte thanks to @Dominic van Essen.
(10^nchar(z<-scan())*z+z)*z

Try it online!
Shorter than bouncyball's solution with different approach.
Explanation
z=scan() gets input
10^nchar(z))*z+z is concatenation of the two copies of the number
*z at the end to get the result.

27 bytes... but it took 6 years to save the last byte!

@DominicvanEssen, thanks, that's some archaeological work! (it was my second R answer on this site...) Actually inlining the scan does the job, so I'll stick to the old formula.

Sometimes one of these old questions comes to the top of the 'Home' page, and I give it a go, and only afterwards check whether there's already a similar answer...

Batch, 27 20 18 bytes
@cmd/cset/a%1%1*%1

Edit: Saved 7 bytes thanks to @TessellatingHeckler. Saved a further 2 bytes thanks to @EʀɪᴋᴛʜᴇGᴏʟғᴇʀ.

set /a at the prompt outputs the result of the assignment. ->  @cmd/c set/a n=%1%1*%1 for 22 bytes.

@TessellatingHeckler Why bother assigning if you're outputting?

@TessellatingHeckler Huh, I already did this trick myself six weeks ago, and I've forgotten it already..

@cmd/cset/a%1%1*%1 for 18.

@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ Huh, would you believe it?

@Neil Nope, but I tested it (on Windows 10!) The cmd/c part is needed because the batch file executing tool is not cmd itself.

Mumps, 11 bytes
R I W I_I*I

This is one of those rare golf challenges where the idiosyncrasies of Mumps can come in very handy. First, all variables are strings, and all math equations are strictly evaluated left-to-right (as in: not PEMDAS), so 1+2*4=12 in Mumps instead of =9 the way PEMDAS would. So, (barely) ungolfed:
R I ;     Read from stdin to variable I
W I_I*I ; Write out I concatenated with I, then multiplied by I.

Word of caution - because the flavour of Mumps that I'm using (InterSystems Ensemble) does not echo the carriage return for stdin, the input and output number will appear concatenated. To rectify that / increase readability, you'd need to add two bytes and add a manual CR/LF, thusly:
R I W !,I_I*I

However, as I didn't see that requirement in the rules of the challenge, I'm pretty sure that I'm good with the shorter code. If I'm mistaken, please feel free to LART me and I'll modify my answer. :-)

Perl 6, 11 bytes
{"$_$_"*$_}

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  12 => 14544,
   1 => 11,
   2 => 44,
   3 => 99,
  10 => 10100,
 174 => 30306276,
);

plan +@tests;

my &uninteresting = {"$_$_"*$_}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is uninteresting($input), $expected, .gist
}

1..6
ok 1 - 12 => 14544
ok 2 - 1 => 11
ok 3 - 2 => 44
ok 4 - 3 => 99
ok 5 - 10 => 10100
ok 6 - 174 => 30306276

Haskell, 22
I'm new to Haskell (and functional programming), so expert criticism is welcome.
f n=(read$n++n)*read n

main=do
  putStrLn $ show $ f "1"
  putStrLn $ show $ f "2"
  putStrLn $ show $ f "3"
  putStrLn $ show $ f "10"
  putStrLn $ show $ f "174"

You technically didn't fulfill the requirements. It says to use numbers as input, you used strings. I had the same idea before I realized that. ;)

@AplusKminus The asker allows string as input

Curry (PAKCS), 26 bytes
f n=n*read(show n++show n)

Try it online!
-1 from ovs

Clojure, 22 bytes
#(*(bigint(str % %))%)

Anonymous function which concatenates string representation of its argument covnerts it to BigInteger and multiplies by the argument. The output is in format 11N (N signifies its a bigint), if there should be no N at the end then we can use
#(*(read-string(str % %))%)

for 27 bytes.
See it online: https://ideone.com/QqYfpo

SpecBAS - 30 bytes
1 INPUT n$: ?VAL(n$+n$)*VAL n$

My shortest SpecBAS answer yet :-)

Python, 51 Bytes
from math import*
g=lambda x:x*(x+x*10**(1+int(log10(x))))

Here's the mathematical way to do it (friend of mine found the formula).
I guess using it wouldn't produce an answer shorter than 3 bytes. :)

I was a bout to post an answer using a similar approach... by the way it is python not phyton.

@LeakyNun Code doesn't work either. Will look into it.

Add from math import* to the beginning of your submission, and you can remove g= from the byte count.

Changing from 10**(1+int(log10(x))) to 10**-~int(log10(x)) saves you bytes on parentheses. Changing from x*(x+x*10**... to x*x*-~10**... also saves bytes on parentheses.

Japt, 4 bytes
U²*U

² translates to p2, which was (seemingly) designed to shorten the syntax for raising the number to the power of two. For strings, p function is repeating, not exponentiating, but the shortcut still works :) As you may've understood, takes the input as string.
Demo

This can now be 2 bytes, for the win!

Hexagony, 23 bytes
?'=1*'\|@}*\=+=':<\}0.!

Embiggened:
    ? ' = 1
   * ' \ | @
  } * \ = + =
 ' : < \ } 0 .
  ! . . . . .
   . . . . .
    . . . .

Try it online!
As Hexagony doesn't have a concatenation function, it has to be done through multiplying the input by the appropriate factor of 10, then adding the input to it again. For example, CONCAT(12,12) can be implemented as (12 * 100) + 12.

><>, 22 Bytes
a:{:@)8$.$a*!
::{*+*n;

Input is expected to be on the stack already. If that's not okay, then I'll probably mark this answer non-competing. Reading numeric inputs in ><> is a real pain. Try it online
On a side note, this is my first post after a long period of inactivity; I'm glad to be able to contribute to this wonderful community again.

Explanation
I'm using the term "padding" to refer to a "variable"* that the input will be multiplied so that its digits may be duplicated.
e.g. if 12 is our input N and 1212 is the number O, then the padding used would be 100 since 12*100 + 12 = 1212.
*><> doesn't exactly have those, aside from the register (&), but you can effectively have them by manipulating the stack if that makes sense
Line 1
a:{:@)8$.$a*!
a              push initial padding value (10)
 :{:           duplicate padding, bring input to front of stack and duplicate it
    @          manipulate stack so that it looks like [padding,input,padding,input]
     )         pop input and padding from top and push the result of (padding > input)
      8$.      push 8 and swap with the result, then jump to that location
         $     swap top so it looks like [input,padding]
          a*!  multiply padding by 10, skip pushing 10 at beginning

Line 2
::{*+*n;
::        duplicate input twice -> [padding,input,input,input]
  {       bring padding from bottom -> [input,input,input,padding]
   *      multiply first input copy by padding
    +     add it to the second copy
     *    multiply by the final copy
      n   print result
       ;  terminate

Here's a hopefully more readable explanation.
Line 1
a:{:@)8$.$a*!

The program initializes the stack so that it contains [input,10] (10 is the initial padding value). It then checks to see if the padding is greater than the input. The result of this (1 if true, 0 if false) is pushed onto the top of the stack. The pointer then jumps to the location (8,padding>input), which means that if the padding is greater than the input, the program goes to the second line and if it isn't it continues along on the first line. If it continues on the first line, it'll multiply the padding by 10 and repeat the process.
Line 2
::{*+*n;

On Line 2, the program duplicates the input twice and then evaluates the expression input*((input*padding) + input) and prints it.

Brachylog (2), 4 bytes
j:?×

Try it online!
Explanation
j:?×
j     Append the input to itself
 : ×  then multiply by
  ?   the original input

Wren, 41 bytes
Fn.new{|n|Num.fromString(n.toString*2)*n}

Try it online!
Explanation
Fn.new{|n|                              } // New function with the parameter n
                         n.toString       // Convert the number to a string
                                   *2     // Duplicate this value
          Num.fromString(            )    // Convert to a number
                                      *n  // Multiply it with the original number

Google Sheets, 11 bytes
=(A1&A1)*A1

Fishing, 26 bytes
v+CCCCCCCCCC
  Icc{n{n}mP

Explained column-by column

Set casting direction downwards
Increase casting length to 1
Read input to first cell on tape
Concatenate first and second (empty) cell on tape and add to end of tape
Concatenate first and second (now containing input) cell and add to end of tape
Move to second cell (containing input)
Cast cell content to number
Move to third cell (containing input twice)
Cast cell content to number
Move to second cell.
Set content of second cell to second cell multiplied by third cell
Print second cell content

Actually, 7 bytes
;;+k♂≈π

Try it online!
Explanation:
;;+k♂≈π
;;       duplicate input twice (3 total copies)
  +      concatenate two of the copies
   k♂≈   push to a list, convert all elements to ints
      π  product

R 34 bytes
y=scan();as.numeric(paste0(y,y))*y

I think the numeric approach is faster ;-) Nice answer however, I didn't know paste converts numbers to strings implicitly.

hashmap, 8 bytes
i&&+d#d*

Explanation:
i&&+d#d*
i&&      Triple the input
   +     Add them together
    d#d  Convert both into a number
       * Multiply them

Forth, 63 bytes
This feels horribly inefficient...
: f dup 2dup 10e s>f flog 1e f+ floor f** s>f f* s>f f+ f>s * ;

Try it online
Note that this works on Ideone (gforth-0.7.2), but not repl (JS-Forth), since repl doesn't support pushing numbers to the float stack or the flog and floor operations.
Explanation
: f                     ( define a word/function named 'f'              )
dup 2dup                ( duplicate 3 times                             )
10e                     ( push 10 to float stack, not used for log{n}   )
s>f flog                ( move # to f-stack and get its log-10          )
1e f+ floor             ( increment the above result by 1 and floor     )
f**                     ( use the 10 pushed earlier, 10**log{n}         )
s>f f* s>f f+           ( mul by n, then add n                          )
f>s * ;                 ( to regular stack, mul by n, end definition    )

Mathematica, 24 bytes
a=FromDigits;a[#<>#]a@#&

Anonymous function, takes a string representing a number as input and generates its corresponding uninteresting number.

Coffeescript, 36 34 19 bytes
Thanks to @Fawful for shaving off 2 bytes, and to @joeytwiddle for some more
a=(n)->(""+n+n|0)*n

Neater script and explanation:
a=(n)->               # Creates a new function
       (""+n+n|0)     # Concatenate as strings, then convert back to integer
                 *n   # then multiplies it by n

parseInt((""+n)+n)?

You can use Number() instead of parseInt(). Or even better you can use |0. Also there is no need for return. We can reach 19 in CS, 17 in ES6. ;)

@joeytwiddle Ah yeah... I posted this ages ago, so...

Ruby, 22 Bytes
->n{(n*2).to_i*n.to_i}

Takes input as a string. Double the string, and then multiply it by the input, both as integers

Your mom, 6 bytes
ð::+*

The name of this language is a idea from mbomb007...
Explanation:
ð     Read a string from stdin
 ::   : is the duplicate operator, so the input is duplicated 2 times
   +*
      Implicit output

Logy, 40 bytes
main[A]->print[atoi[A(1)*2]*atoi[A(1)]];

Ungolfed:
main[Args] -> print[atoi[Args(1)*2]*
                    atoi[Args(1)]];

RProgN, 9 Bytes
] ] . * _

Explanation
] ]     # Push two copies of the top of the stack, which implicitly contains the input.
.       # Concatenate the top two values of the stack, and push it to the top of the stack.
*       # Multiply the top two values of the stack
_       # Floor the top of the stack, to make it pretty.
        # Implicitly print

Yay for Stack Based Loosly typed languages.
The main downside of RProgN is that (Currently) whitespace is needed for a function to run (Aside from the last command). Which wastefully adds four whole bytes.

k, 14 bytes:
{x*"J"$s,s:$x}

Explanation:
x              // implicit input
  $            // string the input
    s:         // set variable s to..
      s,s      // append s to s
        "J"$   // cast to 64bit int
           x*  // multiply by original input, return is implicit

TI-Basic, 9 bytes
Input should be passed as string
expr(Ans)expr(Ans+Ans

Brain-Flak, 226 bytes
((({}))){(({})(<><>))<>((()())(({}){}){}){(({})){({}[()])<>}{}}{}<>([{}()]{})(<>{}(<>))<>((()())(({}){}){})([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)}{}<>([]){{}({}<>(({}){})(({}){}){})<>([])}{}<>({}<>)({<({}[()])><>({})<>}{})

Try it online!
The main idea here is to decompose N into its digits, putting the digits on the off-stack; then we can calculate O by multiplying N by 10, adding a digit from the off-stack, and repeating until the off-stack is empty. Multiplying that result by another copy of N gives the final answer. I borrowed pretty heavily from the arithmetic algorithms here, tweaking them a bit to fit into this particular program in fewer bytes.
Make two more copies of the input
((({})))
The third copy will be decomposed into its digits
Loop while the partially decomposed number is not zero:
{
 Push a zero and a copy of the number
 (({})(<><>))
 Switch to the off-stack and push 10
 <>((()())(({}){}){})
 Modulo algorithm: we end up on the off-stack with number % 10 on top
 {(({})){({}[()])<>}{}}{}<>([{}()]{})
 Push a zero and the top of the main stack to the off-stack, popping the main stack
 (<>{}(<>))
 Switch to the main stack and push 10
 <>((()())(({}){}){})
 Division algorithm: we end up on the main stack with number / 10 on top, and without any
 junk left on the off-stack
 ([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)
}
Pop the leftover zero, switch to off-stack, and push stack height
{}<>([])
Loop while stack height is not zero:
{
 Discard stack height
 {}
 Add top of off-stack to 10 times top of main stack and push to main stack
 ({}<>(({}){})(({}){}){})
 Switch back to off-stack and push stack height
 <>([])
}
Discard stack height and switch to main stack
{}<>
Multiplication algorithm: we end up with O*N on the stack, which the program outputs
({}<>)({<({}[()])><>({})<>}{})

Keg, 7 bytes
::⑫++ℤ*

Try it online!
Simply duplicate the input twice, push an empty string, add the input to that string, convert to integer and multiply by original input

GolfScript, 7 bytes
.2*~\~*

Try it online!
Explanation:
.2*       duplicate, concatenate duplicate to self
   ~\~    convert both strings to ints
      *   multiply

Vyxal, 2 bytes
J*

Try it Online!

Desmos, 28 bytes
f(n)=10^{floor(logn)}10nn+nn

Try It On Desmos!
Try It On Desmos! - Prettified

Ly, 8 bytes
nsS&:Jl*

Try it online!
Ly supports a pretty direct translation of the rules of this challenge...
n         - read in the number
 s        - stash the number
  S       - push the digits of the number onto the stack
   &:     - append the stack to itself
     J    - convert those digits to a number
      l   - restore the original number
       *  - multiple, stack prints as number automatically

Ruby, 31 26 bytes
-5 bytes thanks to pxeger and Steffan
n=gets;p (n+n).to_i*n.to_i
Attempt This Online!

You can replace puts with just p for -3 bytes

you can use just (n+n) instead of the o variable to save another -2 bytes

here's 26 bytes

Zsh, 13 bytes
<<<$[$1*$1$1]
Attempt This Online!

Haskell, 23 bytes
A pointfree function which takes and returns an integer.
(*)<*>read.(show<>show)
Attempt This Online!

Julia 1.0, 35 bytes
!x=(10^floor(Int,log10(x)+1)*x+x)*x

Try it online!

Welcome to Code Golf!

Japt, 2 bytes
Takes input as a string
*²

Try it
*²     :Implicit input of string
*      :Multiplied by
 ²     :Itself duplicated

Julia 1.0, 21 bytes
!n=parse(Int,"$n$n")n

Try it online!

C, 52 50 bytes
q;f(char*v){q=atoi(v);return atoi(strcat(v,v))*q;}

Usage
q;f(char*v){q=atoi(v);return atoi(strcat(v,v))*q;}
main(c,v)char**v;{while(*++v)printf("%d\n",f(*v));}

Full Program 75 69 bytes
q;main(c,v)char**v;{q=atoi(*++v);printf("%d",atoi(strcat(*v,*v))*q);}

-2 & -6 thanks to Toby Speight in this comment

Be careful with that main() loop - most implementations don't leave enough space for the strcat() in there.

BTW, in the 'full program' version, you don't need to dereference ++v, and you can move the increment over to the next statement: {q=atoi(*++v);...  I think that gains you 3 bytes.  Moreover strcat() returns the start of the string, so you can use atoi(strcat(v,v))*q and atoi(strcat(*v,*v))*qrespectively.

True!! I wrote the full program version in a rush...

ForceLang, 54 bytes, noncompeting
set a io.readnum()
io.write a.mult number.parse a+""+a

Noncompeting, because it requires a language version published after this challenge (containing a patch for a minor parse error relating to the empty string literal).

The original answer, which doesn't require this bugfix (76 bytes):
set a io.readnum()
set b a+string.builder()
io.write a.mult number.parse b+a

Racket, 74 62 bytes
(λ(n)(*((λ(m)(string->number(string-append m m)))(~a n))n))

I hate the length of built-in function names in Racket sometimes.   Other times, I discover a really concisely named version of a function and transform a number->string into ~a.

Common Lisp (Lispworks), 91 78 77 bytes
(defun f(n)(*(parse-integer(concatenate'string #1=(write-to-string n)#1#))n))

I edited your answer so that it would show up as code. I don't know lisp, so I'm not sure. Is the newline is necessary?

Is the newline is necessary? not  necessary

I'm not sure, that's why I'm asking you. Will this still run if you combined it into one line?

yes, lisp  separative sign is parentheses or blank space (etc. tabbar\Spacebar)

Python 3, 43 bytes
x=int(input());print(10**len(str(x))*x+x)*x

SAS, 32 Bytes
%macro x(a);%eval(&a&a*&a)%mend;

Macro language, so no string/numeric concept.  Function style (so this doesn't return the value to the screen, that's your job, this just returns the value).
Examples:
86   %put %x(1);
11
87   %put %x(12);
14544

Jolf, 4 bytes
Try it here!
*P+§

Explanation
*P+§xxx
*     x   implicit input *
   §x       implicit input as string
  +  x      followed by implicit input
 P         as a number

T-SQL, 45 bytes
DECLARE @i INT = 12
SELECT CONCAT(@i, @i)*@i

TI-BASIC, 22 or 24 bytes
Prompt X
X(X+X10^(1+int(log(X

Or, 22 bytes stored as a Y-var (basically a function).

Python, 46 bytes
i=input("N:")           # Standard input
y=i+(i[-2:])            # Using strip method to take last two chars from input
print(int(y)*int(i))    # Temp convert strings into integers for maths and print the result.

JavaScript, 25 bytes
Golfed:
_=prompt();alert((_+_)*_)

Ungolfed:
_=prompt();
alert((_+_)*_)

Explanation:
_=prompt();    - set variable to prompt
alert((_+_)*_) - alert output, which is the number plus itself, times itself

This code was originally written by TùxCräftîñg. Their original comment with the code can be found here.

PHP, 32 bytes
function f($n){print($n.$n)*$n;}

Try it online!

Arturo, 28 bytes
$[n][n*to :integer~"|n||n|"]

Try it

J, 6 bytes
*&".,~

Similar to miles' 7 bytes but found independently and accepts a string.
Attempt This Online!
*&".,~   NB. Monadic hook (y f g y)
    ,~   NB. concat input with itself
 &       NB. compose, f&g applies g to both args and applies f to the results
  ".     NB. eval
*        NB. multiply

Thunno, \$ 8 \log_{256}(96) \approx \$ 6.58 bytes
DdDA+ZD*

Attempt This Online!
Explanation
DdDA+ZD*  # Implicit input                    Example: input = 10
Dd        # Duplicate and get digits          10, [1, 0]
  DA+     # Duplicate and concatenate         10, [1, 0, 1, 0]
     ZD   # Convert from a list of digits     10, 1010
       *  # Multiply                          10100
          # Implicit output

Pyt, 7 bytes
ĐĐąŁᴇ⁺Π

Try it online!
Takes in an integer
ĐĐ       implicit input (n); triplicate on stack
  ąŁ     get number of digits in n
    ᴇ⁺   raises 10 to that power
      Π  takes the product of everything on the stack; implicit output

JavaScript, 13 bytes
x=>(''+x+x)*x

Try it:

f=x=>(''+x+x)*x

console.log(f(1)); // 11
console.log(f(2)); // 44
console.log(f(3)); // 99
console.log(f(10)); // 10100
console.log(f(174)); // 30306276

Thunno 2, 3 bytes
Ḍ,p

Attempt This Online!
Takes the input as a string (allowed by OP).
Explanation
Ḍ,p  # Implicit input                   -> "12"
Ḍ    # Double                           -> "1212"
 ,   # Pair with input                  -> ["12", "1212"]
  p  # Product (implicit cast to int)   -> 14544
     # Implicit output

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Golf to find Boring numbers
If an integer has a digit/sequence of digits in it which repeats continuously (You will understand why I said "continuously") 5 or more times, we call It "Boring".
For example, 11111 is Boring, whereas 12345 is not.
Instructions
Take an Integer as Input
Output a truthy value if the integer is boring, and a falsey value if the integer is not boring.
Example
11111=>true or 1 (1 repeats 5 times)
12345=>false or 0
1112111=>false or 0
4242424242=>true or 1 (42 repeats 5 times)
-11111=>true or 1
3452514263534543543543543543876514264527473275=>true or 1 (543 repeats 5 times)
If you use other types of "truth" and "false", specify it.
Rules
Basic code-golf rules apply.
Good luck!

Is 1112111 boring?

Is 4242424242 boring?

4242424242 is boring.1112111 is not.

I guess today is the day of numbers no one likes. :)

1/7*1000000=Boring

Is 111112 boring?

It is. It has 1 continuously repeating 5 times.

Only non-negative integers?

All integers including negative integers.

Should the truthy or falsy value be consistent?

No. Actually some answers already use non-consistent truthy values.

All of your boring examples consist only of the boring part. Could you add some test cases like 12333334 and 51231231231231236?

Done. Its quite long.

@MatthewRoh Actually 1112111 contains more than the boring part

But It isn't boring

Strictly speaking, all numbers are boring, as they all can be written with an arbitrary number of leading zeros. :-)

"If you use other types of "truth" and "false", specify it." Can I use false as true and true as false?

Sure, but be sure to specify it.

You should have said without regex..

@MatthewRoh It's a really really easy challenge.

is pi boring in the region of the Feynman point?

Uhh, probably, I think?

05AB1E, 8 bytes
Code:
Œv¹y5×åO

Explanation:
Œ         # Compute all substrings from the input.
 v        # For each substring.
   y5×    # Repeat the substring 5 times (42 × 5 = 4242424242).
  ¹   å   # Check if it's in the input string.
       O  # Sum up the result. Non-boring numbers should give 0.

Truthy is non-zero and falsy is zero. Uses the CP-1252 encoding.
Try it online!

Nice use combining Œ with ×.

@Adnan Nice Work! c=

5 bytes (although I realize that wasn't possible yet when you've posted your answer mid-2016).

Retina, 9 bytes
(.+)\1{4}

Verify all testcases! (slightly modified to run all testcases at once.)

Wait, People are doing It THIS fast?

I was way too slow to post this. Knew Retina would love this challenge :)

@Emigna sorry xd

XD I actually did not expect people would do this fast.

Might be worth noting that this may print positive numbers other than 1 as well if the input is boring.

Why does (.+){5} not work?

@LuisMendo Doesn't that match any 5+ anything regardless if they're the same or not? For example it would match 12345

@Emigna That may be it. I don't know enough about regexes

@LuisMendo (.+){5} expands to (.+)(.+)(.+)(.+)(.+) while (.+)\1{4} expands to (.+)\1\1\1\1.

Thanks. I didn't know it worked by just expanding

Java 8, 52 bytes
s->s.matches(".*(.+)\\1{4}.*")

Outgolfed this Java 8 answer with a direct String#matches.
Explanation:
Try it here.
s->              // Method with String parameter and boolean return-type
  s.matches(     //  Return whether the entire String matches the following regex:
    ".*          //   0 or more leading characters
     (.+)\\1{4}  //   group of 1 or more characters, repeated 5 times
     .*")        //   0 or more trailing characters

Java 8, 73 66 bytes:
L->java.util.regex.Pattern.compile("(.+)\\1{4}").matcher(L).find();

Hooray for Java 8 lambdas! Returns true if match is found and false otherwise.
Try It Online! (Ideone)

Lua, 35 Bytes
Well, I don't see how to do better with Lua's patterns! Takes a command-line argument as input and output nil for falsy cases, and the number repeated when truthy.
print((...):match("(%d+)%1%1%1%1"))

JavaScript, 16 bytes
In node.js (60 bytes)
process.stdin.on('data',t=>console.log(/(.+)\1{4}/.test(t)))

Wasting a ton of bytes on input/output.
JavaScript ES6 (33 bytes)
alert(/(.+)\1{4}/.test(prompt()))

Again wasting bytes on input/output.
Preferably, as an anonymous function (22 bytes)
n=>/(.+)\1{4}/.test(n)

Or even shorter (16 bytes)
/(.+)\1{4}/.test

Thanks @BusinessCat for pointing out my mistakes.

You can use /(.+)\1{4}/.test(n) instead of match which saves a few bytes. Also it doesn't look like this will actually output anything.

@BusinessCat You're absolutely right, I guess I missed that in the question. Thanks for the suggestion.

You needn't take standard input, you could use function arguments

Uncaught TypeError: Method RegExp.prototype.test called on incompatible receiver undefined. I'm not sure if that technically counts as a correct answer, wouldn't it need to be something like /./.test.bind(/(.+)\1{4}/)?

The question states that "any number repeated 5 or more times" is Boring.

Python 3.5, 49 43 bytes:
(-6 bytes thanks to tips from Martin Ender!)
import re;lambda u:re.search(r'(.+)\1{4}',u)

Uses a Regular Expression to match all repeating sequences of characters as long as they repeat continuously 5 or more times. Returns an re match object (such as <_sre.SRE_Match object; span=(0, 10), match='4242424242'>) if a match is found as a truthy value, and nothing or None as a falsey value.
Try It Online! (Ideone)

Ah, the almighty regex.

Replace {4,} by {4}?

@LeakyNun Yeah, that also works.

What's the \1 do after the regex group?

@speedplane Matches any subsequent occurrences of the match from the group.

Perl, 17 15 bytes
$_=/(.+)\1{4}/

+ the p flag.
(run with perl -pe '$_=/(.+)\1{4}/')
Thanks to Dom Hasting for the (.+) instead of (\d+).
Explanations if needed :
  (.+) will match any part of the number, and \1{4}$ searches if it is repeated 4 times consecutives.

Good one, but there are better golfers out there. Its still good though.

I'm not sure Perl can do better than that... And I still wanted to submit a Perl solution, so here it is.

Can you add an explanation?

I think you might need $_=/(\d+)\1{4}/ instead as 111112 is boring but this won't catch it. You might even be able to use /./ as per the Retina answer.

@DomHastings  Indeed, I read the question too fast and didn't see the "5 times" (and the examples don't show it clearly). You're right about the /./, I edited it.

No problem! I think you need to remove the ^ and $ fully though, then you should be good!

Yup you're right, I was tring to match a "very boring number" when only boring ones were enough

Husk, 13 11 bytes
§ṁ€ȯm*5tQda

Try it online!
similar to 05AB1E.
-2 bytes from Dominic Van Essen and Jo King.

...and you can use ȯ to get 11 bytes...

@DominicvanEssen @JoKing Thanks for the help. Also, Q instead of Ṗ would be more accurate I think.

SABDT, 41 bytes
White Space-less:
if($.r("(.+)\1{4})"=""){pr"0";}el{pr"1";}

Prettified:
if( $.r( "(.+)\1{4}" ) = "" ){
    pr "0";
} el {
    pr "1";
}

Answer brought to you partly by the brilliant person who came up the regex "(.+)\1{4}"

Python 3 without regex, 66 bytes
lambda s:any(s[j:i]*5in s for i in range(len(s))for j in range(i))

Try it online!

C# - 93 38 bytes
s=>new Regex(@"(.+)\1{4}").IsMatch(s);

Takes a string, returns an integer.
Thanks to aloisdg for saving a lot of bytes!

You can take the argument as a string though, which should save you some bytes.

Wouldn't @"(.+)\1{4}" work as the regex as well? Does in my C# environment at least.

You can use a lambda. It is allowed. s=>Syst...

@Emigna - it would definitely work regardless of the C# environment. Anything with >5 consecutive characters will also work for exactly 5 consecutive characters.

Did you forget "Text" in System.Text.RegularExpressions?

You can create a new Regex and use isMatch (returns a bool). Also if you update your regex to the Retina solution (the mighty one!). You can move to 69 bytes: s=>new System.Text.RegularExpressions.Regex(@"(.+)\1{4}").IsMatch(s);

Also, I think that we should be able to write s=>new Regex(@"(.+)\1{4}").IsMatch(s); Because we stay in .NET (which his our stdlib) and we never count for using System.Linq; or using System.Collections.Generic.

Pyth, 9 8 bytes
1 byte thanks to Maltysen.

sm}*5dQ.:
f}*5TQ.:

Truthy value is a non-empty array.
Falsey value is [] (empty array).
Test suite.
f}*5TQ.:   input as a string stored in Q
f}*5TQ.:Q  implicit arguments
        Q  input
      .:   all substrings of.
f   T      filter for this condition, keep those returning true:
  *5           repeat five times
 }   Q         in Q? (True/False)

get 8 bytes by replacing m with f and taking out the sum.

Mathematica, 46 40 36 bytes
b=a__;StringContainsQ[b~~b~~b~~b~~b]

Function. Takes a string as input and outputs True or False. Tests strings against the expression a__~~a__~~a__~~a__~~a__, which represents the same character sequence repeated 5 times. For reference, the shortest solution using a regex is 45 bytes long:
StringContainsQ@RegularExpression@"(.+)\1{4}"

curse you RegularExpression!

Nice use of pattern matching.

PHP, 37 33 bytes
thanks to NoOneIsHere, I forgot about <?=
program for PHP<5.4, prints 1 for boring numbers, 0 else
<?=preg_match('/(.+)\1{4}/U',$n);

usage:

set register_globals=1 in php.ini for php-cgi
then call php-cgi <filename> n=<number>;echo""
for PHP>=5.4, replace $n with $_GET[n]

non-regexp solution, 152 147 140 bytes
<?for($e=$n+1;--$e;)for($f=$e;$f--;)for($a=str_split(substr($n,$f),$e),$k=$c='';strlen($v=array_pop($a));)$c-$v?$k=0&$c=$v:($k++<3?:die(1));

returns exit code 1 for boring numbers, 0 else
replace die(1) with die(print 1) and append echo 0; to print instead
same usage as above, but also set short_open_tags=1 if disabled
The outer loop got an unreasonable start value in the golfing, replace $n+1 with ceil(strlen($n)/5)+1 or at least with strlen($n) for testing or it may loop like forever.

<?=preg_match... is a few chars shorter

Haskell, 80 (63?)
It would be 63 if there were no import statement.
import Data.List
f x=or$tail[isInfixOf(concat$replicate 5 b)x|b<-subsequences x]

Usage
f "11111211"
f "11111"
f "12345"
f "1112111"
f "4242424242"
f "-11111"
f "3452514263534543543543543543876514264527473275"

By the way, consecutive makes more sense to me than continuously.
(Sorry, I can't comment yet.)

I hope My upvote helped making yourself able to comment.

CJam, 22 bytes
q:T,{)Tew{5*T\#)}/}%:+

Try it online!
Takes sum of 1-indexed positions of all possible repeated substrings in the input. Returns 0 if interesting, anything non-zero if boring.

Japt, 7 bytes
øUã mp5

Try it (includes all test cases)
øUã mp5     :Implicit input of string U
ø           :Does U contain any element of
 Uã         :  Substrings of U
    m       :  Map
     p5     :    Repeat 5 times

Vyxal Ṡs, 34 bitsv2, 4.25 bytes
K5*vc

Try it Online!
The 05ab1e answer but in less bytes :)

JavaScript (Node.js), 77 bytes
s=>s.some((_,i)=>s.some(c=>--i<0&&([,s]+1).split([t+=[,c]]+t+t+t+t)[1],t=''))

Try it online!

TSQL, 151 bytes
Golfed:
DECLARE @t varchar(99)='11111'

,@z bit=0,@a INT=1,@ INT=1WHILE @a<LEN(@t)SELECT @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),@=IIF(@=20,1,@+1),@a+=IIF(@=1,1,0)PRINT @z

Ungolfed:
DECLARE @t varchar(99)='11111'

,@z bit=0,
@a INT=1,
@ INT=1
WHILE @a<LEN(@t)
  SELECT
    @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),
    @=IIF(@=20,1,@+1),
    @a+=IIF(@=1,1,0)

PRINT @z

Fiddle

PowerShell, 26 bytes
$args[0]-match"(.+)\1{4}"

I'm by no means a regex master, so credit to the other answers for that.

JS without regexes, 166
b=s=>{for(let i=0;i<s.length-4;i++){for(let n=1;n<=Math.floor((s.length-i)/5);n++){if([1,2,3,4].every(k=>s.slice(i,i+n)==s.slice(i+n*k,i+n*(k+1))))return 1}}return 0}

non minified:
// test any start pos, and length
var b = s => {
    for (let i = 0; i <= s.length - 5; i++) {
        for (let n = 1; n <= Math.floor((s.length - i) / 5); n++) {
            // test if s is boring at position i, with length n
            if ([1, 2, 3, 4].every(k => s.slice(i, i + n) === s.slice(i + n * k, i + n * (k + 1)))) {
                return 1;
            }
        }
    }
    return 0;
};

console.log(b('11111'));
console.log(b('12345'));
console.log(b('1112111'));
console.log(b('-11111'));
console.log(b('3452514263534543543543543543876514264527473275'));

Hi, and welcome to PPCG! However, this can really be golfed more. You can remove just the extra whitespace for a much shorter code. Please either golf it more or delete.

I like the idea of avoiding regex. Replace(['boring','let','false','true']['b','','0','1']; that cut 20 characters

Clojure, 24 bytes
#(re-find #"(.+)\1{4}"%)

Uses clojure's falsey values of nil/false and truthy values for everything else. Specifically, nil when no match is found for false, and an array [] for true when a match is found like for 11111 then ["11111" "1"] is true.

Scala 3, 27 bytes
_.matches(".*(.+)\\1{4}.*")

Attempt This Online!