text:
In Search of a Soulmate
Given a nonempty finite list of integers, output a truthy value if there are exactly two equal entries and all other entries are distinct, and a falsey value otherwise.
Examples
truthy:
[1,1]
[1,2,1]
[1,6,3,4,4,7,9]

falsey:
[0]
[1,1,1]
[1,1,1,2]
[1,1,2,2]
[2,1,2,1,2]
[1,2,3,4,5]

I suppose we can't assume that the integers will always be less than 10?

Yes except if your language does not support any larger integers.

Can you elaborate what you mean by consistent?

Are the truthy and falsey values returned required to be the same regardless of the input, or could different falsey or truthy values be returned?

No they need to be truthy and falsey as defined.

Saw this on the top of HNQ & thought we’d reached the final interpersonal.se question

@gntskn Saw this on the top of SE's homepage and thought the same.

Allowing more than one soul mates couple would have add a bit of challenge, everyone is just posting code about removing duplicates and check that the length drop to the original length - 1.

@Walfrat Post it as your own challenge. Also such feedback is usually appreciated in the sandbox.

Are all values non-negative?

Yes you can assume that.

Python 3, 30 28 bytes
lambda m:len({*m})+1==len(m)

Try it online!
{*m} casts the list to a set object, an unordered list of items without duplicates. Doing this will always decrease the length of the list by the number of duplicates in it. By computing how much the length has changed, we can easily tell if the list had a single duplicate and return the result of the test.
-2 bytes thanks to ovs.

Exactly the solution I had, but forgot about the {*m} shortcut instead of set, well golfed!

27 bytes for the negation. (Falsey when it should be Truthy, etc)

Here's another weird way to do it (also negation): lambda m:~-len(m[len({*m}):])

Husk, 4 bytes
εṠ-u

Try it online!
Explanation
εṠ-u  Implicit input.
   u  Unique elements.
 Ṡ-   Delete them from input, counting multiplicities.
ε     Is the result a singleton list?

Haskell, 34 bytes
f x=[1|a<-x,b<-x,a==b]==1:1:(1<$x)

Try it online! Based on H.PWiz' answer.

Jelly, 8 5 bytes
QL‘=L

Try it online!
Explanation
QL‘=L  - Main link, argument L (a list)   e.g [1,6,3,4,4,7,9]
Q      - Deduplicated elements                [1,6,3,4,7,9]
 L     - Length                               6
  ‘    - Increment                            7
    L  - Length of the input                  7 ([1,6,3,4,4,7,9])
   =   - Are they equal?                      1

If the output values can be any consistent values, then QL_L works, which outputs -1 for truthy and any other non-positive number for falsey (thanks @JonathanAllan)

QL_L would output -1 for truthy and some number less than -1 or 0 for falsey (e.g. [1,6,3,4,4,7,9,9,9] would return -3, while [1,6,3,4,7,9] would return 0).

@JonathanAllan Oh yeah. I guess the examples I tested it on all happened to return -2.

MATL, 7, 6 bytes
&=sp4=

Try it online!
One byte saved thanks to @Guiseppe!
Explanation:
&=  % Table of pair-wise equality comparisons
    %
    % [1 0 0 0 0 0 0
    %  0 1 0 0 0 0 0
    %  0 0 1 0 0 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 1 1 0 0
    %  0 0 0 0 0 1 0
    %  0 0 0 0 0 0 1]
    %
s   % Sum each Column. Stack:
    %
    % [1 1 1 2 2 1 1]
    %
p   % Product of the array. Stack:
    %
    % [4]
    %
4=  % Compare the stack to '4'

Since s is sum and sum sums along the first non-singleton dimension (columns), and the matrix is symmetric, couldn't this just be s instead of Xs?

@Giuseppe Ah, TIL. Thankyou!

JavaScript (ES6), 30 bytes
a=>new Set(a).size==a.length-1

Try it online

Retina, 15 12 11 bytes
Thanks to Neil for saving 1 byte.
D`
Mm2`^$
1

Try it online!
Input is linefeed-separated. (The test suite uses comma-separation for convenience.)
Explanation
D`

Deduplicate the lines in the input, which removes any integer that has appeared before (but leaves the surrounding linefeed(s)).
Mm2`^$

Count the number of empty lines, which is equal to the number of duplicates we removed, but only consider the first two matches. So the output will only be 0 (no duplicates), 1 (one duplicate), 2 (two or more duplicates).
1

Make sure that exactly one duplicate was removed.

Save a byte by limiting the newline match to 2, so that the input to the third line is always 0, 1, or 2, simplifying the test. (Annoyingly you can't use A`. to count newlines, because it drops the last one.)

@Neil Thanks, the limit is a neat idea. I also tried using A\., but the problem is rather that you can't distinguish a single empty line from having no lines at all. Maybe I should consider terminating AandG` output with a linefeed if there are any lines. Although that should probably be an option since I can imagine that linefeed being annoying in other scenarios.

Matching a single empty line is easy - that's just ^$¶.

@Neil No, I mean that the output of A is identical regardless of whether it retains a single empty line or discards all lines.

Sorry, that's what I meant by "drops the last one" - it returns one fewer empty line, but then you can't distinguish between 0 and 1.

J, 7 6 bytes
=&#0,=

= check every element for equality with every unique element, creates a matrix with m rows for m unique elements.
0, add an empty row on top.
=&# does the number of rows equal the length of input?
Try it online!

I think you can replace .~ with =

@H.PWiz Nice, edited.

Octave, 25 bytes
This is not using a group or unique approach as many of the other answers, but rather the "cartesian product" of all possible comparisions.
@(x)nnz(triu(x==x',1))==1

Explanation
             x==x'        %create a matrix where the entry at (i,j) compares whether x(i) == x(ju)
        triu(x==x',1)     %only consider the strict upper triangular matrix
    nnz(triu(x==x',1))    %count the number of nonzero entries
@(x)nnz(triu(x==x',1))==1 %check whether this number is actually 1

Try it online!
And because no program would be complete without a convolution (thanks @LuisMendo for fixing a mistake):
Octave, 40 bytes
@(x)nnz(~conv(sort(x),-1:2:1,'same'))==1

Try it online!

You inspired me to come up with this approach :)

@StewieGriffin I think the MATL answer used your exact approach:)

Pushy, 8 bytes
Simple implementation of checking whether len(set(list)) == len(list)-1:
LtvuL^=#

Explanation:
       \ Implicit: Put all input on stack
Ltv    \ Get the stack length - 1, save in auxiliary stack
u      \ Remove non-unique elements
L      \ Get the new length
^=     \ Compare with the previously saved length
#      \ Print result

This works as the length will only decrease by 1 if there was only exactly 1 non-distinct integer in the initial list.
Try it online!

Wow, haven't seen a Pushy answer in ages! +1

@cairdcoinheringaahing Pushy will never die. It will only come back stronger.

R, 32 31 bytes
-1 byte thanks to @JarkoDubbeldam
cat(sum(duplicated(scan()))==1)

Try it online!
Reads from stdin, writes to stdout.
duplicated iterates through the list, replacing the values of l with TRUE if that value occurs earlier in the list, and FALSE otherwise. If there's a unique pair of soulmates, there should be exactly one TRUE value, so the sum should be 1.

31 bytes

@JarkoDubbeldam ah, of course. Good to see you again! It's been a while.

Been busy with some other stuff, not sure I'm completely back yet.

@Giuseppe, I just read this question and immediately thought of your Original Approach.... Very nice!  I would have never thought of the scan() approach.

K (ngn/k), 10 bytes
1=-/#'1?:\

Try it online!
A tacit version of {1=(#x)-#?x}.

1?:\ run a distinct-do-scan for one iteration, returning a two-item list containing the original input and the distinct items of the input
#' take the count/length of each item in that list
1=-/ is the difference between the counts one?

K (ngn/k), 8 bytes
2=*/#'=:

Try it online!
Checks if the product of the counts of unique elements is 2. This works because the only way to get the product of 2 is (1, 1, 1, ..., 1, 2) in some order.

PowerShell, 40 37 bytes
($args|sort -u).count-eq$args.count-1

Try it online!
The Sort-Object command (alias sort) with the -unique flag pulls out only the unique components of the input. For example, for input @(1,3,3,2), this will result in @(1,2,3).
Thus, we just need to make sure that the .count of this object (i.e., how many elements it has) is -equal to the .count of our input array -1 (i.e., we have exactly one duplicate entry).
Saved 3 bytes thanks to Sinusoid.
Fixed bug thanks to TessellatingHeckler.

Can you use the get-unique alias 'gu' instead of group to reach the same result?

@Sinusoid Yes, we can. Thanks!

This doesn't work on the second test case 1,2,1 - get-unique only works on pre-sorted input. How about ($args|sort -u).count-eq$args.count-1 which is also 37 but does work for all the test cases, if you call it like f 1 2 1 instead of f 1,2,1 ?

@TessellatingHeckler Ah, good catch. All of the testing I did was with pre-sorted input. Thanks!

05AB1E, 4 bytes
{¥_O

Try it online!
Outputs 1 as truthy, any other non-negative integer as falsy. In 05AB1E, 1 is the only truthy number (thanks @Emigna for the insight!).
Explanation
{       Implicit input. Sort
 ¥      Consecutive differences
  _     Boolean negate
   O    Sum. Implicit display

Ruby, 32 bytes
->(s){s.uniq.length==s.length-1}

Welcome to PPCG! Because this is code golf, you need to include the byte count of your program. I've taken the liberty of doing it for you this time.

How about Array#size?

You can get down to 26 bytes by using ->s{s.uniq.size==s.size-1}

Pyth, 6 bytes
qtlQl{

Verify all the test cases.

l{ - Gets the number of unique elements.

tlQ - Gets the length of the input list, decremented.

q - Checks equality.

7 bytes
q1l.-Q{

Verify all the test cases

C# (.NET Core), 35 + 18 bytes
+18 for using System.Linq.
n=>n.Distinct().Count()==n.Length-1

Try it online!
67 byte alternative without Linq:
n=>new System.Collections.Generic.HashSet<int>(n).Count==n.Length-1

Try it online!

Excel, 42 bytes
Danish language version
=TÆLV(A:A)=SUM(--(FREKVENS(A:A,A:A)>0))+1

Assumes each integer from the list in separate cell in column A.
If we were allowed for inconsistent falsey values, we could save 3 bytes:
=TÆLV(A:A)+SUM(-(FREKVENS(A:A,A:A)>0))

English language version (44 bytes)
=COUNTA(A:A)=SUM(--(FREQUENCY(A:A,A:A)>0))+1

Jelly, 10 bytes
ċ@€`QṢ⁼1,2

Try it online!
a longer but different approach

05AB1E, 6 5 bytes
{¥>ΘO

Try it online!
{¥>ΘO   # example input:               [1, 6, 3, 4, 4, 7, 9]
{       # sort                      -> [1, 3, 4, 4, 6, 7, 9]
 ¥      # get deltas                -> [  2, 1, 0, 2, 1, 2 ]
  >     # increment                 -> [  3, 2, 1, 3, 2, 3 ]
   Θ    # truthify (only 1 gives 1) -> [  0, 0, 1, 0, 0, 0 ]
    O   # sum                       -> 1

1 being the only truthy value in 05AB1E, we can stop here. (Thanks @Emigna for pointing that out.)
To get only two distinct values, we can optionally add:
     Θ  # equals 1?                 -> 1

If it is okay to return any falsey value for the falsey cases, you can skip the Θ, as 1 is the only truthy value in 05AB1E.

@Emigna Thanks! I was not sure whether it was approved by the OP, but I guess it is.

I'm afraid you need to revert to the previous solution as ¢ will not work. It would count [19,4,4,9] as false and [19,9] as true since it finds the 0 in 10.

@Emigna Thanks for spotting that. I think that's fixed.

{¥_O should be okay as well.

Yes, but now that's Luis' answer.

Ah, didn't see that. And Riley took your old answer. Guess you'll have to stay here then unless there is another strategy that can be used.

Haskell, 37 bytes
f x=sum[1|0<-(-)<$>x<*>x]==2+length x

Try it online!

Perl 5, 36 + 1 (-a) = 37 bytes
map$k{$_}++,@F;@a=keys%k;say@a+1==@F

Try it online!

may be golfed @k{@F}++;say@F==1+keys%k

05AB1E, 5 bytes
gIÙg-

Try it online!
g     # Get number of elements in input
 IÙg  # Get number of unique elements in input
    - # Subtract

In 05AB1E 1 is the only truthy  value, so for a truthy result there must be exactly 1 duplicate element removed by the uniquify.

Haskell, 37 bytes
f x=sum[1|a<-x,b<-x,a==b]==2+length x

Try it online!

Octave / MATLAB (with Statistics package / toolbox), 21 bytes
@(x)nnz(~pdist(x))==1

Anonymous function. Input is a column vector. Output is true (displayed as 1) or false (displayed as0).
Try it online!
Explanation
pdist(x) computes a vector of Euclidean distances between all pairs of rows from x. It considers each pair only once (order of the two rows doesn't matter), and doesn't consider pairs formed by the same row twice.
In our case x is a column vector, so Euclidean distance between two rows is just absolute difference between the two numbers.
~ is logical (Boolean) negation, nnz is number of nonzeros, and ==1 compares to 1. So the result is true if and only if there is only one pair that gives zero distance.

Julia, 39 26 bytes
!a=sum(a.==a')==endof(a)+2

Explanation
The code generates a 2-dimensional table of booleans, which is then collected using the sum function, counting the number of same-element pairs in the cartesian square of A. Then this is compared to the length of the string plus two, and the quantities are equal only when there is exactly one repeat character.
This code redefines the NOT operator.

!a=sum(a.==a')==endof(a)+2 saves a few bytes. Try it online!

Jq 1.5, 53 25 bytes
length-(unique|length)==1

Inspired by Riley's answer and much shorter then my original solution.
Try it online!

Octave, 23 26 bytes
@(x)prod(sum(x==x'))==4

Try it online!
The x==x' part was inspired by flawr's answer. This is longer than Luis' answer, but it doesn't use any toolboxes.
Explanation:
This is an anonymous function that takes a vector x as input, and compares it to itself transposed. This will give a matrix where all diagonal elements are 1, and any off diagonal elements signals that there are duplicates elements.
The sum along any given column shows how many duplicates there are of that number. We want two of the numbers to have a duplicate, so we two values equal to two, and the rest unequal to two.
If we take the product of this matrix, we'll get 4 if there are only two equal elements (2*2*1*1*1*1*...), and something other than 4 if there are no duplicates, or more than two.

PHP, 46 bytes
<?=count(array_unique($argv))==count($argv)-1;

Counts the number of entries in $argv and compares it to the number of unique entries. If the former is higher than the latter by 1 then truthy, else falsey.
Try it on eval.in!

Do you have to use the variable name $argv can you not just use $a instead?

@dading84 $argv is the list of command line parameters. So: no, he cannot just use $a.

APL (Dyalog Unicode), 7 bytesSBCS
1=≢-≢∘∪

Try it online!
Explanation:
1=≢-≢∘∪  ⍝ Monadic function train
    ≢∘∪  ⍝ Generate a list of unique items in the input,
         ⍝ and return the length of that list
  ≢-     ⍝ Take the length of the input and subtract the above
1=       ⍝ If the difference is 1, true, otherwise false

Uiua, 7 bytes
=1-⧻⊃⊝⧻

Try it!
=1-⧻⊃⊝⧻
    ⊃⊝⧻  # length and unique elements of input
   ⧻     # length (of unique elements)
  -      # subtract
=1       # is it equal to one?

Japt, 7 bytes
â Ê¶UÊÉ

Try it

Explanation
Remove duplicates (â), get length (Ê) and compare equality (¶) with the length (Ê) of the input (U) minus 1 (É).

Isn't that 12 bytes? Aren't âÊÉ¶ multibyte characters?

Clojure, 31 bytes
#(=(count(set %))(-(count %)1))

Try it online!
Does the same as LyricLy's answer

Welcome to PPCG!

Thanks! Hope this answer is ok, I felt like I was misusing TIO haha

Bash + coreutils, 36 bytes
sort|uniq -dc|grep -Pqz '^ *2 .*\n$'

Output is via exit code, where 0 is success (truthy) and 1 is failure (falsy).
Try it online!

C (GCC), 80 78 bytes
i,j,t;f(x,l)int*x;{for(i=t=0;i<l;++i)for(j=0;j<i;)t+=x[i]==x[j++];return!~-t;}

-1 thanks to Jonathan Frech
-1 thanks to Kevin Cruijssen
Try it Online!
f is a function that takes in an int* pointing to the list, and an int that is the length of the list, and returns 1 if there are exactly two equal entries and all other entries are distinct, and 0 value otherwise.
The function checks all pairs of numbers in the list, counting the number of pairs, and returns whether the number of pairs is 1.

return 1==t; can be return!~-t; to save a byte.

j<i;++j)t+=x[i]==x[j] can be j<i;)t+=x[i]==x[j++] to save a byte.

73 bytes

Java 8, 46 44 bytes
l->l.stream().distinct().count()==l.size()-1

-2 bytes thanks to @Nevay. (Old answer: l->new java.util.HashSet(l).size()==l.size()-1)
Explanation:
Try it here.
l->                // Method with List parameter and boolean return-type
  l.stream()       //  Stream over the List
   .distinct()     //  ignoring all duplicated items
   .count()        //  and get the total amount of non-duplicated items in the List
     ==            //   And check if it's size is equals to
       l.size()-1  //   the size of the input-list - 1
                   // End of method (implicit / single-line return-statement)

44 bytes: l->l.stream().distinct().count()==l.size()-1

Bash, 36, 35 bytes
for k;{ H[$k]=;};((${#H[@]}+1==$#))

TIO exit status 0: true, 1: false, ((..)) can be changed to echo $((..)), to see boolean value (1:true, 0:false)

Japt, 7 bytes
ÊÉ¶Uâ Ê
      Ê // Return whether the number of
   Uâ   // unique items in the input
  ¶     // is equal to
ÊÉ      // the input's length minus one.

Try it online!

Brachylog, 7 bytes
dl.&l-₁

Try it online!
Truthy/falsy input is achieved through predicate success/failure, as if this predicate is run as the entire program on a single input, it will print true. if it succeeds and false. if it fails. The header on TIO is there so you can run all of the cases at once.
dl         The length of the input with duplicates removed
  .        is the output variable,
   &       and
    l-₁    so is the length of the input minus 1.

Regex (ECMAScript), 69 67 bytes
The input is in the form of a comma-delimited list of nonnegative integers in decimal.
^(?=.*\b(\w+\b).*,\1\b)(?!(.*\b\1\b){3}|.*\b(?!\1\b)(\w+\b).*,\3\b)

Try it online!
^
(?=
    .*\b(\w+\b)          # \1 = an element that occurs at least twice
    .*,\1\b              # locate the second occurrence of \1; since there's at least one
                         # element before it, it's guaranteed to have a commma in front
)
(?!
    (.*\b\1\b){3}        # Assert that \1 does not occur 3 or more times
|
    .*\b(?!\1\b)(\w+\b)  # \3 = any element that's different from \1
    .*,\3\b              # Assert that \3 does not occur again; since there's at least one
                         # element before it, it's guaranteed to have a commma in front
)

Regex (ECMAScript), 67 65 bytes
^(?=.*(\bx+\b).*,\1\b)(?!(.*\b\1\b){3}|.*\b(?!\1\b)(x+\b).*,\3\b)

Try it online!
This is a straight port of the decimal version to positive unary, changing both occurrences of \w+ to x+. Input is a list of positive unary numbers separated by ,. Each one is a string of xs whose length represents the number.
Regex (ECMAScript), 92 bytes
This version fully supports nonnegative unary. That is very costly; \b can no longer be used at all. The part that ballooned the most in length was where it's asserted that no element other than \2 is repeated 3 or more times, because with a simple {3} loop, it would get a false negative due to falsely finding a repeated zero consisting of 3 repeated zero-width matches with no commas consumed.
^(?=.*(^|,)(x*(?!x)).*,\2(?!x))(?!.*(^|,)(\2(?!x)(.*,\2(?!x)){2}|(?!\2(?!x))(x*(?!x)).*,\6(?!x)))

Try it online!
^
(?=
    .*(^|,)(x*(?!x))          # \2 = an element that occurs at least twice
    .*,\2(?!x)                # locate the second occurrence of \2; since there's at least one
                              # element before it, it's guaranteed to have a commma in front
)
(?!
    .*(^|,)
    (
        \2((?!x).*,\2){2}     # Assert that \2 does not occur 3 or more times
    |
        (?!\2(?!x))(x*(?!x))  # \6 = any element that's different from \2
        .*,\6                 # Assert that \6 does not occur again; since there's at least one
                              # element before it, it's guaranteed to have a commma in front
    )
    (?!x)
)

Jelly, 4 bytes
QṁƑḊ

Try it online!
Q       Is the input uniquified
 ṁƑ     the same length as
   Ḋ    the input without its first element?

Mathematica, 26 bytes
(l=Length)@Union@#+1==l@#&

Try it online!

Convex, 7 bytes
_Å,)\,=

Try it online!

Batch, 131
set b=,%*,
goto j
:l
call set f=%%b:,%1,=,#,%%
if "%b%"=="%f%" exit 1
set b=%f%
goto:eof
:j
FOR %%A IN (%b%) DO call :l %%A

The %errorlevel% can be checked for the result. it works by tokenising the input, FOR %%A IN (%b%) DO call :l %%A every instance of that token + to commas is then replaced in a copy of the input with a ",#," call set f=%%b:,%1,=,#,%% the resulting string is then compared to the copy of the previous string. If there is no change in the string, it is because that number has already occured.
c:\>batfile.bat 1,2,3

Batch, 109 bytes
@set/ap=1,s=0
@for %%x in (%*)do @(for %%y in (%*)do @set/a"s+=!(%%x-%%y)")&set/ap*=s,s=0
@if %p%==4 echo 1

Port of @DJMcMayhem's answer.

Perl 5, 25+1 (-p)=26 bytes
$H{$_}=1}{$\=$.-1==keys%H

TIO

Perl 6, 12 bytes
{.Set+1==$_}

Try it online!
Convert to Set, test if the number of elements is less by one.

R, 40 bytes
sum(outer(x<-scan(),x,"=="))==2+sum(x|1)

Try it online!
Approach is different from the other R solution - and not as golfy...

Nit's Japt answer can (I think) be ported but using unique is certainly close-ish to duplicated

12-basic, 31 bytes
FUNC S(L)?LEN(L|L)==LEN(L)-1END

The | (union) operator returns an array containing elements that are in both of the input arrays. As a side effect, it removes duplicates.

Pari/GP, 16 bytes
a->#a==#Set(a)+1

Try it online!

R, 38 bytes
Not quite as golfed as another R answer, but a different approach.
length(a<-scan())-length(unique(a))==1

Try it online!

F#, 49 bytes
let s c=Seq.distinct c|>Seq.length=Seq.length c-1

Try it online!
Seq.distinct creates a sequence of all the unique elements in the collection. If the number of distinct elements is one less than the original collection, there are soulmates.

Javascript,96 bytes
for(i=0;i<a.length;i++)for(j=0;j<a.length;j++)(a[i]==a[j]&& i!=j)?count++:0 console.log(count==2)

And a better readable format
for(i=0;i<a.length;i++){
  for(j=0;j<a.length;j++){
   (a[i]==a[j]&& i!=j)?count++:0
  }
}
 console.log(count==2)

GolfScript, 7 bytes
.,\.&,-

Try it online!
.,\.&,- # Stack will be show as [], with L being our list.
.       # Duplicate array [L L]
 ,      # Size of top element [L N]
  \     # Swap the positions of the top two elements [N L]
   .&   # Listwise OR (remove duplicates) [N L&]
     ,  # Size of top elements (should be 1 lesser) [N N-1?]
      - # Difference

Output is 1 if TRUE. Any other result is FALSE.

Factor, 25 bytes
[ duplicates length 1 = ]

Try it online!
Explanation
It's a quotation (anonymous function) that takes a sequence as input and leaves a boolean as output. Assuming { 1 6 3 4 4 7 9 } is on top of the data stack when this quotation is called...

duplicates Obtain a list of duplicate values. Stack: { 4 }
length Get the length. Stack: 1
1 Push 1 to the stack. Stack: 1 1
= Return t if the top two objects on the data stack are equal, otherwise return f. Stack: t


text:
I am greater than you!
Write a function or program that given a list of non negative integers, arranges them such that they form the largest possible number.
INPUT
[50, 2, 1, 9]

OUTPUT
95021

INPUT
0

OUTPUT
0

INPUT
(Interesting one)
[7, 76]

OUTPUT
776

RULES

standard loopholes apply.
Depending on your language you can use int(32) / int(64) or any other numeric datatype. (Please append the chosen type to your answer)
take a list as Input
you choose the behavior on empty input

GL

Can we return a list rather than a number? [9,50,2,1] for instance?

No, a "plain" number has to be returned., like in the example.

Is there any reason why it must be a plain number and not a list?

Because in my understanding a list can't be read as a number.
Concatenating is also the task.

Duplicate?

05AB1E, 3 bytes
œJà

Try it online!

Python 2, 85 80 77 72 70 bytes
lambda l:''.join(sorted(map(str,l),key=lambda i:i+i[-1]*max(l))[::-1])

Try it online!
Sorts the numbers lexicographically, but each number is padded with its last  digit.
This means that 'shorter' numbers (string-wise) can be larger than 'longer' numbers:
Example:
Input: [76, 7]
Each number gets padded with its last digit: ['76666..','7777..']
Sorted (descending): ['7777..',76666..'], which gives [7, 76]
Joining the result gives: 776

Jelly, 4 bytes
Œ!VṀ

Explanation
       Input: list [1, 4, 5, 21, 4]
Œ!     Generate all permutations of input list
  V    Eval those lists as Jelly code: every sublist is joined and interpreted as int
   Ṁ   Pick the highest

Try it online!

Brachylog, 5 bytes
pᶠcᵐ⌉

Try it online!
Explanation
pᶠ       Find all permutations of the list
  cᵐ     Concatenate each permutation into an integer
    ⌉    Take the biggest one

JavaScript (ES6), 40 bytes
a=>a.sort((a,b)=>``+b+a-(``+a+b)).join``

Sorts the numbers by their ordering when concatenated, and joins the result.

I like those ugly concatenations, it works in Squeak Smalltalk too [:x|(x sort:[:a :b|'',a,b>('',b,a)])join+0]the final +0 is for answering an Integer and avoiding quotes

Ohm v2, 4 bytes
ψJì↑

Explanation:
ψ      All possible permutations
 J     join sublists
  ì    convert to int
   ↑   get maximum

Try it online!

Japt, 8 bytes
ñ!îL w q

Test it online!
Look ma, no permutation built-in!
Explanation
ñ           Sort the input as if each item
 !îL          were repeated to 100 chars. (!îL -> LîX for each item X, L = 100)
     w      Reverse.
       q    Join into a single string.
            Implicit: output result of last expression

Repeating each item to length 100 works because while '7' < '76', '7777...' > '7676...', and no number could possibly be length 100 when converted to a string.

Fails for 7, 78; output should be 787 but this returns 778.

@Neil Whoops, thanks. Fixed at +0 bytes.

Now fails for 7, 776; output should be 7776 but this returns 7767.

'78' is before '7', '76' after '7' and, '7' and '77' can be in any order , more generally when a number start with sequence of another wrapped the digit which comes after must be compared to the next number in shorter: for example '7625' comes before '762575' but '76257625762' before '7625'

@NahuelFouilleul thanks, fixed at +0 bytes. I promise it's finally fixed this time, for real...

C#, 113 Bytes
It's not very short, but hey, it's still C# we're talking about.
int F(List<int>n)=>n.Max(i=>{var l=new List<int>(n);l.Remove(i);return int.Parse(""+i+(l.Count>0?""+F(l):""));});

Formatted:
int F (List<int>n) => n.Max (i =>
{
    var l = new List<int> (n);
    l.Remove (i);
    return int.Parse ("" + i + (l.Count > 0 ? "" + F (l) : ""));
});

It simply recursively tries all possible permutations of the input and returns the largest one.
It uses a 32 Bit integer as input and output numerical datatype.
If anybody has an idea on how to improve this solution, feel free to comment.

Ruby, 48 41 36 bytes
Similar implementation to others, generates all permutations and takes the max. Shame that "permutation" needs to be spelled out in full . . .
f=->l{l.permutation.map(&:join).max}

Calling it:
f.call([50, 2, 1, 9])
 => "95021"

f.call([7, 76])
 => "776"

Or
f.([50, 2, 1, 9])
 => "95021"

I have assumed that the output has to be an integer in the given language - I can drop the .to_i at the end and save 5 bytes if this is not the case. However OP has stated output should be a "plain number"

you can also output it as a String, which s generally readable like an int

You can also use the f.([50, 2, 1, 9]) syntax to call lambdas.

Actually, 11 bytes
;l@╨⌠εj≈⌡MM

Try it online!
Explanation:
;l@╨⌠εj≈⌡MM
;l@╨         all permutations of input
    ⌠εj≈⌡M   concatenate each permutation
          M  maximum

Java (OpenJDK 8), 113 220 87 bytes
l->l.stream().map(i->""+i).sorted((i,j)->(j+i).compareTo(i+j)).reduce((i,j)->i+j).get()

Try it online!

what about l->l.stream().sorted((i,j)->(j+""+i).compareTo(i+""+j)).forEach(i->System.out.print(i))

should be a function rather than a consumer l->l.stream().map(i->""+i).sorted((i,j)->(j+i).compareTo(i+j)).reduce((i,j)->i+j).get()

Pyth, 9 bytes
eSmsjkd.p

Try it here!
or:
eSsMjLk.p
jkeojkN.p

.p - Generate all the permutations.

msjkd - Map on the above with the following function that takes d as a variable:

jkd - Concatenate the integers into a single string.

s - Convert to integer.

S - Sort the input.

e - Get the last element.

Octave / MATLAB, 65 bytes
@(x)max(cellfun(@(s)str2num(s(s>32)),cellstr(num2str(perms(x)))))

Try it online!

Japt, 13 7 bytes
á m¬ñ Ì

Try it here.
-6 thanks to ETHproductions.

Don't think you'll need the ms if you change ®r+} to m¬

@ETHproductions Oh so there is such a builtin :p

A built-in to join an array on the empty string? Of course :P

@ETHproductions yeah I was referring to q I thought it surprisingly didn't exist but japt isn't that insane so as not to include it :p

K (oK), 18 bytes
Solution:
,/x@>(|/#:'x)#'x:$

Try it online!
Examples:
> ,/x@>(|/#:'x)#'x:$50 2 1 9
"95021"
> ,/x@>(|/#:'x)#'x:$7 76
"776"

Explanation:
,/x@>(|/#:'x)#'x:$ / the solution
                 $ / convert to string, 50 2 1 9 -> "50","2","1","9"
               x:  / store in x
     (      )      / do this together
        #:'x       / count (#:) each (') x, "50","2","1","9" -> 2 1 1 1
      |/           / max over, 2 1 1 1 -> 2,
             #'    / take each parallel, 2#'"50","2","1","9" -> "50","22","11","99"
    >              / return sorted indices (descending), "50","22","11","99" -> 3 0 1 2
  x@               / apply these indices to x, "50","2","1","9" -> "9","50","2","1"
,/                 / flatten, "9","50","2","1" -> "95021"

Python 2, 90 86 80 bytes
lambda l:max("".join(map(str,x))for x in permutations(l))
from itertools import*

Try it online!
-4 bytes thanks to FlipTack
-6 bytes thanks to i cri everytim
I believe this can be golfed a ton, but I don't really know how. Stupid type conversions added a ton of bytes.

IIRC you don't need any of your square brackets as max and join can take generators, which should save you four bytes

80 bytes.

Groovy, 41 bytes
{it.permutations().max{it.join()}.join()}

If commands were 3 bytes in groovy instead of a full word I halve the size lol:
{it.p().max{it.j()}.j()}

MATLAB/Octave, 65 62 bytes
@(n)max(str2num(sprintf([repmat('%d',size(n)) 10],perms(n)')))

Try it online!
Anonymous function which takes an array as an input, and spits out an integer representing the largest number that can be made.
Permutations are found, then the result is formatted to a 2D array where each line contains only the digits from the values in a given permutation in order. This is done by sprintf with enough %d markers to absorb the whole permutation. The result is then converted back to an array of integers where each line becomes its own value. The maximum from this array is returned.

Save 3 bytes using size(n) instead of 1,numel(n) in the repmat() call

Note: This was developed completely independently from the other Octave answer.

Gaia, 4 bytes
f$¦⌉

Try it online!

Perl 5, 27 bytes
join"",sort{"$b$a"cmp$a.$b}

TIO

J, 29 25 bytes
[:>./-.&' '&.":"1@(A.~i.@!@#)
[:>./,&.":/"1@(A.~i.@!@#)

-.&' '&.":"1 smashes a list of numbers together to produce a single number.  -. is "set minus" and ": is format, so ": turns, eg, the list 7 76 into the single string (aka list of chars) into '7 76', and -.&' ' removes the spaces from that string.  Since ": was applied using Under &. the inverse is automatically applied at the end, turning the single string-now-without-spaces back into a number.
,&.":/"1 smashes a list of numbers together to produce a single number.
(A.~i.@!@#) all permutations of the list
>./ maximum of

Try it online!

bash, 96 bytes
f(){ local l g p=$1;shift&&{ for i;{ (($i$p>$p$i))&&l+=\ $i||g+=\ $i;};echo $(f $l)$p$(f $g);};}

Try It Online

Doesn't work for inputs of 7 and 78.

indeed, from ETHproductions solution (to append 'a' so that '7' > '76') doesn't work because shorter numbers always placed after number which begins with same sequence however it doesn't work for all numbers : '7' > '76', '7' > '77', '7' > '78' but (should be '7' < '76', '7' = '77' and '7' < '78')

fixed using bash builtins instead of coreutils

Mathematica, 57 bytes
Max[FromDigits[Join@@IntegerDigits/@#]&/@Permutations@#]&

Try it online!

Matlab, 135 53 bytes
New Solution:
a=input('')
b=sprintf('%d', a)
c=sort(b,'descend')

Explanation: It takes a user matrix input, then separates it into digits, and finally orders those digits from greatest to least.
Old Solution:
a=input('');
b=sprintf('%d',a) - '0';
c=[];b=sort(b,'descend');
for i=1:size(b,2)
 c(i)=b(i);
end
for y=1:size(c,2)
 e(y)=num2str(c(y))
end

Explanation: First it takes a user input, then separates all of the numbers into individual digits. The %d in sprintf essentially converts the numbers in the string, which is necessary for sorting into each digit (afaik). I tried simply doing num2str(a) but that leaves a space between each number. From there, it is just a matter of sorting and arranging the numbers with proper formatting. The actual code has a lower byte count because it has no semi-colons and everything on one line.

I think that this might not work (based on the description your provided) because he doesn't want the individual DIGITS ordered (for example, if I'm understanding right, you would return 95210 and split up the 50 from the example, when the user requested that it return 95021).

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:
Siteswap validator
Siteswap is a notation for juggling patterns.
The other siteswap puzzle is great and it explains siteswap in greater detail than here. This puzzle is meant to be a bit simpler! Numberphile recently interviewed Colin Wright which helped develop the notation. The part at ~16min will be useful for this challenge. Another resource which may be useful for wrapping your hear around siteswap if you have not used it before: In your head
Below is the diagram(courtesy of wikipedia) for valid throws with 3 balls and a max height of a throw of 5. A valid siteswap ends at the same position as it started.

A valid siteswap for the case we are interested in is defined as follows: In the diagram above choose a starting node and then follow the arrows and write down the number attached to the arrow. If you end up on the same node as you started then the number you have written down is a valid siteswap, otherwise it is not valid.
Challenge
Take a number as input and output a truthy value if it is a valid siteswap for juggling with 3 balls with a max height of 5, otherwise output a falsy value. (No multiplex throws are allowed)
Examples
Input             Output
------------------------
3                  True
3333333333         True
3342               True
441                True
5                  False
225225220          False
332                False

Loopholes that are forbidden by default are not allowed.
This is code-golf, so fewest bytes wins.

I've voted to close this as unclear; challenges should provide all the required information rather than linking to other challenges and sites. As it stands, nothing in the challenge defines a valid siteswap nor can a definition be easily inferred from the test cases. In the future, please consider Sandboxing your challenges.

Possible duplicate? Certainly related.

@shaggy I hope my edit clarifies it; now the links serve more as additional background rather than primary explanation

I think it is pretty clear now (the first 2 paragraph is background information, the next 2 paragraph and the image describe the challenge). Given that we need to compress the graph, this challenge is somewhat like a kolmogorov-complexity one.

Can we take the siteswap as a list of numbers instead of a single number?

That would be ok

Python 2, 204 195 188 174 149 144 bytes
lambda s:any(i==reduce(lambda C,c:int('40WW75W5AA47WW07W4WW54A0WWAA70A5WAA123896W'.replace('W','A'*3)[C::11][int(c)],16),s,i)for i in range(10))

Try it online!

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


text:
Sequence of integer square roots
Let's define a sequence of integer square roots. First, a(1) = 1. Then, a(n) is the smallest positive integer not seen before such that
sqrt(a(n) + sqrt(a(n-1) + sqrt(... + sqrt(a(1)))))

is an integer. Some  examples:
a(2) is 3 because it's the smallest integer such that sqrt(a(2) + sqrt(a(1))) = sqrt(a(2) + 1) is integer, and 3 hasn't occured in the sequence before.
a(3) is 2 because it's the smallest integer such that sqrt(a(3) + sqrt(a(2) + sqrt(a(1)))) = sqrt(a(3) + 2) is integer, and 2 hasn't occured in the  sequence before.
a(4) is 7 because sqrt(a(4) + 2) is integer. We couldn't have a(4) = 2 because 2 already occured in our sequence.
Write a program or function that given a parameter n returns a sequence of numbers a(1) to a(n).
The sequence starts 1,3,2,7,6,13,5, ....
Source of this sequence is from this Math.SE question.

A plot of the first 1000 elements in the sequence:

:'-(

@Mr.Xcoder That just makes it interesting!

@Mr.Xcoder Yeah I agree it's so bad you can't just copy-paste the formula...

Can we have 0-indexed input?

@EriktheOutgolfer No. When you get n as input you should return or print a list of a(1) to a(n). In other words, the first n numbers in the sequence. There is no 'indexing'.

Are errors caused by floating point inaccuracies acceptable for very large inputs?

@Zgarb I guess it's too late now already... Fine... Use floating point 'answers'.

the want to play connect the dots intensifies *

Python 2, 80 bytes
s=[]
exec'x=q=1\nwhile(x in s)+q%1:x+=1;q=(v+x)**.5\nv=q;s+=x,;'*input()
print s

Try it online!

MATL, 30 27 bytes
lXHiq:"`@ymH@+X^1\+}8MXHx@h

Try it online! Or see a graphical display (takes a while; times out for inputs exceeding approximately 60).
Explanation
l          % Push 1. This is the array that holds the sequence, initialized to
           % a single term. Will be extended with subsequent terms
XH         % Copy into clipboard H, which holds the latest result of the
           % "accumulated" square root
iq:"       % Input n. Do the following n-1 times
  `        %   Do...while
    @      %     Push interaton index k, starting at 1. This is the candidate
           %     to being the next term of the sequence
    y      %     Push copy of array of terms found so far
    m      %     Ismbmer? True if k is in the array
    H      %     Push accumulated root
    @+     %     Add k
    X^     %     Square root
    1\     %     Modulo 1. This gives 0 if k gives an integer square root
    +      %     Add. Gives nonzero if k is in the array or doesn't give an
           %     integer square root; that is, if k is invalid.
           %   The body of the do...while loop ends here. If the top of the
           %   stack is nonzero a new iteration will be run. If it is zero that
           %   means that the current k is a new term of the sequence
  }        %   Finally: this is executed after the last iteration, right before
           %   the loop is exited
    8M     %     Push latest result of the square root
    XH     %     Copy in clipboard K
    x      %     Delete
    @      %     Push current k
    h      %     Append to the array
           % End do...while (implicit)
           % Display (implicit)

Mathematica, 104 bytes
(s=f={i=1};Do[t=1;While[!IntegerQ[d=Sqrt[t+s[[i]]]]||!f~FreeQ~t,t++];f~(A=AppendTo)~t;s~A~d;i++,#-1];f)&

Try it online!
The sequence of the square roots is also very interesting...
and outputs a similar pattern

1,2,2,3,3,4,3,5,3,6,4,4,5,4,6,5,5,6,6,7,4,7,5,7,6,8,4,8,5,8,6,9,5,9,6,10,5,10,6,11,5,11,6,12,6,13,6,14,7,7,8,7,9,7,10,7,11,7,12,7,13,7,14,8,8,9,8,10...

also here are the differences of the main sequence

Python 2, 87 bytes
t,=s=1,
for n in~-input()*s:
 while(n in s)+(t+n)**.5%1:n+=1
 s+=n,;t=(t+n)**.5
print s

Try it online!
-3 thanks to Mr. Xcoder.
-5 thanks to ovs.

92 bytes -> while n in s or(t+n)**.5%1>0 -> while(n in s)+(t+n)**.5%1

87 bytes

@ovs clever one

Haskell, 103 87 bytes
Horribly inefficient, but does not rely on floating point arithmetic. Here a(x) = sqrt(f(x)+a(x-1)) is a helper sequence, that simplifies the computation.
a 0=0
a x=[k|k<-[1..],m<-[k^2-a(x-1)],m>0,notElem m$f<$>[1..x-1]]!!0
f x=(a x)^2-a(x-1)

Try it online!

Husk, 21 bytes
!¡oḟȯΛ±sFo√+Som:`-N;1

Try it online!
How?
!¡oḟȯΛ±sFo√+Som:`-N;1    Function that generates a list of prefixes of the sequence and indexes into it
                   ;1    The literal list [1]
 ¡                       Iterate the following function, collecting values in a list
  oḟȯΛ±sFo√+Som:`-N        This function takes a prefix of the sequence, l, and returns the next prefix.
                `-N      Get all the natural numbers that are not in l.
            Som:         Append l in front each of these numbers, generates all possible prefixes.
    ȯΛ±sFo√+               This predicate tests if sqrt(a(n) + sqrt(a(n-1) + sqrt(... + sqrt(a(1))))) is an integer.
        F                Fold from the left
         o√+             the composition of square root and plus
       s                 Convert to string
    ȯΛ±                  Are all the characters digits, (no '.')
  oḟ                     Find the first list in the list of possible prefixes that satisfies the above predicate
!                        Index into the list

Python 2, 117 115 112 102 99 87 bytes
t,=r=1,;exec"x=1\nwhile(t+x)**.5%1or x in r:x+=1\nr+=x,;t=(t+x)**.5;"*~-input();print r

Try it online!
Used the t=(t+x)**.5 logic from Erik's answer

99 bytes.

@JonathanFrech Thanks :)

R, 138 105 99 bytes
function(n){for(i in 1:n){j=1
while(Reduce(function(x,y)(y+x)^.5,g<-c(T,j))%%1|j%in%T)j=j+1
T=g}
T}

Try it online!
-33 bytes using Tfeld's clever sqrt()%%1 trick in the while loop
-6 bytes using T instead of F
original answer, 138 bytes:
function(n,l={}){g=function(L)Reduce(function(x,y)(y+x)^.5,L,0)
for(i in 1:n){T=1
while(g(c(l,T))!=g(c(l,T))%/%1|T%in%l)T=T+1
l=c(l,T)}
l}

Try it online!

JavaScript (ES7), 89 82 77 76 bytes
i=>(g=k=>(s=(++n+k)**.5)%1||u[n]?g(k):i--?[u[n]=n,...g(s,n=0)]:[])(n=0,u=[])

Demo

let f =

i=>(g=k=>(s=(++n+k)**.5)%1||u[n]?g(k):i--?[u[n]=n,...g(s,n=0)]:[])(n=0,u=[])

console.log(JSON.stringify(f(10)))

Formatted and commented
i => (                             // given i = number of terms to compute
  u = [],                          // u = array of encountered values
  g = p =>                         // g = recursive function taking p = previous square root
    (s = (++n + p) ** .5) % 1      // increment n; if n + p is not a perfect square,
    || u[n] ?                      // or n was already used:
      g(p)                         //   do a recursive call with p unchanged
    :                              // else:
      i-- ?                        //   if there are other terms to compute:
        [u[n] = n, ...g(s, n = 0)] //     append n, set u[n] and call g() with p = s, n = 0
      :                            //   else:
        []                         //     stop recursion
  )(n = 0)                         // initial call to g() with n = p = 0


text:
Detect the Zeroless Numbers
Zeroless numbers are numbers that do not contain 0 as one of their decimal digits.
Given an integer K, return the Kth zeroless number. K will be non-negative if you choose 0-indexing, or positive if you choose 1-indexing instead. Note that this is OEIS A052382.
This is code golf, so the shortest code in bytes wins.
Test cases
1-indexed:

1 -> 1
2 -> 2
9 -> 9
10 -> 11
16 -> 17
100 -> 121

0-indexed:

0 -> 1
1 -> 2
8 -> 9
9 -> 11
15 -> 17
99 -> 121

Converting n to bijective base 10 is fundamentally the same as counting in bijective base B, so by the standards of PPCG this is a duplicate.

@PeterTaylor I wouldn't say this is a duplicate, since here much simpler approaches are possible, like counting up and discarding numbers containing a 0 (and seeing different ways to check if a number contains a 0 is interesting by itself)

@Leo, that approach is possible in the other question too.

@PeterTaylor it may be possible, but it is not competitive there. Of the answers I can understand in the other question, none use this approach. The vast majority of them are based on cartesian product, which could also be applicable here but currently seems inferior to the other approaches.

The way I see it is, convert k (zero indexed) into base 9, in the string of digits add 1 to each (and interpret the string as a number in base 10). That seems to be an efficient way time-wise, but won't necessarily make shorter code, depending on the language's features, so brute force may be shorter...

@Heimdall this doesn't work, e.g. 99 is 120 in base 9, so your method would yield 231. what works is converto the 1-indexed k into base 9, and starting from the most significant digit, replace every 0 you encounter with a 9 and then subtract 1 from the group of digits to the left of your current digit.

@FelixPalmen I see the flaw in my method, it doesn't give numbers that begin with 1. I should use a hybrid system where the most significant digit is is base 10 and the rest of the number is in base 9 (but then I wouldn't be able to use a built-in base converter if there is one in whichever language I go for, I would have to write my own). Then leave the most significant digit alone and add 1 to all other digits (if any). Of course, that would need 1-indexed k.

@FelixPalmen Your method is good though, applied carefully. You could just subtract 1 from the digit to the left rather than the group because it's not going to be 0 since you're parsing from left (from the most significant digit. But sometimes you'll create more zeroes because you'll subtract 1 from 1 (which I guess you'll ignore if that 1 was the most significant digit, like with k=1). So those additional zeroes will have to be dealt with, too, maybe immediately, and continue to parse the number after dealing with the additional zero, or parse the number again.

For example, k=66348, in base 9 it is 111010. First zero is the fourth digit, so it becomes 110910. Continue parsing the number, the next zero is the sixth (last) digit, we get 110909. Because we created more zeroes, we do another parse (or we have remembered where they were, positions 3 and 5). We get 109909, 109899, next parse, 099899; as it's the most significant number that became 0, we just drop it -> 99899. Or if newly created zeroes are dealt with immediately, it's just one parse: find first zero on position 4, 111010 -> 110910 -> 109910 -> (0)99910, find next zero, -> 99909 -> 99899.

@Heimdall the latter is the algorithm my submission uses ;) This is effectively "subtracting 1 from the group of digits to the left" with the special rule that for the most significant digit only, 0 isn't wrapped to 9 but "cut off" instead. Of course, doing multiple adjustment passes would work as well, didn't think of that. I might check whether it buys me bytes :)

@WheatWizard This can't be a duplicate. If you solve this with a base conversion, adjusting the resulting digits is quite a bit more complex than in the linked challenge. Also, as already commented, other solutions than a base conversion are possible and, depending on the language, superior here.

@felixpalmen I disagree.  I think this is a duplicate.  I'm quite tired of this general attitude that nothing is a duplicate because of minor differences in the approach of language X.  Your free top vote to reopen but I'm not changing my vote.

@WheatWizard I'm quite tired of people spoiling challenges because of faint similarities. The differences here are substantial.

Jelly, 3 bytes
ḃ9Ḍ

Try it online!
How it works
ḃ9Ḍ  Main link. Argument: n (1-based index)

ḃ9   Convert n to bijective base 9.
  Ḍ  Convert the result from base 10 to integer.

whoa this is actually genius +1

Langs with 'monads' and 'bijectives' and 'trilithiums' make me feel like a doofus.

I'm sorry if this is old news and is addressed elsewhere, i'm new, but wouldn't that be 3 characters?

@RobbieMckennie Jelly, as with several other golfing language, has its own code page so that each character is only one byte long. This program would be E7 39 C1 (invalid in UTF-8.)

Aaaahh got you.

Python 2, 35 bytes
f=lambda n:n and~-n%9+1+f(~-n/9)*10

Try it online!
One indexed.

lambda n:int(str(n),11) is shorter.

@J843136028 That gives outputs containing zeroes.

Haskell, 31 bytes
(filter(all(>'0').show)[0..]!!)

Try it online!

32 bytes
(l!!)
l=(+).(10*)<$>0:l<*>[1..9]

Try it online! One-indexed.

33 bytes
(l!!)
l=0:[10*a+b|a<-l,b<-[1..9]]

Try it online!

34 bytes
(l!!)
l=0:do a<-l;take 9[10*a+1..]

Try it online!

37 bytes
f 0=0
f n=mod(n-1)9+1+10*f(div(n-1)9)

Try it online!

Perl 5, 20 bytes
19 bytes code + 1 for -p.
Uses 1-indexing.
0while$_-=++$\!~0}{

Try it online!

Javascript (ES7), 23 Bytes
f=n=>n&&n--%9+10*f(n/9)

Explanation:
f=n=>                  //=> syntax
     n&&n--%9          //only with 0 0s
             +10*f(n/9)//^^

Welcome to the site! :)

Hello! 17B if you use: n=>+n.toString(9) (anonymous functions are allowed)

Python 2, 50 bytes
n=input()
i=0
while n:i+=1;n-=1-('0'in`i`)
print i

Try it online!

Actually, 10 bytes
⌠$'0@cY⌡╓N

Try it online!
Explanation:
⌠$'0@cY⌡╓N
⌠      ⌡╓N  nth number (starting with i=0) where
 $            string representation of i
  '0@cY       does not contain 0

Haskell, 31 bytes
This is zero-indexed
(filter(all(>'0').show)[1..]!!)

Try it online!

MATL, 16 13 14 bytes
-2 bytes thanks to Luis Mendo
E:!tV48-!XA)G)

Try it online!
Explanation:
(implicit input)
E                   % double
 :                  % 1:top of stack (so [1, 2, ..., 2n])
  !t                % transpose and dup
    V               % cast to chars
     48-            % subtract 48 (maps numbers to digits)
        !           % transpose
         XA         % Check each column if All are true (nonzero)
           )        % index into array (so we are left with zeroless numbers)
            G)      % paste input and index; TOS is the nth element.
(implicit output)

Python 2, 50 bytes
n=input();v=0
while n:v+=1;n-=min(`v`)>'0'
print v

Try it online!

PowerShell, 40 bytes
param($a)(1..(2*$a)|?{$_-notmatch0})[$a]

Try it online!
Take input $a, then construct a range from 1 to 2*$a. Pull out those elements that regex do -notmatch 0, and then take the $ath one thereof. Output is implicit.

05AB1E, 5 bytes
µNSĀP

Try it online!
Explanation
µ       # loop over N until input matches are found
 NS     # split N into list of digits
   Ā    # check if trueish (not zero)
    P   # product

or with Dennis's base conversion trick
05AB1E, 3 bytes
9.h

Try it online!

Ahhhh!!! We let Jelly use base conversion before 05AB1E! Noooooooo o's trail off into the distance...

6502 machine code (C64), 124 bytes
00 C0 20 FD AE 20 6B A9 A2 05 A9 00 85 FB 85 FC 85 FD A0 10 06 FB 06 14 26 15
90 02 E6 FB A5 FB C9 09 90 04 E9 09 85 FB 26 FC 26 FD 88 D0 E5 A5 FB 95 61 CA
A5 FD 85 15 A5 FC 85 14 D0 CC A5 15 D0 C8 E8 86 FE B5 61 D0 1E A9 09 95 61 86
9E CA B4 61 F0 11 D6 61 D0 0D E4 FE D0 04 E6 FE B0 05 95 61 CA 10 EB A6 9E E8
E0 06 D0 D9 18 A6 FE B5 61 69 30 20 D2 FF E8 E0 06 D0 F4 60

Online demo
Usage: sys49152,[n], e.g. sys49152,100. n is 1-indexed.
Valid values are in the range [1,63999].
Explanation:
The common approach to save bytes is to do it iteratively / recursively checking for decimal 0 digits -- this doesn't save bytes on the C64 because there's not even a division instruction available -- just converting to base 9 and adjusting the digits gives a shorter result (still with the need to hand-code a long binary division). Here's the commented disassembly:
         00 C0       .WORD $C000        ; load address
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 6B A9    JSR $A96B          ; read 16bit number
.C:c006  A2 05       LDX #$05           ; index of last digit in result
.C:c008   .divide:
.C:c008  A9 00       LDA #$00           ; initialize some variables
.C:c00a  85 FB       STA $FB            ; to zero ...
.C:c00c  85 FC       STA $FC
.C:c00e  85 FD       STA $FD
.C:c010  A0 10       LDY #$10           ; repeat 16 times for division
.C:c012   .div_loop:
.C:c012  06 FB       ASL $FB            ; shift remainder left
.C:c014  06 14       ASL $14            ; shift dividend ...
.C:c016  26 15       ROL $15            ; ... left
.C:c018  90 02       BCC .div_nobit     ; highest bit set?
.C:c01a  E6 FB       INC $FB            ; then add one to remainder
.C:c01c   .div_nobit:
.C:c01c  A5 FB       LDA $FB            ; compare remainder ...
.C:c01e  C9 09       CMP #$09           ; ... to 9 (divisor)
.C:c020  90 04       BCC .div_nosub     ; if greater or equal 9 (divisor)
.C:c022  E9 09       SBC #$09           ; subtract 9 from remainder
.C:c024  85 FB       STA $FB
.C:c026   .div_nosub:
.C:c026  26 FC       ROL $FC            ; shift quotient left, shifting in
.C:c028  26 FD       ROL $FD            ; carry if remainder was >= 9
.C:c02a  88          DEY                ; loop counting
.C:c02b  D0 E5       BNE .div_loop      ; and repeat
.C:c02d  A5 FB       LDA $FB            ; load remainder
.C:c02f  95 61       STA $61,X          ; store in current output digit
.C:c031  CA          DEX                ; decrement digit index
.C:c032  A5 FD       LDA $FD            ; copy quotient ...
.C:c034  85 15       STA $15
.C:c036  A5 FC       LDA $FC            ; ... to dividend
.C:c038  85 14       STA $14
.C:c03a  D0 CC       BNE .divide        ; if not zero yet
.C:c03c  A5 15       LDA $15
.C:c03e  D0 C8       BNE .divide        ; repeat division by 9
.C:c040  E8          INX
.C:c041  86 FE       STX $FE            ; remember index of first digit
.C:c043   .adjust_loop:
.C:c043  B5 61       LDA $61,X          ; load digit
.C:c045  D0 1E       BNE .nonine        ; if it's zero, must be changed to 9
.C:c047  A9 09       LDA #$09
.C:c049  95 61       STA $61,X
.C:c04b  86 9E       STX $9E            ; save current index and go back
.C:c04d  CA          DEX
.C:c04e   .sub_loop:
.C:c04e  B4 61       LDY $61,X          ; examine previous digit
.C:c050  F0 11       BEQ .sub_done      ; zero? nothing more to subtract
.C:c052  D6 61       DEC $61,X          ; decrement previous digit
.C:c054  D0 0D       BNE .sub_done      ; not zero -> done
.C:c056  E4 FE       CPX $FE            ; are we at the first digit?
.C:c058  D0 04       BNE .sub_next      ; no: go on
.C:c05a  E6 FE       INC $FE            ; first digit now zero, so increment
.C:c05c  B0 05       BCS .sub_done      ; and done with subtraction
.C:c05e   .sub_next:
.C:c05e  95 61       STA $61,X          ; store 9 to this digit
.C:c060  CA          DEX                ; and go to previous
.C:c061  10 EB       BPL .sub_loop      ; repeat
.C:c063   .sub_done:
.C:c063  A6 9E       LDX $9E            ; load saved digit index
.C:c065   .nonine:
.C:c065  E8          INX
.C:c066  E0 06       CPX #$06           ; reached last digit?
.C:c068  D0 D9       BNE .adjust_loop   ; no -> repeat
.C:c06a  18          CLC
.C:c06b  A6 FE       LDX $FE            ; start output at first digit
.C:c06d   .out_loop:
.C:c06d  B5 61       LDA $61,X          ; load digit
.C:c06f  69 30       ADC #$30           ; add character code `0`
.C:c071  20 D2 FF    JSR $FFD2          ; output character
.C:c074  E8          INX                ; next
.C:c075  E0 06       CPX #$06           ; last digit done?
.C:c077  D0 F4       BNE .out_loop      ; if not, repeat
.C:c079  60          RTS

Jelly, 5 bytes
DȦ$#Ṫ

-2 bytes thanks to Dennis
Explanation
DȦ$#Ṫ  Main link; takes input from STDIN
   #   nfind; get first n matches starting from 0
  $    Get numbers that are zeroless:
D      Digits
 Ȧ     Are all truthy
    Ṫ  Tail; get last element

Try it online!

QBIC, 32 bytes
[:|p=p+1≈instr(!p$,@0`)|p=p+1}?p

Explanation
[:|     FOR a = 1 to <input>
p=p+1   increase p (starts as 0) by 1
≈       WHILE
 instr  the index in
 (!p$     the string-cast of p
 ,@0`)|   of the string '0' is non-zero
 p=p+1    skip this number in the zero-less sequence
}       WEND, NEXT
?p      PRINT p

Mathematica, 55 bytes
(s=t=1;While[s<=#,If[DigitCount[t++,10,0]<1,s++]];t-1)&

Try it online!

Perl 6, 24 bytes
{(grep {!/0/},^∞)[$_]}

Try it online!
0-indexed.

grep(…) will be one character shorter than (grep …). Otherwise it is basically the same as I came up with. (I used 1..*)

Pyth,  9  8 bytes
e.f*FjZT

Verify all the test cases.
Explanation

e.f*FjZT   ~ Full program.

 .f        ~ Collect the first Q matches. Uses a variable Z.
     jZT   ~ Decimal digits of Z.
   *F      ~ Product. Can be replaced by .A (all) - Basically checks if all are ≥ 1.
e          ~ End. Get the last element.

Python 2, 50 49 bytes
1 byte off thanks to @Mr.Xcoder
lambda n:[k for k in range(2*n)if('0'in`k`)<1][n]

0-based.
Try it online!

C, 70 bytes
i,j,k;f(n){for(i=0;n--;n+=!k)for(k=j=++i;j;j/=10)k=j%10?k:0;return i;}

1-indexed
Try it online!
C (gcc), 65 bytes
i,j,k;f(n){for(i=0;n--;n+=!k)for(k=j=++i;j;j/=10)k=j%10?k:0;n=i;}

1-indexed
Try it online!

JavaScript (ES6), 28 27 bytes

f=n=>n&&--n%9+1+10*f(n/9|0)
<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Edit: Saved 1 byte by switching to a numeric result (effectively porting @xnor's Python answer).

Excel VBA, 57 Bytes
Anonymous VBE immediate window function that takes input, n from range [A1] and outputs the nth 0-indexed zeroless number to the VBE immediate window.
For i=1To[A1]:j=j+1:While InStr(1,j,0):j=j+1:Wend:Next:?j

AWK, 39 bytes
{for(;c<$1;)c=index(++i,0)?c:c+1;$0=i}1

Since this is AWK 1-indexing seemed appropriate.
Try it online!

Java 8, 45 bytes
int c(int n){return n>0?--n%9+1+c(n/9)*10:0;}

1-indexed
Port of @xnor's Python 2 answer.
Explanation:
Try it here.
int c(int n){  // Method with integer as both parameter and return-type
  return n>0?  //  If `n` is larger than 0:
    --n%9      //   Return `(n-1)%9
    +1         //    + 1
    +c(n/9)    //    + recursive call with `(n-1)/9`
     *10       //      multiplied by 10
   :           //  Else:
    0;         //   Return 0
}              // End of method

C# (.NET Core), 68 63 bytes
-8 bytes thanks to @raznagul.
k=>{int i=0;for(;k>0;)if(!(++i+"").Contains("0"))k--;return i;}

Try it online!

Don't really want to use this, since it's just a C# port of an existing answer.
C# (.NET Core), 45 bytes
int c(int n){return n>0?--n%9+1+c(n/9)*10:0;}

Try it online!

You can save some bytes by removing j and decrementing k instead.

Jq 1.5, 76 bytes
[.,0]|until(.[0]<1;.[1]+=1|if"\(.[1])"|contains("0")then. else.[0]-=1end)[1]

Expanded
  [.,0]                           # initial state (n, v)
| until(.[0]<1;                   # until we've found n'th number
     .[1]+=1                      #   increment v
   | if "\(.[1])"|contains("0")   #   if v contains 0
     then .                       #   leave state alone
     else .[0]-=1                 #   otherwise decrement n
     end
  )[1]                            # return n'th number found

Try it online!