text:
Draw a phi triangle
Clarification: Basically, you need to make this
Euler's totient function has the name phi.
Let's try to calculate phi(8)
First, list all numbers 8 and under backwards, not including 0 or under
8
7
6
5
4
3
2
1

Now find which numbers don't share a factor with 8 (1 doesn't count), and place a # in their place.
8
#
6
#
4
#
2
#

Remove the numbers.
#

#

#

#
                                                 -

Now do this, but string the outputs together in a triangle
        9
       88
      777
     6666
    55555
   444444
  3333333
 22222222
111111111
---------
123456789

# out non-factor sharing numbers
        9
       8#
      7##
     6#66
    5####
   4#4#4#
  3##3##3
 2#2#2#2#
#########

Remove numbers:
        #
       ##
      #
     ####
    # # #
   ## ##
  # # # #
#########

This would be the output for input 9 (since 9 columns.)
Leading + trailing newlines allowed.

Clarification needed.

if you need to clarify, try the sandbox first.

can I output as a list of lines?

Leading newline allowed?

MATL, 17 15 bytes
:Gq:!Zd1=RP35*c

Try it online!
If a leading newline is acceptable: 13 bytes:
:t!Zd1=RP35*c

Explanation
:     % Take input N. Generate row vector [1 2 ... N]
Gq:   % Row vector [1 2 ... N-1].
      % (In the 13-byte version this is replaced by function `t`, which duplicates
      % the array [1 2 ... N])
!     % Transpose into column vector
Zd    % GCD, element-wise with broadcast. Gives (N-1)×N matrix
1=    % True for entries that equal 1, corresponding to relatively prime pairs.
      % The rest of entries are set to false, i.e. 0.
R     % Upper triangular part: set values below diagonal to 0
P     % Flip matrix vertically
35*   % Multiply each entry by 35 (ASCII for '#')
c     % Convert to char. 0 will be displayed as a space. Implicitly display

Nice use of char(0) :)

@Suever It's turning out to be very useful!

Jelly, 20 18 bytes
RR⁶”#g’¥?€"Rz⁶U'j⁷

Try it online!

Pyth - 22 bytes
Will try to golf further.
j_.tmsm@"# "n1idkSdSQd

Try it online here.

I did it in 20 bytes.

Well.... 21 bytes.

JavaScript (ES6), 112 bytes
n=>[...s=` `.repeat(n)].map(_=>s.replace(/./g,_=>`# `[+g(n+1,i++)],n-=i=1),g=(i,j)=>i?i>j||g(j%i,i):j>1).join`\n`

Where \n represents the literal newline character. Alternative solution, also 112 bytes:
n=>(s=`# `.repeat(n)).replace(r=/../g,_=>s.replace(r,m=>m[+g(n+1,i++)],n-=i=1)+`
`,g=(i,j)=>i?i>j||g(j%i,i):j>1)

Java, 162 158 bytes
int g(int a,int b){return a<1?b:g(b%a,a);}
String d(int n){String r="";for(int i=0;i<n;i++){for(int j=1;j<=n;)r+=i+j<n|g(n-i,j++)>1?" ":"#";r+="\n";}return r;}

Full program (not updated)
import java.util.Scanner;

public class Q79082 {
    int gcd_ungolfed(int a,int b){
        if(a==0) return b;
        return gcd_ungolfed(b%a,a);
    }
    void draw_ungolfed(int n){
        for(int i=1;i<=n;i++){
            for(int j=1;j<=n;j++){
                if(i+j<=n || gcd_ungolfed(n+1-i,j)!=1){
                    System.out.print(" ");
                }else{
                    System.out.print("#");
                }
            }
            System.out.println();
        }
    }
    int g(int a,int b){return a<1?b:g(b%a,a);}
    String d(int n){String r="";for(int i=0;i<n;i++){for(int j=1;j<=n;j++)r+=(i+j<n||g(n-i,j)>1)?" ":"#";r+="\n";}return r;}
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        new Q79082().draw_ungolfed(n);
        System.out.println(new Q79082().d(n));
    }
}

Input/output:
9

        #
       ##
      #
     ####
    # # #
   ## ##
  # # # #
#########

        #
       ##
      #
     ####
    # # #
   ## ##
  # # # #
#########

Make the shortcutted or into a single pipe, then put i++ and j++ in the call to g. Will save 3 bytes. Also, you don't need the parens in the trinary in d. 2 more bytes

i++ won't work because nested.

SQL (PostGreSQL9.4), 239 291 bytes
Creates a prepared statement that can be executed.  I'm sure I can probably take quite a few bytes out of this, but I'll have to pick away at it later.
Does a cross join on a range of 1 to n.  Calculates the GCD in a lateral join.  Where the GCD is 1 and the series A is greater than series B output a '#' otherwise a space.  Aggregate the results up into a string grouped by series B.
prepare p(int)as
select string_agg(coalesce(CASE WHEN b<=a AND x=1THEN'#'END,' '),'')from generate_series(1,$1)a,generate_series(1,$1)b,LATERAL(SELECT MAX(G)x FROM generate_series(1,LEAST(a,b))g WHERE a%g+b%g=0)g
group by b
order by b desc

Run in the following way
execute p(13)

string_agg
----------------

            #
           ##
          # #
         ## #
        # # #
       ######
      #   # #
     #### ###
    # # # # #
   ## ## ## #
  # # # # # #
#############

And cleaned up with
deallocate p

Python 2 (120 bytes)
g=lambda m,n:m if n<1 else g(n,m%n)
r=range(input())
for i in r[:0:-1]:print''.join('# '[i>j+1 or g(i,j+1)>1]for j in r)

Ruby, 84 bytes
->n{s=[];n.times{|i|j=0;m=n-i;s<<(?#*n).gsub(/./){m.gcd(j+=1)>1||m>j ?' ':$&}};s*$/}


text:
Is it a prefix code?
In information theory, a "prefix code" is a dictionary where none of the keys are a prefix of another. In other words, this means that none of the strings starts with any of the other.
For example, {"9", "55"} is a prefix code, but {"5", "9", "55"} is not.
The biggest advantage of this, is that the encoded text can be written down with no separator between them, and it will still be uniquely decipherable. This shows up in compression algorithms such as Huffman coding, which always generates the optimal prefix code.
Your task is simple: Given a list of strings, determine whether or not it is a valid prefix code.
Your input:

Will be a list of strings in any reasonable format.
Will only contain printable ASCII strings.
Will not contain any empty strings.

Your output will be a truthy/falsey value: Truthy if it's a valid prefix code, and falsey if it isn't.
Here are some true test cases:
["Hello", "World"]
["Code", "Golf", "Is", "Cool"]
["1", "2", "3", "4", "5"]
["This", "test", "case", "is", "true"]

["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011",
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]

Here are some false test cases:
["4", "42"]
["1", "2", "3", "34"]
["This", "test", "case", "is", "false", "t"]
["He", "said", "Hello"]
["0", "00", "00001"]
["Duplicate", "Duplicate", "Keys", "Keys"]

This is code-golf, so standard loopholes apply, and shortest answer in bytes wins.

Do you want a consistent truthy value or could it be e.g. "some positive integer" (which might vary between different inputs).

@MartinBüttner Any positive integer is fine.

@DrGreenEggsandHamDJ I don't think that answer is meant to address the consistency of outputs at all, hence the question. ;)

Just out of curiosity: The challenge says: "The biggest advantage of this, is that the encoded text can be written down with no separator between them, and it will still be uniquely decipherable.". How would something like 001 be uniquely decipherable? It could be either 00, 1 or 0, 11.

@Joba It depends on what your keys are. If you have 0, 00, 1, 11 all as keys, this is not a prefix-code because 0 is a prefix of 00, and 1 is a prefix of 11. A prefix code is where none of the keys starts with another key. So for example, if your keys are 0, 10, 11 this is a prefix code and uniquely decipherable. 001 is not a valid message, but 0011 or 0010 are uniquely decipherable.

Pyth, 8 bytes
.AxM.PQ2

Test suite
Take all 2 element permutations of the input, map each to the index of one string in the other (0 for a prefix) and return whether all results are truthy (non-zero).

Haskell, 37 bytes
f l=[x|x<-l,y<-l,zip x x==zip x y]==l

Each element x of l is repeated once for every element that it's a prefix of, which is exactly once for a prefix-free list, giving the original list. The prefix property is checked by zipping both lists with x, which cuts off elements beyond the length of x.

This is an elegant solution (+1)

Java, 128 127 126 125 124 121 bytes
(Thanks @Kenny Lau, @Maltysen, @Patrick Roberts, @Joba)
Object a(String[]a){for(int i=0,j,l=a.length;i<l;i++)for(j=0;j<l;)if(i!=j&a[j++].startsWith(a[i]))return 1<0;return 1>0;}

Ungolfed
Object a(String[] a) {
    for (int i = 0, j, l = a.length; i < l; i++)
        for (j = 0; j < l;)
            if (i != j & a[j++].startsWith(a[i])) return 1<0;
    return 1>0;
}

Output
[Hello, World]
true

[Code, Golf, Is, Cool]
true

[1, 2, 3, 4, 5]
true

[This, test, case, is, true]
true

[111, 010, 000, 1101, 1010, 1000, 0111, 0010, 1011, 0110, 11001, 00110, 10011, 11000, 00111, 10010]
true

[4, 42]
false

[1, 2, 3, 34]
false

[This, test, case, is, false, t]
false

[He, said, Hello]
false

[0, 00, 00001]
false

[Duplicate, Duplicate, Keys, Keys]
false

idk bout java, but would & work instead of &&?

Right, saves another byte. In Java, using bitwise operators with boolean operands behave just like normal logical operators, except they don't short circuit which isn't needed in this case.

Couldn't you just change the return type of the function to int and return 0 and 1? That would save several bytes. Also I forget if this is valid in Java but if you declare i, j, and l inside the outer for loop that would save one byte from one less semicolon.

@PatrickRoberts Maltysen suggested this before, but this is not valid according to the most upvoted definition of truthy/falsey. Putting the declarations in the loop however is perfectly valid and pretty obvious now that I think about it. Thats what you get for golfing at 4 in the morning :^)

@Maltysen just noticed that with the fact that & doesn't short circuit I can shave off another byte by putting the incrementation of j into the if-condition.

Now thats a neat trick! Cheers.

Instead of startsWith(a[i]) use indexOf(a[i])<1 to save one byte

@Joba Pretty sure that isn't valid since indexOf returns -1 when the string isn't found; it would need to be indexOf(a[i])==0 in which case there are no savings.

You actually got a point there, didn't think of that

Python 2, 48 51 bytes
lambda l:all(1/map(a.find,l).count(0)for a in l)

For each element a of l, the function a.find finds the index of the first occurrence of a in the input string, giving -1 for an absence. So, 0 indicates a prefix. In a prefix-free list, mapping this function returns only a single 0 for a itself. The function checks that this is the case for every a.

51 bytes:
lambda l:[a for a in l for b in l if b<=a!/(.*)\1/.test(''+a.sort().join``)
      ^            ^               ^ embedded NUL characters

My previous solution, which handled string arrays of all UTF-8 characters:
a=>!/[^\\]("([^"]*\\")*[^\\])",\1/.test(JSON.stringify(a.sort()))

I was able to avoid JSON.stringify since the challenge specifies printable ASCII characters only.
Test

f=a=>!/(\0.*)\1/.test('\0'+a.sort().join`\0`) // since stackexchange removes embedded NUL characters

O.textContent += 'OK: '+
[["Hello", "World"]
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011",
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a))

O.textContent += '\nKO: '+
[["4", "42"]
,["1", "2", "3", "34"]
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

CJam, 14 bytes
q~$W%2ew::#0&!

Test suite.
Explanation
q~   e# Read and evaluate input.
$    e# Sort strings. If a prefix exists it will end up directly in front
     e# of a string which contains it.
W%   e# Reverse list.
2ew  e# Get all consecutive pairs of strings.
::#  e# For each pair, find the first occurrence of the second string in the first.
     e# If a prefix exists that will result in a 0, otherwise in something non-zero.
0&   e# Set intersection with 0, yielding [0] for falsy cases and [] for truthy ones.
!    e# Logical NOT.

Haskell, 49 bytes
g x=[1|z<-map((and.).zipWith(==))x<*>x,z]==(1<$x)

This has a couple parts:
-- Are two lists (or strings) equal for their first min(length_of_1,length_of_2) elements, i.e. is one the prefix of the other?
(and.).zipWith(==)

-- Check whether one element is the prefix of the other, for all pairs of elements (including equal pairs)
map((and.).zipWith(==))x<*>x

-- This is a list of 1's of length (number of elements that are the prefix of the other)
[1|z<-map((and.).zipWith(==))x<*>x,z]

-- This is the input list, with all the elements replaced with 1's
(1<$x)

If the two lists are equal, then an element is only the prefix of itself, and it's valid.

Retina, 19 bytes
Byte count assumes ISO 8859-1 encoding.
O`.+
Mm1`^(.+)¶\1
0

The input should be linefeed-separated. Output is 0 for falsy and 1 for truthy.
Try it online! (Slightly modified to support multiple space-separated test cases instead.)
Explanation
O`.+

Sort the lines in the input. If a prefix exists it will end up directly in front of a string which contains it.
Mm1`^(.+)¶\1

Try to match (M) a complete line which is also found at the beginning of the next line. The m activates multiline mode such that ^ matches line beginnings and the 1 ensures that we only count at most one match such that the output is 0 or 1.
0

To swap 0 and 1 in the result, we count the number of 0s.

Java, 97 bytes
Object a(String[]a){for(String t:a)for(String e:a)if(t!=e&t.startsWith(e))return 1<0;return 1>0;}

Uses most of the tricks found in @Marv's answer, but also makes use of the foreach loop and string reference equality.
Unminified:
Object a(String[]a){
    for (String t : a)
        for (String e : a)
            if (t != e & t.startsWith(e))
                return 1<0;
    return 1>0;
}

Note that, as I said, this uses string reference equality.  That does mean that the code can behave oddly due to String interning.  The code does work when using arguments passed from the command line, and also when using something read from the command line.  If you want to hardcode the values to test, though, you'd need to manually call the String constructor to force interning to not occur:
System.out.println(a(new String[] {new String("Hello"), new String("World")}));
System.out.println(a(new String[] {new String("Code"), new String("Golf"), new String("Is"), new String("Cool")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("4"), new String("5")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("true")}));
System.out.println(a(new String[] {new String("111"), new String("010"), new String("000"), new String("1101"), new String("1010"), new String("1000"), new String("0111"), new String("0010"), new String("1011"), new String("0110"), new String("11001"), new String("00110"), new String("10011"), new String("11000"), new String("00111"), new String("10010")}));
System.out.println(a(new String[] {new String("4"), new String("42")}));
System.out.println(a(new String[] {new String("1"), new String("2"), new String("3"), new String("34")}));
System.out.println(a(new String[] {new String("This"), new String("test"), new String("case"), new String("is"), new String("false"), new String("t")}));
System.out.println(a(new String[] {new String("He"), new String("said"), new String("Hello")}));
System.out.println(a(new String[] {new String("0"), new String("00"), new String("00001")}));
System.out.println(a(new String[] {new String("Duplicate"), new String("Duplicate"), new String("Keys"), new String("Keys")}));

@Jo King See the second half of my answer; it's a bit complicated and depends on how input is specified.  I don't remember actually writing this, though

PostgreSQL, 186, 173 bytes
WITH y AS(SELECT * FROM t,LATERAL unnest(c)WITH ORDINALITY s(z,r))
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

Output:

No live demo this time. http://sqlfiddle.com supports only 9.3 and to run this demo 9.4 is required.
How it works:

Split string array with number and name it y
Get all y
LEFT OUTER JOIN to the same derived table based on the same i(id), but with different oridinal that start with prefix y.z LIKE u.z||'%'
Group result based on c (initial array) and use EVERY grouping function. If every row from second table IS NULL it means there is no prefixes.

Input if someone is interested:
CREATE TABLE t(i SERIAL,c text[]);

INSERT INTO t(c)
SELECT '{"Hello", "World"}'::text[]
UNION ALL SELECT  '{"Code", "Golf", "Is", "Cool"}'
UNION ALL SELECT  '{"1", "2", "3", "4", "5"}'
UNION ALL SELECT  '{"This", "test", "case", "is", "true"}'
UNION ALL SELECT  '{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011","0110", "11001", "00110", "10011", "11000", "00111", "10010"}'
UNION ALL SELECT  '{"4", "42"}'
UNION ALL SELECT  '{"1", "2", "3", "34"}'
UNION ALL SELECT  '{"This", "test", "case", "is", "false", "t"}'
UNION ALL SELECT  '{"He", "said", "Hello"}'
UNION ALL SELECT  '{"0", "00", "00001"}'
UNION ALL SELECT  '{"Duplicate", "Duplicate", "Keys", "Keys"}';

EDIT:
SQL Server 2016+ implementation:
WITH y AS (SELECT *,z=value,r=ROW_NUMBER()OVER(ORDER BY 1/0) FROM #t CROSS APPLY STRING_SPLIT(c,','))
SELECT y.c, IIF(COUNT(u.z)>0,'F','T')
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z+'%'
GROUP BY y.c;

LiveDemo
Note: It is comma separated list, not real array. But the main idea is the same as in PostgreSQL.

EDIT 2:
Actually WITH ORDINALITY could be replaced:
WITH y AS(SELECT *,ROW_NUMBER()OVER()r FROM t,LATERAL unnest(c)z)
SELECT y.c,EVERY(u.z IS NULL)
FROM y LEFT JOIN y u ON y.i=u.i AND y.r<>u.r AND y.z LIKE u.z||'%' GROUP BY y.c

SqlFiddleDemo

Brachylog, 8 bytes
¬(⊇pa₀ᵈ)

Try it online!
Outputs through predicate success/failure. Takes more than 60 seconds on the last truthy test case ["111","010","000","1101","1010","1000","0111","0010","1011","0110","11001","00110","10011","11000","00111","10010"] but passes it quickly with an added byte which eliminates a large number of possibilities earlier than the program does otherwise (Ċ before checking permutations rather than ᵈ after checking permutations, to limit the length of the sublist to two).
¬(     )    It cannot be shown that
   p        a permutation of
  ⊇         a sublist of the input
      ᵈ     is a pair of values [A,B] such that
    a₀      A is a prefix of B.

Less trivial 9-byte variants than ¬(⊇Ċpa₀ᵈ) which run in reasonable time are ¬(⊇o₁a₀ᵈ), ¬(⊇o↔a₀ᵈ), and ¬(⊇oa₀ᵈ¹).

If this challenge used "two distinct and consistent values" instead of "truthy/falsy", this would only take 5 bytes.

Perl 6, 24 bytes
{.all.starts-with(.one)}

Try it online!
Wow, surprisingly short while using a long built-in.
Explanation
{                      }  # Anonymous code block taking a list
 .all                     # Do all of the strings
     .starts-with(    )   # Start with
                  .one    # Only one other string (i.e. itself)

I wrote a 50 byte answer but yours just blew mine out of the water.

@bb94 Yeah, I started with a similar answer but ran into the same problem as yours with sets with duplicated keys returning truthy. Writing this answer was incredibly satisfying

Racket, 70 bytes
(λ(l)(andmap(λ(e)(not(ormap(curryr string-prefix? e)(remv e l))))l))

JavaScript (ES6), 52 54
Edit 2 bytes saved thx @Neil
a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

Test

f=a=>!a.some((w,i)=>a.some((v,j)=>i-j&&!w.indexOf(v)))

O.textContent += 'OK: '+
[["Hello", "World"]
,["Code", "Golf", "Is", "Cool"]
,["1", "2", "3", "4", "5"]
,["This", "test", "case", "is", "true"]
,["111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011",
 "0110", "11001", "00110", "10011", "11000", "00111", "10010"]
].map(a=>f(a))

O.textContent += '\nKO: '+
[["4", "42"]
,["1", "2", "3", "34"]
,["This", "test", "case", "is", "false", "t"]
,["He", "said", "Hello"]
,["0", "00", "00001"]
,["Duplicate", "Duplicate", "Keys", "Keys"]
].map(a=>f(a))

!w.indexOf(v)?

@Neil right, thanks

Mathematica 75 69 68 bytes
Loquacious as usual. But Martin B was able to reduce the code by 7 bytes.
Method 1: Storing output in an Array
(68 bytes)
f@a_:=!Or@@(Join@@Array[a~Drop~{#}~StringStartsQ~a[[#]]&,Length@a])

f@{"111", "010", "000", "1101", "1010", "1000", "0111", "0010", "1011", "0110", "11001", "00110", "10011", "11000", "00111", "10010"}

True

f@{"He", "said", "Hello"}

False

Method 2: Storing output in a List
(69 bytes)
f@a_:=!Or@@Flatten[a~Drop~{#}~StringStartsQ~a[[#]]&/@Range@Length@a]

The precedence rules should make a~Drop~{#}~StringStartsQ~a[[#]] work. Also Array should save some bytes over Length, especially because it will allow you to use Join@@ instead of Flatten@ (provided, you're using Flatten only for a single level).

Thanks for the suggestion. I'll look into Array later.

Mathematica, 41 bytes
!Or@@StringStartsQ@@@Reverse@Sort@#~Subsets~{2}&

APL (Dyalog Unicode), 13 bytesSBCS
-2 bytes:

≢=∘≢∘⍸∘.(⊃⍷)⍨

Try it online!
Explanation:
≢=∘≢∘⍸∘.(⊃⍷)⍨  ⍝ Monadic function train
         ⍷     ⍝ "Find": Convert the right argument into a boolean vector,
               ⍝ where ones correspond to instances of the left argument
        ⊃     ⍝ Take the first item of the above vector (i.e., only prefixes)
     ∘.(  )⍨  ⍝ Commutative outer product: take the above function and apply
              ⍝ it for each possible pair of elements in the input
              ⍝ If the input is a prefix code, the above should have a number of ones
              ⍝ equal to the length of the input (i.e., each item is a prefix of only itself)
              ⍝ To test this...
     ⍸        ⍝ Find the location of all ones in the above
   ≢∘         ⍝ Take the length of the above
≢=∘           ⍝ Compare to the length of the input

~2∊+\⊃¨∘.⍷⍨⎕

J, 17 bytes
#=1#.1#.{.@E.&>/~

Try it online!
Note: I actually wrote this before looking at the APL answer, to approach it without bias.  Turns out the approaches are almost identical, which is interesting.  I guess this is the natural "array thinknig" solution
Take boxed input because the strings are of unequal length.
Create a self-function table /~ of each element paired with each element and see if there is a match at the start {.@E..  This will produce a matrix of 1-0 results.
Sum it twice 1#.1#. to get a single number representing "all ones in the matrix", and see if that number is the same as the length of the input #=.  If it is, the only prefix matches are self matches, ie, we have a prefix code.
sorting solution, 18 bytes
0=1#.2{.@E.&>/\/:~

Attempt at different approach.  This solution sorts and looks at adjacent pairs.
Try it online!

R, 48 bytes
function(s)sum(outer(s,s,startsWith))==length(s)

Try it online!
Explanation: outer(s,s,startsWith) outputs a matrix of logicals checking whether s[i] is a prefix of s[j]. If s is a prefix code, then there are exactly length(s) TRUE elements in the result, corresponding to the diagonal elements (s[i] is a prefix of itself).

I've found a bunch of other 48 byte alternatives, like function(s)all(colSums(outer(s,s,startsWith))<2) but it remains that startsWith is a function I didn't know about! Nice find.

@Giuseppe I tried several ways of checking whether the matrix is an identity matrix, but couldn't get it under 48 bytes either. I thought this way was the easiest to understand, but I'm sure someone will golf it down!

47 bytes by inverting TRUE and FALSE...

@Giuseppe Is that allowed? The rules explicitly ask for truthy when the input is a valid prefix code. (Also your link is to the 48 byte version, but I am guessing that your suggestion is to replace ==  with >. :-) )

Pyth - 13 12 bytes
!ssmm}d._k-Q

Try it online here.

Ruby, 48 bytes
Uses arguments as input and stdout as output.
p !$*.map{a,*b=$*.rotate!
a.start_with? *b}.any?

Python, 58 55 bytes
lambda l:sum(0==a.find(b)for a in l for b in l)==len(l)

a.index(b)==0 is a bit shorter. Alternatively, you could do 0**sum(a.index(b)for a in l for b in l).

@Mego That doesn't work because index throws an exception when b isn't found. And because it should be ==, not >=. However, find works. (And it's shorter too!)

Whoops, I meant to type find. Sleepy brain is sleepy. The second version should also work with find.

@Mego I'm not sure if I get the second version. Wouldn't that always return 0?

@Mego That only works if every string is the same. The reason we compare it to len(l) is since we're iterating through all bs on each a, there will always be at least one match per a. So we check if the number of matches is the same as the number of elements.

I'm a sleepy idiot. I'm gonna go to bed instead of offering more dysfunctional improvement suggestions. :)

Scala, 71 bytes
(s:Seq[String])=>(for{x<-s;y<-s}yield x!=y&&x.startsWith(y)).forall(!_)

Racket 130 bytes
(define g #t)(for((n(length l)))(for((i(length l))#:unless(= i n))(when(string-prefix?(list-ref l i)(list-ref l n))(set! g #f))))g

Ungolfed:
(define(f l)
  (define g #t)
  (for ((n (length l)))
    (for ((i (length l)) #:unless (= i n))
      (when (string-prefix? (list-ref l i) (list-ref l n))
        (set! g #f))))g)

Testing:
(f [list "Hello" "World"])
(f [list "Code" "Golf" "Is" "Cool"])
(f [list "1" "2" "3" "4" "5"])
(f [list "This" "test" "case" "is" "true"])
(f [list "111" "010" "000" "1101" "1010" "1000" "0111" "0010" "1011"
         "0110" "11001" "00110" "10011" "11000" "00111" "10010"])

(f [list "4" "42"])
(f [list "1" "2" "3" "34"])
(f [list "This" "test" "case" "is" "false" "t"])
(f [list "He" "said" "Hello"])
(f [list "0" "00" "00001"])
(f [list "Duplicate" "Duplicate" "Keys" "Keys"])

Output:
#t
#t
#t
#t
#t
#f
#f
#f
#f
#f
#f

C (gcc), 93 bytes
p(r,e,f,i,x)char**r;{for(f=i=0;i<e;++i)for(x=0;x<e;++x)f|=x!=i&&strstr(r[i],r[x])==r[i];r=f;}

Try it online!
Simple double for loop using strstr(a,b)==a to check for prefices. Mainly added since there doesn't seem to be a C answer yet.

85 bytes

Japt, 8 bytes
á2 ËrbÃe

Try it
á2 ËrbÃe     :Implicit input of array
á2           :Permutations of length 2
   Ë         :Map each pair
    r        :  Reduce by
     b       :  Get the index of the second in the first - 0 (falsey) if it's a prefix
      Ã      :End map
       e     :All truthy (-1 or >0)

05AB1E, 13 bytes
2.ÆDí«ε`Å?}O_

Too long.. Initially I had a 9-byte solution, but it failed for the duplicated key test case.
Try it online or verify all test cases.
Explanation:
2.Æ             # Get all combinations of two elements from the (implicit) input-list
   Dí           # Duplicate and reverse each pair
     «          # Merge the lists of pairs together
      ε         # Map each pair to:
       `        #  Push both strings to the stack
        Å?      #  And check if the first starts with the second
          }O    # After the map: sum to count all truthy values
            _   # And convert it to truthy if it's 0 or falsey if it's any other integer
                # (which is output implicitly as result)

C# (Visual C# Interactive Compiler), 70 bytes
l=>!l.Any(x=>l.Where((y,i)=>l.IndexOf(x)!=i).Any(z=>z.StartsWith(x)));

Try it online!

Stax, 6 bytes
å·↑↑¶Ω

Run and debug it
This produces non-zero for truthy.
The general idea is to consider every pair of strings in the input.  If the substring index of one in the other is ever zero, then it's not a valid prefix code.  In stax, index of a non-existing substring yields -1.  This way, all the pair-wise substring indices can be multiplied together.
This is the same algorithm as isaacg's pyth solution, but I developed it independently.

source: Stack Exchange

license: 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/

sort: votes


text:
Is this uniquely concatenable?
In this challenge about prefix code, we learnt that prefix codes are uniquely concatenable.
That means, they can be joined together without separator, and without ambiguity.
For example, since [1,2,45] is a prefix code, I can join them together without separator as such: 1245245112145, and there will be no ambiguity.
However the converse is not always true.
For example, [3,34] is not a prefix code. However, I can do the same: 3333434334333, and there will be no ambiguity. You would just need a smarter parser.
However, [1,11] is not uniquely concatenable, because 1111 can be interpreted in 5 ways.
Goal
Your task is to write a program/function that takes a list of strings (ASCII) as input, and determine if they are uniquely concatenable.
Details
Duplicate counts as false.
Scoring
This is code-golf. Shortest solution in bytes wins.
Testcases
True:
[12,21,112]
[12,112,1112]
[3,4,35]
[2,3,352]

False:
[1,1]
[1,2,112]
[1,23,4,12,34]
[1,2,35,4,123,58,8]

Just to make sure I understand the challenge correctly, it is not uniquely concatenable if one of the strings is composed of any combination of the other ones? You should make that details more clear.

Are you sure this isn't equivalent to the halting problem?

Can you demonstrate why this is equivalent to the halting problem?

I didn't say it was, but wondered it might be. After some more thought I believe it isn't.

@feersum Here's a poly time algorithm for this problem: https://en.wikipedia.org/wiki/Sardinas%E2%80%93Patterson_algorithm

05AB1E, 15 bytes
On the phone, so explanation will have to follow later. Code:
gF¹N>ã})€`€JDÚQ

Uses CP-1252 encoding. Try it online!.
Takes too much memory for the last test case, so that might not work...

It's extremely impressive that you're able to type that on your phone.

@DrGreenEggsandHamDJ It took about 40 minutes...

@Adnan I wonder what your phone keyboard's text predictor thinks of all that garbage symbols :-)

@LuisMendo Haha, it only happened once that I sent a random 05AB1E program to a friend.

I'm guessing that this works by placing an upper bound on the length of the shortest collision. Am I right?

@PeterTaylor It computes all Cartesian products of the input array with the repeat varying from 1 to len(all_numbers), and checks if each of them (when joined together to 1 single string) is unique.

I wondered whether that was the right bound. It seemed plausible, but I haven't managed to prove it.

CJam (54 bytes)
q_N/:A\,{_Am*:${~1$,<=},{~\,>}%La:L-}*A,A_&,-A*](\M*&!

Takes input on stdin as newline-separated list.
Online demo
If we didn't have to handle duplicate codewords, this could be shortened to 44:
q_N/\,{_W$m*:${~1$,<=},{~\,>}%La:L-}*](\M*&!

Or if CJam had an array subtraction which only removed one item from the first list for each item in the second, it could be 48...
Dissection
This is the Sardinas-Patterson algorithm but de-optimised. Since each dangling suffix only comes up at most once, running the main loop as many times as there are characters in the input (including separators) guarantees to be sufficient.
Note that I had to work around what is arguably a bug in the CJam interpreter:
"abc" "a" #   e# gives 0 as the index at which "a" is found
"abc" "d" #   e# gives -1 as the index at which "d" is found
"abc" ""  #   e# gives an error

So the prefix check is complicated to 1$,<= instead of \#!
e# Take input, split, loop once per char
q_N/\,{
  e# Build the suffixes corresponding to top-of-stack and bottom-of-stack
  _W$m*
  e# Map each pair of Cartesian product to the suffix if one is the prefix of the other;
  e# otherwise remove from the array
  :${~1$,<=},{~\,>}%
  e# Filter out empty suffixes iff it's the first time round the loop
  La:L-
}*
e# If we generated an empty suffix then we've also looped enough times to generate all
e# of the keywords as suffixes corresponding to the empty fix, so do a set intersection
e# to test this condition.
](\M*&!

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


text:
Scale up an image!
Your task is to write a program/function to scale up an image (list of strings) by a factor of n.
Specs

You will receive two inputs: an image, and a positive integer.
The image will only contain ASCII printable characters (U+0020-U+007F).

Scoring
This is code-golf. Shortest solution in bytes wins.
Testcases
Testcase 1
abc
xyz

2

aabbcc
aabbcc
xxyyzz
xxyyzz

Testcase 2
|_|

3

|||___|||
|||___|||
|||___|||

Can you please try to use the sandbox next time? I see that you have already gotten negative votes on two previous questions today, and now this one has been marked as a duplicate.

Actually, 23 bytes
╗'
@s`╜;)*(Zk♂ΣiΣn`M'
j

Takes the string input (with newlines represented as \ns to make multi-line input work) as the first input and the integer as the second.
Try it online!
Explanation (newlines replaced with \n):
╗'\n@s`╜;)*(Zk♂ΣiΣn`M'\nj
╗                          push n to reg0
 '\n@s                     split s on newlines
      `╜;)*(Zk♂ΣiΣn`M      for each line:
       ╜;)*(Z                make n copies and zip them
             k♂ΣiΣ           join the strings ("abc" -> ["abc", "abc"] -> "aabbcc" with n = 2)
                  n          make n copies of the result line
                     '\nj  join on newline

Actually, this is quite long... (Pyth may need not more than 10 bytes I reckon)

@KennyLau Actually doesn't do well with string manipulation. Its strength is math.

So, this looks like an old answer, but I don't think \n is actually part of CP437.


text:
The rice and chess problem
An Indian legend tells the story of the alleged inventor of the chess game, who impressed the emperor of India with his game so much that he would get rewarded with anything asked.
The man said he wanted to be paid in rice. He wanted a grain of rice for the first square of the chessboard, two for the second, four for the third, eight for the fourth, and so on, until the 64th square.
The emperor was amazed that the man asked for such a small reward, but as his mathematicians started counting, he ended up losing one of his provinces.
Task
Given the length of the side of a hypothetical chessboard (which is 8 on a default chessboard) and the multiplier between squares (which is 2 in the legend), calculate the number of grains of rice the emperor must pay to the man.
Notes

The side length will always be a positive integer. The multiplier could instead be any kind of rational number.
If your language of choice can't display very large numbers, it's okay as long as your program can correctly process smaller inputs.
Also if your language of choice rounds larger values (with exponential notations), it's okay if those values are approximately correct.

Testcases
Input (side length, multiplier) => Output
8, 2                            => 18446744073709551615
3, 6                            => 2015539
7, 1.5                          => 850161998.2854
5, -3                           => 211822152361
256, 1                          => 65536
2, 2                            => 15
2, -2                           => -5

Please note that the explicit formula
result = (multiplier ^ (side ^ 2) - 1) / (multiplier - 1)

Performs wrong on multiplier = 1, as
1 ^ (side ^ 2) - 1 = 0
1 - 1 = 0
0 / 0 != side ^ 2 (as it should be)

Scoring
This is code-golf. Shortest answer in bytes wins.

You probably want a test case where the multiplier is 1 and another where it is 0 (assuming both are valid). Also "anything" is pretty broad, does the square root of negative one count? How about "potato"? ;) I'd recommend "any real number" or something.

If your language of choose can't display too large numbers, it's ok as long as your program can correctly process smaller inputs Careful, that has caused problems in the past. http://meta.codegolf.stackexchange.com/a/8245/31716

Related: http://math.stackexchange.com/questions/203824/what-is-xy-how-to-understand-it/204461#204461

... it must have been a rich province, because even today, the yearly world production of rice is still less than 2^64 grains.

So you ask us to implement an explicit formula? f(s,m)=(m^(s^2)-1)/(m-1)? I bet that is a dupe.

I thought the formula would make this trivial, but it not working for m=1 means that both summing a list and a recursive/iterative expression seem to be competitive options in non-golfing languages.

@vsz Actually, the guy was killed. The amount added to the king giving away the entire kingdom to the man, so naturally the easier way out was taken.

@cst1992 the version I read says the man gave up on his request and got a province as a gift.

result = ... / (multiplier - 1), not +

This is s^m^2-1, right?

Jelly, 4 bytes
²b1ḅ

This uses the approach from @APLDude's clever APL answer.
Try it online! or verify all test cases.
How it works
²b1ḅ  Main link. Arguments: x (side length), y (multiplier)

²     Square; yield x².
 b1   Convert to base 1 (unary), yielding a list of x² ones.
   ḅ  Convert from base y to real number.
      This yields y^(x²-1) + ... + y + 1.

MATL, 6 bytes
2^:q^s

Try it online!
2^   % Take implicit input, say N, and square it: N^2
:q   % Generate array [0 1 ... N^2-1]
^    % Take implicit input, M, and compute [M^0 M^1 ... M^(N^2-1)]
s    % Sum of the array. Implicit display

APL, 10 bytes
⎕⊥1+0×⍳⎕*2

⎕ is used to read user input twice. If we store the side length in s and the multiplier in m, we get the following code.
m⊥1+0×⍳s*2

And here's how APL parses this code:

Or as a function train: ⊣⊥1⍴⍨⊢×⊢ (8 bytes) As an interactive REPL command, ⎕⊥×⍳⎕*2 (7 bytes) works as well.

Python, 40 bytes
lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)

Generates and evaluates a string like
1+m*(1+m*(1+m*(1+m*(0))))

that encodes the sum as a Hornerized polynomial with n*n terms.
A lot of different methods gave very similar byte counts:
#String evaluation
lambda n,m:eval('1+m*('*n*n+'0'+')'*n*n)   #40

#Direct summation
lambda n,m:sum(m**i for i in range(n*n))   #40
lambda n,m:sum(map(m.__pow__,range(n*n)))  #41

#Direct formula
lambda n,m:n*n*(1==m)or(m**n**2-1)/(m-1)   #40

#Iterative sequence
f=lambda n,m,j=0:j<n*n and 1+m*f(n,m,j+1)  #41
def f(n,m):s=0;exec"s=s*m+1;"*n*n;print s  #41

#Recursive expression
#Fails due to float imprecision of square root
f=lambda n,m:n and 1+m*f((n*n-1)**.5,m)    #39*

Ah right, my bad. Anyway, I really like seeing all the different approaches you took :)

Pyth, 6 bytes
1 byte saved thanks to @FryAmTheEggman.
s^Lvz*

Try it online!
Test suite.

JavaScript (ES2016/ES7), 31 29 28 bytes
a=>b=>(b**(a*a)-1)/--b||a*a

Just @Bassdrop Cumberwubwubwub and @Kaizo's ES6 version, but with exponentiation operator. :) (I didn't have enough reputation to comment instead.)
Edit: /+(b-1) changed to /--b (thanks @Neil).
Edit: now uses currying (thanks @MamaFunRoll).

Welcome to PPCG! Your answer is pretty good!

Welcome! The + operator was a test I forgot to edit out, so you can shave off 1 byte by omitting it :)

The formula doesn't work for m = 1 :3

@user6245072 are you on chrome canary? Or on node? If on node, enable harmony flag

Would /--b save you a byte or two?

@BassdropCumberwubwubwub and Neil thanks, I've made the changes. (Not had a chance to test though.)

@BassdropCumberwubwubwub seriously though, you should get the credit for this answer :) (well, and @Neil)

Currying can save you a byte. a=>b=>

Haskell, 25 bytes
n%m=sum$(m^)<$>[0..n*n-1]

Sums the list [m^0, m^1, ..., m^(n*n-1)].

Jelly, 6 bytes
²R’*@S

Try it online!

Javascript ES6, 59 37 35 34 bytes
a=>b=>(Math.pow(b,a*a)-1)/--b||a*a`

Thanks to @Kaizo for shaving off a whopping 19 bytes, @Neil for another 2 and @gcampbell for 1 more!
Try it here

f=
a=>b=>(Math.pow(b,a*a)-1)/--b||a*a

a.innerHTML='
'+
  [[8,2],
   [3,6],
   [7,1.5],
   [5,-3],
   [256,1],
   [2,2],
   [2,-2]].map(b=>`${b[0]}, ${b[1]} => ${f(b[0])(b[1])}`).join('
')+'
'

Alternative broken versions
32 bytes
(a,b)=>(Math.pow(b,a*a)-1)/(b-1)

Causes NaN for b==1.
30 bytes
(a,b)=>(Math.pow(b,a*a)-1)/~-b

Causes Infinity for b==1.5.
28 bytes
(a,b)=>~-Math.pow(b,a*a)/~-b

Outputs 1 for some valid testcases.
Old version for 59 bytes
(a,b)=>Array(a*a).fill``.reduce((c,d,i)=>c+Math.pow(b,i),0)

Why haven't you just treated the b==1 case in the 32 bytes case? 40 bytes: (a,b)=>b-1?(Math.pow(b, a * a)-1)/(b-1):a*a

@Kaizo you're right, I'm an idiot :D

/~-b is obviously no good for fractional b, but /--b should work, no?

By the way, I golfed the old version down to 47 bytes: (a,b)=>[...Array(a*a-1)].reduce(s=>s+=p*=b,p=1)

@Neil you're right, ofcourse. That's what you get when you rush your answers :p Thanks!

@BassdropCumberwubwubwub you can curry it to save a byte (thanks @MamaFunRoll).

MATLAB, 23 bytes
@(n,k)sum(k.^(0:n^2-1))

Test it here!

Java, 132 bytes
import java.math.*;Object e(int n,BigDecimal m){BigDecimal r=BigDecimal.ONE,a=r;for(n*=n;n>1;n--)r=r.add(a=a.multiply(m));return r;}

Ungolfed
import java.math.*;

Object e(int n, BigDecimal m) {
    BigDecimal r = BigDecimal.ONE, a = r;
    for (n *= n; n > 1; n--)
        r = r.add(a = a.multiply(m));
    return r;
}

Notes

This will work for arbitrarily big outputs as required by OP (Too bad Java supports big numbers, this would be shorter otherwise).

Outputs
Input:      8 2.0
Expected:   18446744073709551615
Actual:     18446744073709551615

Input:      3 6.0
Expected:   2015539
Actual:     2015539

Input:      7 1.5
Expected:   850161998.2854
Actual:     850161998.285399449204543742553141782991588115692138671875

Input:      5 -3.0
Expected:   211822152361
Actual:     211822152361

Input:      256 1.0
Expected:   65536
Actual:     65536

Input:      2 2.0
Expected:   15
Actual:     15

Input:      2 -2.0
Expected:   -5
Actual:     -5

Input:      263 359.9
Expected:   ?
Actual:     9709...[176798 digits]...7344.7184...[69160 digits]...6291

R, 18 bytes
sum(m^(1:s^2-1))

Explanation:
sum(               # Calculate sum
    m              # Multiplier
     ^             # Exponentiate
      (1:s^2-1))   # Generate sequence from 1 to s(ide)^2-1

05AB1E, 5 bytes
Code:
nL<mO

Explanation:
n      # Compute i ** 2
 L     # Push the list [1, ..., i ** 2]
  <    # Decrement by 1, [0, ..., i ** 2 - 1]
   m   # Power function with implicit input, [0 ** j, ..., (i ** 2 - 1) ** j]
    O  # Sum that all up

Try it online!.

Haskell, 30 bytes
n#m=sum$take(n^2)$iterate(*m)1

or equally long
n%1=n^2
n%m=(m**(n*n)-1)/(m-1)

The first version starts with 1 repeatedly multiplies with m. Then it sums the first n^2 numbers of this sequence. The second version is the explicit formula as seen in other answers.

Can't you just do n#m=sum$(m^)<$>[0..n*n-1]?

@xnor: oh, that's nice. I think it's different enough for a separate answer. Please post it yourself.

J, 10 bytes
+/@:^i.@*:

Usage
I mark some integers with the x suffix to use extended integers to get exact results.
   f =: +/@:^i.@*:
   2x f 8
18446744073709551615
   3x f 6
75047317648499560
   6x f 3
2015539
   1.5 f 7
8.50162e8
   _3x f 5
211822152361
   1 f 256
65536
   2 f 2
15
   _2 f 2
_5

Explanation
+/@:^i.@*:
        *:  Square the value s to get s^2
     i.@    Make a range from 0 to s^2 exclusive, [0, 1, ..., s^2-1]
    ^       Using m as the base, calculate the power with the range
            [m^0, m^1, ..., m^(s^2-1)]
+/@:        Sum the entire list and return it

6 bytes #.*:$* as per APL Dude.

PostgreSQL, 67 66 bytes
SELECT SUM(m^v)FROM(VALUES(3,6))t(s,m),generate_series(0,s*s-1)s(v)

SqlFiddleDemo
Input: VALUES(side, multiplier)

EDIT:
Input moved to table, all cases at-once:
SELECT s,m,SUM(m^v)FROM i,generate_series(0,s*s-1)s(v)GROUP BY s,m

SqlFiddleDemo
Output:
╔══════╦══════╦══════════════════════╗
║  s   ║  m   ║         sum          ║
╠══════╬══════╬══════════════════════╣
║   7  ║ 1.5  ║ 850161998.2853994    ║
║   2  ║ 2    ║ 15                   ║
║   2  ║ -2   ║ -5                   ║
║ 256  ║ 1    ║ 65536                ║
║   5  ║ -3   ║ 211822152361         ║
║   8  ║ 2    ║ 18446744073709552000 ║
║   3  ║ 6    ║ 2015539              ║
╚══════╩══════╩══════════════════════╝

Mathcad, [tbd] bytes (~11)

Uses Mathcad's built in summation operator.  Also demonstrates symbolic processor simplification to generate exact formula.
Mathcad effectively runs two processing engines in parallel - one a standard IEEE 64/80 bit floating point, and the other an arbitrary number length symbolic process (MuPad).  Standard numerical evaluation is indicated by equals sign (=), whilst a right arrow indicates symbolic evaluation.

Mathcad counting scheme yet to be determined so no byte count given.
ctl-$ enters the summation operator (Sigma), including empty placeholders to put the summation variable, initial value, final value and expression. Approximate byte-equivalent count = 11.

where is the code ?

The "code" for the actual challenge is the first summation sign (capital Sigma) you see under the heading "Challeng Solution".  The other bits of "code" are given under the heading "Solution Variants".   What you see in the image is exactly what gets written down on a Mathcad worksheet - Mathcad uses mathematical symbols for various operations, such as a vector sum or product, function integration or differentiation, or logical operations.  Most operators can be input with a key combination (for example, ctl-4 for an implicit vector sum or ctl-& for an iterated sum), or via a menu or toolbar.

Python, 40 bytes
lambda l,m:sum(m**i for i in range(l*l))

lambda l,m:(m**(l*l)-1)/(m-1)

In regular languages using formula would be shorter. I used map because in esolangs maps would be shorter.

Where's the strikethrough?

@KennyLau I was still working on my answer, I posted this before seeing your comment.

Alright, (7 more to go...)

Wouldn't work if m==1...

TI-Basic, 19 bytes
S is side length, and M is the multiplier.
Prompt S,M:Σ(M^I,I,0,S²-1

Ruby: 39 bytes
->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

Test:
f = ->s,m{(0...s*s).reduce(0){|a,b|a+m**b}}

f[8,2]   # 18446744073709551615
f[3,6]   # 2015539
f[7,1.5] # 850161998.2853994
f[5,-3]  # 211822152361
f[256,1] # 65536
f[2,2]   # 15
f[2,-2]  # -5
f[1,1]   # 1

When did Ruby get a sum function??? This is gamechanging

Oh no! What I thought was a ruby core method is in fact a rails method sad face.  I've updated the answer.

Can you just change your language to Rails? I don't know about any imports you might need for that

Python, 41 Bytes
Totally new at this golfing thing, criticism welcome!
lambda n,m:sum(m**i for i in range(n**2))

It's actually quite good ; )

Haha, thanks. I had to google how to do lambdas in python again, since I haven't touched python in a while.

Welcome to Programming Puzzles & Code Golf! This is a nice answer, but it's rather similar to this one.

Ah, I didn't see if there were any other solutions. Did he save a byte by doing l**l instead of what I did?

l*l actually, which is shorter than l**2.

Jolf, 18 15 10 bytes
Thanks to Cᴏɴᴏʀ O'Bʀɪᴇɴ for saving 3 bytes and pointing me towards mapping
uΜzQjd^JwH

Try it here!
 ΜzQj       Map over an array of 1 -> square(side length)
     d^JwH  Set the current array value to multiplier^(current value - 1)
u           Sum the array

Nice work! You can remove the a before the zeta, as that is implicitly outed. You can also use Mu (map) instead of for each, and I think you can replace the D with a d and remove the ending }.

@Cᴏɴᴏʀ O'Bʀɪᴇɴ Neat, keep forgetting about the implicit parts of Jolf, they are certainly some of the best ways to shave off a few bytes.

Mathematica, 22 bytes
Tr[#^(Range[#2^2]-1)]&

Creates a range of {1, 2, ... s^2}, subtracts 1 over it to make {0, 1, ..., s^2-1}. Then raise each to the power of m making {m^0, m^1, ..., m^(s^2-1)} and return the sum of it.
Alternatively, Mathematica can use the explicit formula by taking its limit. This requires 29 bytes.
Limit[(s^#^2-1)/(s-1),s->#2]&

You could write your first version as Tr[#^Range[#2^2]/#]&

CJam, 9 bytes
q~2#,f#:+

Inputs are in reverse order separated by a newline or a space.
Try it online!
q~    e# Read input. Evaluate: pushes the two numbers, M and N, onto the stack
2#    e# Square: compute N^2
,     e# Range: generates array [0 1 ... N^2-1]
f#    e# Compute M raised to each element of the array [0 1 ... N^2-1]
:+    e# Fold addition: compute sum of the array [M^0 M^1 ... M^(N^2-1)]

PHP, 58 54 bytes
<?function a($n,$m){$n*=$n;echo(1-$m**$n)/(1-$m)?:$n;}

This just uses the summation formula to show the value, after checking if the multiplier is 1 (which returns NAN in the formula).

PARI/GP, 25 bytes
f(s,m)=sum(i=0,s^2-1,m^s)

Longer but faster (35 bytes):
f(s,m)=if(m==1,s^2,(m^s^2-1)/(m-1))

Cute (30 bytes):
f(s,m)=vecsum(powers(m,s^2-1))

Lua, 54 47 bytes
r=0l,m=...for i=0,l^2-1 do r=r+m^i end print(r)

Run from the command line with the board side length as the first argument and the multiplier as the second.
Thanks to user6245072 for saving 6 bytes, and Katenkyo for saving an additional 1.

Original 54 byte version:
a,b=...c=1 d=1 for i=2,a^2 do c=c*b d=d+c end print(d)

Hello, and welcome to PPCG! Great answer!

l,m=...r=0 for i=0,l^2 do r=r+m^i end print(r)

This should save some bytes.

renaming d saves one byte because it allows to skip the space in c=1 d=1 => a,b=...c=1g=1 for i=2,a^2 do c=c*b g=g+c end print(g). if @user6245072 's suggestion works, you could save a byte on the same principle => r=0l,m=...for i=0,l^2 do r=r+m^i end print(r)

The whitespace between r=0 and l,m=... is anyway compulsory, so it doesn't change. Also the loop should be  for i=0,l^2-1 but this is my fault lol.

C#, 56 bytes
double f(int n,double q){return(Math.Pow(q,n*n)-1)/--q;}

Testcase 256, 1?

Is it not 256^2?

(Math.Pow(1, 256 * 256) - 1) / --1 = 0/0.

You need either using System; or System.Math.Pow. And your code doesn't work, when q=1, as stated by @user6245072.

J, 17 bytes
A non-tacit solution, by defining a dyad:
f=:4 :'+/y^i.x^2'

e.g.
8x f 2

18446744073709551615

, 11 chars / 14 bytes
⨭⩥ î²)ⓜⁿ⁽í$

Try it here (Firefox/WebKit Nightly only).
Yes,  now works in WebKit Nightly! Chrome support is next.
Explanation
⨭⩥ î²)ⓜⁿ⁽í$ // implicit: î = input1, í = input2
   ⩥ î²)       // generate a range [0..î^2)
                     ⓜ      // map over range ($ is mapitem):
        ⁿ⁽í$  //   í^$
⨭            // sum resulting range
              // implicit output

RETURN, 32 bytes
[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

Try it here.
Anonymous lambda that leaves result on Stack2. Usage:
8 2[a:2^0\
{[$¥][a;\^]#[¤¥][+]#]!

Explanation
[                              ]!  lambda
 a:                                store multiplier to a
   2^                              square side-length
     0\␊                           create range [0..result)
        {                          set current stack to range
         [  ][     ]#              while loop
          $¥                         check if TOS is truthy
              a;\^␌                  if so, push a^TOS to Stack2
                     ␁            set current stack to Stack2
                       [¤¥][+]#    sum Stack2

Actually, 9 bytes
╗²r`╜ⁿ`MΣ

Takes input as side length first, then multiplier.
Try it online!
Explanation:
╗²r`╜ⁿ`MΣ
╗          save m to reg0
 ²r        range(s**2) ([0, s**2-1])
   `  `M   map (for n in list):
    ╜ⁿ       m**n (m is pushed from reg0)
        Σ  sum

Pyke, 5 bytes
XUm^s

Try it here!
X     - input()**2
 U   - range(0,^)
  m^  - map(^,^)
    s - sum(^)

MathGolf, 4 bytes
²r#Σ

Try it online!
Explanation
Basically a port of Luis Mendo's MATL answer, but uses some implicit operating magic of MathGolf.
²      Square the first input
 r     Create range [0, 1, ..., N^2-1]
  #    Map (2nd input)^i for i in the array
   Σ   Sum the array

Thunno 2 S, 3 bytes
²L*

Try it online!
Port of Luis Mendo's MATL answer.
Explanation
²L*  # Implicit input
²    # Square the first input
 L   # Push [0..that)
  *  # Take the second input
     # to the power of each
     # Sum the resulting list
     # Implicit output

C#, 48 bytes
x=>y=>x==1?y*y:(System.Math.Pow(x,y*y)-1)/(x-1);

Where x is the multiplier, y is the side length. It uses the explicit formula for the sum of the geometric series, which is a1*(q^n-1)/(q-1), if q!=1, n*a1, if q==1.

k, 16 11 bytes
Bytes shaved using the technique from a clever answer.
{y/(x*x)#1}

Try it online! (There seems to be some sort of rounding happening for large numbers.)
Explanation:
{         } /function, x is board length, y is multiplier
   (x*x)#1  /make a list with as many 1s as there are board squares
 y/         /read as base y number

Powershell, 48 bytes
param($l,$m,$r)$c=1;1..$l*$l|%{$r+=$c;$c*=$m};$r

Test script:
$f = {
    param($l,$m,$r)$c=1;1..$l*$l|%{$r+=$c;$c*=$m};$r
}

@(
    ,(8, 2    ,18446744073709551615)
    ,(3, 6    ,2015539)
    ,(7, 1.5  ,850161998.2854)
    ,(5, -3   ,211822152361)
    ,(256, 1  ,65536)
    ,(2, 2    ,15)
    ,(2, -2   ,-5)
) | %{
    $x,$n,$e = $_
    $r = &$f $x $n
    "$($e-eq$r): $r $e"
}

Output:
False: 1.84467440737096E+19 18446744073709551615
True: 2015539 2015539
False: 850161998.285399 850161998.2854
True: 211822152361 211822152361
True: 65536 65536
True: 15 15
True: -5 -5

Differences from rounding are permitted by rules.
$r is a local parameter. If a parameter omitted in a caller then $r will have the value $null.

Japt -x, 5 bytes
²o!pV

Try it

Could you add an explanation of your solution for those not familiar with Japt?

F#, 51 bytes
let c s m=Seq.init(s*s)(fun x->m**float x)|>Seq.sum

Fairly straight-forward. Works as well when m is 1.
Try it online!


text:
Print the Nth non-palindromic number
A palindromic number (in case you don't know) is a number which reads the same backwards and forwards (example, 11). The first 15 non-palindromic numbers are: 10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26. This is A029742. I constantly need these numbers, but my sticky note pad is very small, so your code must be as short as possible.
Rules

Each submission must be a full program or function (e.g. in C, you can't just define a function without headers, but you can define a function WITH necessary headers
).
If it is possible, provide a link to a site where your program can be tested.
Your program must not write anything to STDERR.
You can take input as an argument or from STDIN (or the closest alternative in your language).
Programs are scored according to bytes. The usual character set is UTF-8, if you are using another please specify.
Standard loopholes are forbidden.

Test Cases
1
==> 10

-----

5
==> 15

-----

12
==> 23

Scoring
This is code-golf, so least bytes wins.
Submissions
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

/* Configuration */

var QUESTION_ID = 79251; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];

  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '
' + c.body.replace(OVERRIDE_REG, '') + '
';
    });

    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });

  });

  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;

    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (/ b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Any testcases ?

@KennyLau I'll do some.

Can we use a 0-based index, so 15 would be the 4th number?

@nimi Either, but please specify if yours is 0-indexed.

@nimi Sorry, that's what I meant, have edited to clarify.

Any restriction on completion time?

@cat I guess not, as long as it completes...

Pyth, 7 bytes
e.f!_I`

Test suite
Explanation:
e.f!_I`
e.f!_I`ZQ    Implicit variable introduction.
 .f     Q    Find the first Q numbers whether the following is truthy,
             starting at 1, where Q is the input.
      `Z     Convert the number to a string.
     _I      Check if it's the same when reversed.
    !        Logical not.
 e           Return the last element of the list.

Haskell, 38 bytes
([x|x<-[1..],(/=)<*>reverse$show x]!!)

Uses 0-based index. ([x|x<-[1..],(/=)<*>reverse$show x]!!) 11 -> 23.
The test whether to keep a number (/=)<*>reverse$show x translates to (show x) /= (reverse (show x)), i.e check if the string representation of the number does not equal the reverse of the string representation.

Brachylog, 14 11 bytes
;0{<≜.↔¬}ⁱ⁽

-3 bytes tanks to Fatalize
Explanation
; {      }ⁱ⁽        --  Find the nth number
 0                  --      (starting with 0)
   <                --      which is bigger then the previous one
    ≜               --      make explicit (otherwise it fucks up)
      .             --      which is the output
       ↔            --      and if reversed
        ¬           --      is not the output

Try it online!

;İ{ℕ≜.↔¬}ᶠ⁽t is 2 bytes shorter.

Actually, using iterate is 1 byte shorter: ;0{<≜.↔¬}ⁱ⁽

Jelly, 9 bytes
1 bytes thanks to @Sp3000.
ṚḌ_
0Ç³#Ṫ

Try it online!
Test suite.
Explanation
DUḌ_   Helper link. Check if x is not palindrome.

D      Convert to decimal.
 U     Reverse.
  Ḍ    Convert back to integer.
   _   Subtract x from the result above.
       For 23, this will yield 32-23 = 9.
       Only yield 0 (falsy) if x is palindrome.
       If x is not a palindrome,
       it will return a truthy number.

0Ç³#Ṫ  Main link.

0      Start from 0.
   #   Find the first         numbers:
  ³                   <input>
 Ç         where the above link returns a truthy number.
    Ṫ  Yield the last of the matches.

Fun fact: try 123Ṛ

@Sp3000 Very interesting indeed!

You can drop the ³. If you place the input on STDIN, you can drop the 0 as well. (In the latest version of Jelly, ṚḌ_ø#Ṫ works too, but it is newer than this challenge.)

Doesn't work for me...

7 bytes but it may use newer features

05AB1E, 8 bytes
Code:
µNÂÂQ>i¼

Uses CP-1252 encoding. Try it online!.

This has most likely something to do with the old version of 05AB1E, but out of curiosity: why the double bifurcated Â? PS for anyone else reading this: Can now be 5 bytes µNÂÊ½.

@KevinCruijssen: Likely due to no implicit output of N (only top of stack). Also, it can be 4 bytes now as the ½ is also implicit.

@Emigna Ah, completely forgot about ½ being implicit, even though I mentioned it in a tip I wrote myself.. >.< Thought the ¼ (increase counter_variable by 1) was implicit for the while-loop µ for a moment, but it's indeed the ½ (if top of the stack is 1: increase counter_variable by 1) instead..

Clojure, 62 bytes
#(nth(for[i(range):when(not=(seq(str i))(reverse(str i)))]i)%)

0-indexed. Generate lazily infinite range of non-palindromic numbers using list comprehension and take ith one. See it online: https://ideone.com/54wXI3

PowerShell v2+, 65 bytes
for(;$j-lt$args[0]){if(++$i-ne-join"$i"["$i".length..0]){$j++}}$i

Loops through numbers from 0 (implicit value for uninitialized $i) until we find input $args[0] many matches, then outputs the last one. Note that we don't initialize the loop, so $j=0 is implicit.
Each iteration, we pre-increment $i, and check if it's not-equal to $i reversed. If so, that means we've found a non-palindrome, so increment $j. The loop then continues as many times as necessary.
Examples
PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 100
120

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 5
15

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 55
70

PS C:\Tools\Scripts\golfing> .\print-nth-palindromic-number.ps1 212
245

Python 2, 60 bytes
f=lambda n,i=0,j=1:j>n and i-1or f(n,i+1,j+(`i`!=`i`[::-1]))

A one-indexed function that takes input of n via argument and returns the nth non-palindromic number.
How it works
This is an exhaustive recursive search, which consecutively tests integers i in the range [1,∞) until n non-palindromic numbers have been found; since i is pre-incremented, i-1 is then returned. Testing whether a number is palindromic is performed by converting to a string, reversing, and then checking whether the original and reversed strings are equal.
The code is logically equivalent to:
def f(n,test=0,count=1):
    if count>n:
        return test
    elif str(test)!=reversed(str(test)):
        return f(n,test+1,count+1)
    else:
        return f(n,test+1,count)

which itself is essentially:
def f(n):
    test=0
    count=1
    while count<=n:
        if str(test)!=reversed(str(test)):
            count+=1
        test+=1
    return test-1

Try it on Ideone

Clojure, 62 bytes
#(nth(filter(fn[i](not=(seq i)(reverse i)))(map str(range)))%)

A quite different approach than the other answer, but equal length.

Forth (gforth), 103 99 bytes
: f 9 swap 0 do begin 1+ dup 0 over begin 10 /mod >r swap 10 * + r> ?dup 0= until = 0= until loop ;

Try it online!
Explanation
Loop n times, each iteration finds the next non-palindromic number by incrementing a counter by 1 until the number doesn't equal itself reversed
Ungolfed Code
Normally I wouldn't "ungolf" the code, but since this code is somewhat messy I figured it would help
: reverse ( s -- s )
    0 swap
    begin
        10 /mod
        >r swap
        10 * +
        r> ?dup 0=
    until
;

: f ( s -- s )
    9 swap 0
    0
    do
        begin
            1+ dup dup
            reverse =
        0= until
    loop
;

Code Explanation
: f                \ start a new word definition
  9                \ start at 9, since all positive ints < 10 are palindromic
  swap 0           \ set up loop parameters from 0 to n-1
  do               \ start a counted loop
    begin          \ start an indefinite loop
      1+ dup       \ increment counter and place a copy on the stack
      ( Reverse )
      0 over       \ add 0 to the stack (as a buffer) and copy the top counter above it
      begin        \ start another indefinite loop
        10 /mod    \ get the quotient and remainder of dividing the number by 10
        >r         \ store the quotient on the return stack
        swap 10 *  \ multiply the current buffer by 10
        +          \ add the remainder to the buffer
        r>         \ grab the quotient from the return stack
        ?dup       \ duplicate if not equal to 0
        0=         \ check if equal to 0
      until        \ end inner indefinite loop if quotient is 0
      ( End Reverse )
      = 0=         \ check if counter =/= reverse-counter
    until          \ end the outer indefinite loop if counter =/= reverse-counter
  loop             \ end the counted loop
;                  \ end the word definition

R, 133 117 93 76 bytes
-16 bytes thanks to JayCe. -41 bytes thanks to Giuseppe.
x=scan();while({F=F+any((D=T%/%10^(1:nchar(T)-1)%%10)!=rev(D));F<=x})T=T+1;T

Try it online!

You can some some bytes abusing F, etc.: TIO. Also, why are you restricting the loop to (0:97)+10 ?

use tip #3 from my answer Tips for Golfing in R to extract the digits; you can do all(D==rev(D)) where D is a vector of digits. I believe a while loop will be shorter, and as @JayCe asks, why are you only checking numbers between 10 and 107?

@Giuseppe Updated with your recommendations. Still a little confused on how to implement a while loop while at the same time saving bytes.

@RobertS. if you have any questions, feel free to ping me in the R chatroom!

Perl 6, 29 bytes
{grep({$_!= .flip},^Inf)[$_]}

( uses 0 based index )
{         # The $_ is implied above
  grep(   # V
    { $_ != $_.flip }, # only the non-palindromic elements of
    ^Inf               # an Infinite list ( 0,1,2,3 ...^ Inf )
  )[ $_ ]              # grab the value at the given index
}

Usage:
my &non-palindrome = {grep({$_!= .flip},^Inf)[$_]}

say non-palindrome 1  - 1; # 10
say non-palindrome 5  - 1; # 15
say non-palindrome 12 - 1; # 23

# this also works:
say non-palindrome 0..20;
# (10 12 13 14 15 16 17 18 19 20 21 23 24 25 26 27 28 29 30 31 32)

Actually, 17 bytes
;τR9+;`$;R=Y`M@░E

Try it online!
Values are 1-indexed. This could be easily changed to 0-indexed by replacing the first R with r. But, R is what I initially typed, so that's what I'm going with.
The nonpalindromic numbers satisfy a(n) ≈ n + 10, so 2n+9 is a sufficient upper bound.
Explanation:
;τR9+;`$;R=Y`M@░E
;τ9+R;             push n, range(1,(2*n)+10)
      `$;R=Y`M@░   take values that are not palindromic
                E  take nth element

Java 8, 117 95 94 bytes
n->{int r=10;for(;n-->0;)if((++r+"").contains(new StringBuffer(r+"").reverse()))r++;return r;}

0-indexed
Explanation:
Try it here.
n->{             // Method with integer as both parameter and return-type
  int r=10;      //  Result-integer, starting at 10
  for(;n-->0;)   //  Loop an amount of times equal to the input
    if((++r+"")  //   First raise `r` by 1, and then check if `r`
               .contains(new StringBuffer(r+"").reverse()))
                 //   is the same as `r` reversed (and thus a palindrome)
      r++;       //    And if it is: raise `r` by 1 again
  return r;}     //  Return result-integer

@ceilingcat That gives incorrect results.. new StringBuffer(int) is not equal to new StringBuffer(String), nor is String.equals(StringBuffer) instead of String.equals(String).. This is an old answer however, so I can use (++r+"").contains(new StringBuffer(r+"").reverse()) to save 1 byte.

Ruby, 54 bytes
This function is 1-indexed and is partially based on Dom Hastings's Javascript answer. I think there's a way to golf this better, especially with that last ternary condition. Also, this function currently returns a string, which may need to be edited later. Any golfing suggestions are welcome.
f=->x,y=?9{x<1?y:(y.next!.reverse!=y)?f[x-1,y]:f[x,y]}

Ungolfed:
def f(x, y="9")
 if x<1
  return y
 else
  y = y.next
  if y.reverse != y
   return f(x-1, y)
  else
   return f(x, y)
  end
 end
end

Javascript (using external library) (97 bytes)
n=>_.Sequence(n,i=>{i=_.From(i+"");if(!i.Reverse().SequenceEqual(i)){return i.Write("")}}).Last()

Link to lib: https://github.com/mvegh1/Enumerable
Code explanation: Library has static method called Sequence, where first param defines how many elements the sequence will guarantee to create, and the 2nd parameter is a predicate accepting the current iteration value, "i". The predicate converts the integer to a string, which gets converted to a char array by calling _.From. The char array is compared against the reversal of the char array, and if they are not equal the char array is joined back into a string and returned. Otherwise, nothing is returned (i.e the result is undefined, which the library will always ignore). Finally, the last element of the sequence, i.e the Nth element is returned

C++ (GCC), 148 bytes
It's 1-based and the algorithm is really naive
#import <iostream>
using namespace std;int n,i=1;string s;main(){cin>>n;while(s=to_string(i+1),(n+=equal(begin(s),end(s),s.rbegin()))-i++);cout<<i;}

@enedil regarding your edit: #import is an compiler extension of gcc. It is deprecated, but this doesn't really matter here

C, 84 bytes
Function f(n) takes integer n and returns n-th non-palindromic number (1 based).
g(n,r){return n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;}

Test it on Ideone!
It's fairly trivial code, thus there is probably space for improvement.

Suggest n=n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)-s||s++);n=s; instead of return n?g(n/10,r*10+n%10):r;}s;f(n){for(s=9;n--;g(++s,0)==s&&s++);return s;

JavaScript (ES6), 54 bytes
Uses 1-based indexing. Only works up until the 7624th number.
d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a

Usage
d=(i,a=0)=>i?d(i-=++a!=[...''+a].reverse().join``,a):a
d(1)
10
d(123)
146
d(7624)
7800
d(7625)
// Uncaught RangeError: Maximum call stack size exceeded

JavaScript (ES6), 59 bytes
Doesn't use recursion and so can handle much larger inputs.
i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a")

Usage
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(1)
10
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(7625)
7801
(i=>eval("for(a=9;i-=++a!=[...`${a}`].reverse().join``;);a"))(123456)
124579

APL NARS 35 chars
r←v a;c
r←c←0
A:r+←1⋄c+←r≠⍎⌽⍕r⋄→A×⍳c2:'Tensor ',⍕v⋄v=2:'Matrix'⋄(v=1)∧''≡0↑⍵:'String'⋄''≡0↑⍵:'Char'⋄v=1:'List'⋄⍵≢+⍵:'Complex or Quaternion or Oction'⋄⍵=⌈⍵:'Int'⋄'Float'}
  h←{'Int'≢type ⍵:¯1⋄(⍵<1)∨⍵>2e5:¯1⋄v ⍵}
  h 1
10
  h 1.32
¯1
  h 7878
8057
  h¨3 5 12
13 15 23
  h 6 7 8
¯1
  h '123'
¯1
  h '1'
¯1
  h 1.0
10
  h 1.0003
¯1
  h ¯2
¯1
  h 0
¯1
  h 200000
201200
  h 200001
¯1

Japt, 14 ... 9 7 bytes
0-indexed.
È¦sw}iU

Try it
È¦sw}iU     :Implicit input of integer U
È           :Function taking an integer X as an argument
 ¦          :  Test for inequality with
  s         :  Convert to string
   w        :  Reverse
    }       :End function
     iU     :Get the Uth integer that returns true

Husk, 6 bytes
Yay for ↔ :)
!fS≠↔N

Try it online!
Explanation
 f   N  -- filter the naturals by:
  S≠    --   is it not equal to..
    ↔   --   ..itself reversed
!       -- index into that list

Perl 5, 33 + 1 (-p) = 34 bytes
map{1until++$\!=reverse$\}1..$_}{

Try it online!

C# 7, 89 bytes
n=>{int i=9;for(;n-->0;)if(Enumerable.SequenceEqual(++i+"",(""+i).Reverse()))i++;return i;}

1 indexed
Try on Repl.It
n=>
  int i = 9;                                  | Start at 9. Iterate exactly n times. Assume n >= 1
  for(;n-->0;)                                | Iterate n times
  if(EnumerableSequenceEqual(                 | Compare two sequences
  ++i+"",(""+i).Reverse())                    | Generate the forward and backward strings, which behave like char sequences for Linq
  i++                                         | If the sequences are equal, the number is a palindrome. Increment i to skip
  return i;                                   | Return the number after the for loop exits

I don't think this uses any language features from c# 7, but I put there since that's what I tested against

Welcome to PPCG.

TCC, 11 bytes
?>!~<>;i;'T

Try it online!
            | Printing is implicit
?>          | Find n-th number for which the following is "T":
  !~        | If not equal...
    <>;     | reverse. No value specified, so input is assumed.
       i;   | Input, since double semicolons are ignored
         'T | ... print string "T"

The link to try it online is dead