text:
Invert a boolean array
A nice simple one
Input
Given a boolean array (Or an acceptable alternative), you can assume the array will never be more than 32 elements long.
[false, false, true, false, false]

Output
Invert every element of the array and output it.
[true, true, false, true, true]

Rules

You can write a full program or just a function
Standard loopholes apply
Shortest code in bytes, per language, wins!

Test cases
Input:
[true, false]
Output:
[false, true]

Input: //Example of acceptable alternative
[0,1,1]
Output:
[1,0,0]

How about arrays of 0 (false, all 0 bits) and -1 (true, all 1 bits)?

@Lynn While it's the OPs decision, I'd say it should be up to whether your language considers though truthy/falsy.

Related. (Given the simplicity of the core task, I'd say the differences in format are significant enough that these aren't duplicates.)

More than code golf this looks to me like: what is the not operator in your favourite language? Additional points if it works on lists.

05AB1E, 1 byte
Code:
_

Explanation:
_     # Logical not

Try it online!

I love the explanation

Javascript ES6, 15 bytes
a=>a.map(b=>!b)

Not much explanation needed I guess

f=
a=>a.map(b=>!b)

a.innerHTML = `[true, false, 1, 0] => ${ f([true, false, 1, 0]) }`
<pre id=a>

Probably can't get shorter than that...

Would simply map(b=>!b) count?

@MatthewJensen no because map is a method and not a regular function

Jelly, 1 byte
¬

Try it online!
¬ is logical NOT (1 if false-y, else 0). C (“complement”, 1−z) also works.

I think @Dennis is going to have a hard time outgolfing you.

@flawr It's just a matter of time before Dennis does it in 0 bytes or less.

@EriktheGolfer "0 bytes or less" hmm

@zdimension It's Dennis, he can do it shorter than you think (read the memes).

Matlab,  4  1 byte
This should be self explanatory.
~

Matlab has the one-byte negation operator ~, if you want a function you can use @not.

get @rgument, negate, output, terminate, right?

Haha, right, I'm surprised you're so fluent in Matlab!

lol, this sounds like Borat "This should be self explanatory .... NOT"

surely ~ is an appropriate answer since it's an operator that receives an argument. I think ~[1,0,0,1,0] is entirely appropriate.

besides, by that logic, you should be doing f=@not anyway.

@TasosPapastylianou Operator submissions are definitely valid (in some languages like Julia and Mathematica it's even common practice to define your own operators because that's shorter than defining your own function), but I'm sure flawr just doesn't want to invalidate my comment. ;)

Haskell, 7 bytes
map not

Example:
Prelude> (map not) [False, True, True]
[True,False,False]

You don't need the parenthesis in the example, right?

I don’t, but I wanted to demonstrate in the example how my answer is a valid expression and not a snippet.

There was a suggested edit just now to make the code not<$>, but that’s not a valid expression; you can’t write f = not<$> and then f [False, True, True]; operator slices need parentheses around them, which would contribute towards the byte count.

and also you're not supposed to suggest code via edits anyway

Can you do map(1-) and use [0,1,1] instead of [False, True, True]?

R, 1 byte
!

Example:
> !c(TRUE, FALSE)
[1] FALSE  TRUE

It also works with numerical input:
> !c(1, 0)
[1] FALSE  TRUE

We're not restricted to one-dimensional arrays, either. Let's make a matrix, and randomly populate it with 0s and 1s:
> mat = matrix(rbinom(16, 1, .5), ncol=4)
> mat
     [,1] [,2] [,3] [,4]
[1,]    0    1    1    1
[2,]    0    1    0    0
[3,]    0    0    0    0
[4,]    1    1    1    0

We can invert this just as easily:
> !mat
      [,1]  [,2]  [,3]  [,4]
[1,]  TRUE FALSE FALSE FALSE
[2,]  TRUE FALSE  TRUE  TRUE
[3,]  TRUE  TRUE  TRUE  TRUE
[4,] FALSE FALSE FALSE  TRUE

We can continue to do this for arbitrary numbers of dimensions. Here's an example on a four-dimensional array:
> bigarray = array(rbinom(32, 1, 0.5), dim=c(2,2,2,2))
> bigarray
, , 1, 1

     [,1] [,2]
[1,]    0    0
[2,]    0    0

, , 2, 1

     [,1] [,2]
[1,]    1    0
[2,]    0    0

, , 1, 2

     [,1] [,2]
[1,]    0    1
[2,]    0    1

, , 2, 2

     [,1] [,2]
[1,]    1    0
[2,]    1    1

> !bigarray
, , 1, 1

     [,1] [,2]
[1,] TRUE TRUE
[2,] TRUE TRUE

, , 2, 1

      [,1] [,2]
[1,] FALSE TRUE
[2,]  TRUE TRUE

, , 1, 2

     [,1]  [,2]
[1,] TRUE FALSE
[2,] TRUE FALSE

, , 2, 2

      [,1]  [,2]
[1,] FALSE  TRUE
[2,] FALSE FALSE

Doesn't work for characters, I'm afraid.
> !"Hello world"
Error in !"Hello world" : Invalid argument type.

To save on submitting identical answers, this also works in Julia (except it doesn't work on numeric input there)

C, 46 Bytes recursive version
f(char*s){*s?putchar(*s&72?*s:*s^1),f(++s):0;}

C, 47 Bytes iterative version
f(char*s){for(;*s;putchar(*s&72?*s:*s^1),s++);}

Run using this main function
main(c,v)char**v;
{
    f(v[1]);
}

and input like this
a.exe [1,0,1,1,0]
[0,1,0,0,1]

Shorter than I expected to see for C!

MATL, 1 byte
~

Try it online!
~ is the logical not and as many functions, it can also be applied to arrays/matrices.

Works in APL too.

Perl 6, 4 bytes
"French"/Unicode version:
!«*

"Texas"/ASCII version:
!<<*

Input is a single value which can be treated as a list.
This is a a Whatever lambda (*) with the logical not prefix operator (!) combined using prefix hyper operator («).
Effectively this is the same as:
-> $_ { $_.values.hyper.map: &prefix:<!> }
# ( currently the Rakudo implementation doesn't actually do the ｢.hyper｣ call,
#   but prefix ｢«｣ is specifically designated for doing things in parallel )

Usage:
# pretend it's a method
say (True,False,True,True).&( !«* );
# (False True False False)

say ( !«* )( (False,False,True,False,False) );
# (True True False True True)

# give it a lexical name
my &list-invert = !«*;

#              v¯¯ a space is necessary here
say list-invert (True,False);
# (False True)

say (False,True).&list-invert;
# (True False)

I was just trying to puzzle out the same thing. I only got as far as {!«@_} :)

!** should work too

Labyrinth, 9 bytes
,$:)%#$.,

Try it online! Assumes newline-separated input with a trailing newline. Thanks to @MartinEnder for help with golfing.
This program's a bit weird for a Labyrinth program - it doesn't make use of the 2D nature of the language, and it actually bounces back and forth. On the first forward trip, we have:
[Moving rightward]
,            Read char c of input
 $           XOR c with implicit 0 at bottom of stack
  :)%        Calculate c % (c+1), erroring out if c == -1 from EOF, otherwise returns c
     #$      XOR with (length of stack == 1)
       .     Output (c^1) as char
        ,    Read newline

[Moving leftward]
       .     Output newline
      $      XOR two implicit 0s, stack [0]
    %#       Mod with (length of stack == 1), giving stack [0]
 $:)         Increment, duplicate then XOR, stack still [0]
,            Read char c of input

The next occurence of $ then XORs the existing 0 on the stack with c, as opposed to an implicit 0 at the bottom of the stack like in the first run. Both situations leave the stack as [c], and the program repeats thereafter.
Alternative 9-bytes:
,:):/$.:,
,::)/)$.,
,:):%)$.,

This forwards-backwards effect is really cool.

I like this answer. It's happy. :)

C#, 19 bytes
as an annonymous function, takes a bool[] and returns an IEnumerable
b=>b.Select(x=>!x);

or in 36 bytes with
dynamic f(bool[]b)=>b.Select(x=>!x);

Mathematica, 7 bytes
Not/@#&

or without letters:
!#&/@#&

As for the syntactic sugar: & marks the right end of an unnamed function and has very low precedence. # refers to the first argument of the nearest and enclosing &. ! is the operator for Not. So !#& is just an unnamed function that negates its argument, in other words its identical to the built-in Not. /@ is the operator for Map. So the code would also be equivalent to the somewhat more readable Map[Not, #]&.

How the !#&/@#& am I supposed to read that? :)

@Lynn Does that help? :)

I'm surprised that Not isn't listable

@ASimmons Yeah so was I.

Python, 27 25 24 bytes
Thanks to Lynn for golfing off two bytes, and xnor and Mego for golfing off another.
lambda a:[b^1for b in a]

Arrays of 0/1 are allowed, and 1-b is shorter than not b. I asked the OP if arrays of 0/-1 are allowed, in which case ~b is even shorter.

b^1 also works.

@xnor And that would actually be better, because then the space before the for could be dropped.

I didn't realize that 1for would be parsed as two separate tokens.  Huh, TIL.

J, 2 bytes
-.

This is the negation verb.
Test case
   -. 0 1 0 0 1
1 0 1 1 0

Swift 3 (7 bytes)
.map(!)

e.g.
[true, false].map(!)

Explanation
Seems pretty obvious. Calls map on the array [true, false]. The one "gotcha" is that, in Swift, operators are just functions and can be passed around as arguments. This means map(!) is passing the "not" function ! into map.

An impressively short answer for a language that is terrible for golfing in. :)

I feel like I broke a rule or something. I'm not sure how these are judged. :D

This is awesome.

Shakespeare Programming Language, 240 bytes
.
Ajax,.
Puck,.
Act I:.
Scene I:.
[Enter Ajax and Puck]
Puck:
Open your mind.Is hog as big as you?If so, let us return to scene II.You be sum of difference of zero and you and cat.Open thy heart!Let us return to scene I.
Scene II:.
[Exeunt]

Takes input as a string of \0 and \1 control characters. Outputs as a string of 0 or 1. If the input must be the same as the output, replace Open thy heart with Speak thy mind for no change in bytecount. If \0 and \1 can't be used, do the above, but also replace Open your mind with Listen to thy heart for a 5-byte penalty.
Ungolfed:
The Invertion of Veronan Arrays.

Romeo, who stores the element.
Juliet, who lectures him.

Act I: In which an array is inverted.

Scene I: A silent entrance.

[Enter Romeo and Juliet]

Scene II: In which Juliet pours out her heart to Romeo.

Juliet:
  Open your mind. Is nothing better than thee? If so, let us proceed to scene III.
  Thou art as good as the sum of the difference between nothing and thee and my
  cat. Open your heart! Let us return to scene II.

Scene III: Finale.

[Exeunt]

This roughly translates to the following C pseudocode:
int romeo;

Scene1:
romeo = getchar();
if (0 > romeo) goto Scene2;
romeo = 0 - romeo + 1;
printf("%d", romeo);
goto Scene1;

Scene2:;

I'm using this interpreter. Sample run:
$ python splc.py invert.spl > invert.c
$ gcc invert.c -o invert.exe
$ echo -ne "\x00\x01\x00" | ./invert
101

IBM/Lotus Notes Formula, 2 bytes
!a

Usage:
Create a Notes form with two fields named a and b.
a (input) = editable, number, multi-value, comma separated
b (output) = computed, number, multi-value, comma separated
Paste the above formula into b and give a a default value of 0.
Create a new document with the form, enter a binary list in a and press F9 to update the output.
Examples:

Works because given a list as input, Notes formula will apply whatever specified action to every element in the list.

Oh my god... My company just switched away from lotus notes; I had hoped to never see it again. +1 for that throwback.

I think many companies are @carusocomputing and probably rightly so. I've been working with it on and off for over 20 years and it still amazes me what formula language can do with list iterations sometimes. It's fun to open up designer occasionally and see how much I can still remember :-)

JAISBaL, 1 byte
!

Like all the other 1-byte answers, this is the negation operator, which can operate over an array if needed. This leaves the output on the stack, which is printed at the end of the program.
For two bytes, the array can be explicitly printed:
!§

Input is in JAISBaL's incredibly odd array format (which I did invent, but I don't like it...).
Test Cases (Output from the Java interpreter, 3.0.5):
Enter a value > [true][false]

--------------------
Stack: [[false, true]]
Locals: {}
----------------------------------------
Enter a value > [false][false][true][false][false]

--------------------
Stack: [[true, true, false, true, true]]
Locals: {}

PowerShell, 15 bytes
$args[0]|%{!$_}

I think this may even work in v1, hence I left the version number off the title. Loops through the input $args and negates each item in turn. That resulting array is left on the pipeline.
The neat thing, however, is because PowerShell is so loose on its casting requirements, you can do a completely mixed input and get an appropriate Boolean output. For example, here are the literal Boolean values $false/$true, the numbers 0 1 and 123456789 as integers, an empty string, a non-empty string, an empty array, and a non-empty array --
PS C:\Tools\Scripts\golfing> .\invert-a-boolean-array.ps1 @($false,$true,0,1,123456789,'','foo',@(),@(1,1))
True
False
True
False
False
True
False
True
False

Perl, 7 bytes
Includes +2 for -lp
Give each boolean value as 0 or 1 on its own line
invert.pl
1
1
0
^D

invert.pl:
#!/us/bin/perl -lp
$_^=1

Logicode, 9 8 bytes
out!binp

Simple, really.
Takes input as a binary string, as Logicode doesn't have support for lists (so [true, false] would be 10).
The out outputs the line's result.
The ! command calculates the NOT of every bit in the string, so something like !111 would be 000.
The binp is binary input.
1 byte saved thanks to @daHugLenny

I think you can remove the space between out and !binp.

@daHugLenny Huh, I was not aware you could do that. Thanks!

Brachylog, 7 bytes
:{-$_}a

Try it online!
Explanation
:{   }a   Apply this predicate to each element of the Input
  -         Decrement
   $_       Negate

Java, 58 bytes
void f(boolean[]a){for(boolean i:a)System.out.print(!i);}

Ways to golf: change arr to a (saves 4 bytes), write int[]a instead of int a[] (saves 1 byte),

oops! how do i forget it?how insane i am. and thanks @OlivierGrégoire

Cheddar, 10 bytes
@.map((!))

I hope I counted right as I'm writing from phone

I think, equivalently, fn.vec((!)), if that was ever released :P

brainfuck (58 Bytes)
-[>+<-----]>--->,[<[->->+<<]>[--<]>[>]<[-<+<+>>]<+.[-]<>,]

Try it here
Ungolfed
-[>+<-----]>---     Number 48 (stands for 0)
>,                  Read in first point
[
    <[->->+<<]      Subtract 1 from 48 flag, subtract 1 from read data, add 1 for new flag
    >
    [--<]           If sitting on 1 (true) subtract 2 and move left)
        >[>]<       Move to 48 flag
        [-<+<+>>]   Add 48 to data point
        <+.[-]<     Add 1 move print, zero cell, move to new 48 cell
        >,          Read in next point
]                   Loop if input remaining

Takes an input of undivided 1s or 0s (11001).

Java, 15 bytes
s->s.map(b->!b)

Note: s is a java.util.stream.Stream<Boolean> and the import is not necessary, proof below.
Testing and ungolfed
LookMaNoImports.java
class LookMaNoImports {
  static Main.F f = s -> // transform a Stream<Boolean>
    s.map(               // by applying its map method
      b ->               // which in turns transforms a boolean
        !b               // by applying its negation.
    );
}

Main.java
    import java.util.Arrays;
    import java.util.List;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;

    public class Main {

        interface F {
            Stream<Boolean> f(Stream<Boolean> s);
        }

        public static void main(String[] args) {
            F f=LookMaNoImports.f;

            test(f, new Boolean[]{true}, new Boolean[]{false});
            test(f, new Boolean[]{false}, new Boolean[]{true});
            test(f, new Boolean[]{true, false}, new Boolean[]{false, true});
            test(f, new Boolean[]{true, true}, new Boolean[]{false, false});
        }

        static void test(F f, Boolean[] param, Boolean[] expected) {
            List<Boolean> result = f.f(Arrays.stream(param)).collect(Collectors.toList());
            if (result.equals(Arrays.asList(expected))) {
                System.out.printf("%s: OK%n", Arrays.toString(param));
            } else {
                System.out.printf("%s: NOT OK, expected %s%n", Arrays.toString(param), Arrays.toString(expected));
            }
        }
    }

Binary Lambda Calculus, 64 bits = 8 bytes
0001011000000000010111001011111000001000001100101111011010000010

Try it online!
Note: This is a function and its list format is slightly different from the list format used by default in BLC’s I/O, so the TIO link doesn’t really do anything.
Explanation
If you don’t know what lambda calculus is, please read this Wikipedia page about it, since Wikipedia explains it better than I can.
My function takes a list of Church booleans as input. The list encoding that it uses is the one where a list is encoded as its right fold function. i.e. The encoding of list is foldr list (in pseudo-Haskell). An example of this kind of list is \c n. c (T (c F n)), where T and F are the Church booleans for true and false, respectively. This example represents the list [true, false].
Here is the lambda calculus (pseudo-?)code that I used to get my BLC code:
\l. l (\a b. \c n. c (a (\x y. y) (\x y. x)) (b c n)) (\c n. n)

(\ is abstraction, \a b. ... means \a. \b. ..., abstraction extends as far as it can, and application is left-associative.)
I then represented it using De Bruijin indices:
\1 (\\\\2 (4 (\\1) (\\2)) (321)) (\\1)

Note that 321 means ((3)2)1, not literally a De Bruijin index using the number 321.
Then I used @ to represent application (i.e. @mn means m(n)).
\@@1\\\\@@2@@4\\1\\2@@321\\1

(Note that I transcribed this “by hand,” so if my answer doesn’t work, then it’s probably a problem with this.)
I then used this to get the BLC code. (See here for information about how the encoding works and more information about BLC.)
The actual explanation is here
So I’m going to explain using a condensed version of the lambda calculus notation.
Note that my vocabulary, specifically “the accumulator’ and “the new element”, is probably wrong. I’m basically trying to paint the image of a for loop initializing the “accumulator” at a value and changing it each time it passes through a “new element” of the list.
\l.l(\abcn.c(a(\xy.y)(\xy.x))(bcn))(\cn.n)

\l.l(                             )(     )  Right fold of l.
                                    \cn.n   Start the accumulator as the empty list.
     \a                                     a is the new element.
       b                                    b is the accumulator.
        cn.c(                               Prepend...
             a(\xy.y)(\xy.x)                  the logical negation of a
                            )(bcn)            to the accumulator.

(This is a high-level overview and it’s probably possible to explain some of these concepts a better way.)

Actually, 2 bytes
♂Y

Try it online!
Map (♂) Boolean negate (Y)

CJam, 4 bytes
{:!}

Input is a list of 0s and 1s.
Try it online!

Japt, 3 bytes
¡!X

Japt doesn't have boolean input, so input is an array of 0s and 1s. Test it online!
How it works
¡    // Map each item X in the input to
 !X  //  the boolean NOT of X.
     // Implicit output

Retina, 3 bytes
%`0

Try it online!
For each line (%), count the number of 0s.

Python 2, 24 bytes (non-competing)
lambda a:[i-1for i in a]

Logic is similar to Steven's, but I tried to use this comment's idea, but different, because it still takes 0/1 arrays, not 0/-1. There is no byte shaving for using 0/-1, so let's be sane. Note that this is non-competing, until Steven or Lynn allows me to use the idea. If so, I might remove the non-competing mark. Note that this code cannot be shamelessly stolen, it's still here. Only Steven can use it for his answer.

Ruby, 14 bytes
Anonymous function:
->a{a.map &:!}

Test it:
->a{a.map &:!}.call([true, true, false, true, false, true, true])
# => [false, false, true, false, true, false, false]

Julia (1 Byte - Thanks to Dennis [See Comments])
!

Map the logical not to all elements of collection y, works due to automatic vectorization (as Dennis explained). My previous answer was basically using `f(n)=map(!,n)' to map the logical not, but Julia does this on it's own. Jeez, what a cool language. Second time using it, still trying to learn here!
Try it here

! (1 byte) is enough. ! vectorizes automatically.

In the console I had it didnt let me do that :(, plus thats a snippet, is it not?

I've tested it with version 0.4; it's possible that it doesn't work in older versions of Julia. ! by itself evaluates to a function, which can be saved in a variable (just like a lambda), and is therefore considered a valid function submission. For.example, you can use it like f=!;print(f([true,false])).

That's neat, technically 3 bytes for f=! though, unless just saying "!" is its own function works.

By community consensus, ! is a valid answer on ois own.

Perl 6, 9 bytes
*.map: !*

Usage:
say (*.map: !*)((0, 1, 1)) # (True False False)

Clojure, 12 bytes
#(map not %)

Basically the same as the Haskell answer. Unfortunately, Clojure doesn't have implicit partial application; thus the function macro.

APL (Dyalog Unicode), 1 byte
~

Try it online!

Factor, 4 bytes
vnot

Try it online!

Clojure, 12 bytes
(map not x)

as in:
(map not [true false true])

=> (false true false)
Updating due to the objection that this is not a function or program:
#(map not %)

Returns a function that nots anything passed to it.

This isn't a function or program, and preassumes x exists.

How is that different from the other examples?

Because the other answers are (mostly) all functions, and don't assume the existence of a variable for their code to work. Your second example is fine though.

Stata, 20 bytes
recode x (0=1) (1=0)

x is the input, and the rest is self-explanatory

Scala, 27 bytes
def f(a:Boolean*)=a map(!_)

Takes a bool array as varargs and maps each element to its inverse.

The type annotation isn't required is it? Shouldn't it be able to infer the type from !?

@Carcigenicate Sadly, Scala can't infer the types of method arguments.

Damn. Forgot about that. That's 9 bytes right there!

@Carcigenicate I can't use Int*, because that's neither truthy nor falsey.

Pyth, 2 bytes
!M

Explanation:  (M)ap boolean not (!) over input.
Try it online!

m! works aswell and makes more sense to me since you map the not over the input array.

@KarlKastor They compile down to the same thing, assign("Q", eval_input()); imp_print(Pmap(lambda d: Pnot(d), Q))

Hoon, 24 bytes
|*
*
(turn +< |=(? !+<))

Creates a generic gate, map over the contents of the list, negate all loobeans in it.
This uses the normal Hoon tricks, namely using a generic ("wet"/|*) gate to avoid having to specify the sample type, along with having unnamed samples (* or ?) and using tree navigation syntax (+<) to fetch them.
> a
~[%.y %.n %.n %.y %.n %.y]
> =f |*
  *
  (turn +< |=(? !+<))
> (f a)
~[%.n %.y %.y %.n %.y %.n]

braingasm, 9 bytes
,[48-z:,]

Assumes that input from stdin is a string of only "0"s and "1"s, i.e. bytes containing the value 48 or 49. Prints the negated values to stdout.
How it works:
Read one byte from stdin (,), and loop ([]) until the end of the input. For each byte, subtract 48 (48-) and print 1 if the result is 0 and vice versa  (z is the zero-flag, : prints the given integer value), then get another byte from stdin (,)
Run it like e.g. $ echo -n 001011 | braingasm invert.bg and get 110100

Groovy (19 Bytes)
{x->x.collect{!it}}

Simple mapping function in a closure.

Kotlin, 13 bytes
{it.map{!it}}

This is a lambda of (List<Boolean>)->List<Boolean> type (or (BooleanArray)->List<Boolean>, as map function on arrays returns lists instead of arrays).
{it.map{!it}.toBooleanArray()} would return the result as an actual array.

sed 8
y,01,10,

Takes input as 1s and 0s.

Scala, 36 35 34 bytes
def f(a:Array[Boolean])=a.map(!_)
Discovered I could remove the second space.
Discovered I could remove brackets.

Gogh, 4 bytes
{!}m

Usage:
$ ./gogh -noa '{!}m' "1 0 1 0 0 0 1"
[0 1 0 1 1 1 0]

Racket, 15 bytes
(curry map not)

Basically the Haskell answer.

Making this a lambda might make this more succinct, no? I was going to partially apply for my answer (partial map not,  Clojure), but a function macro ended up being smaller. Idk what Rackets anonymous functions look like though honestly.

Unfortunately Racket's shortest anonymous function uses the form of (λ (arguments) function-body), so it would be (λ(l)(map not l)) which is 18 bytes (the lambda symbol is two bytes). Interestingly, (map not(read)) is also 15 bytes.

It actually uses a lambda symbol? Damn. That seems needlessly complicated :/

(There is also lambda, but that's not applicable to code golfing at all.)

Pyke, 2 bytes
m!

Try it here!
map(not, input)

Golang, 40 bytes
func(a[]bool){for i,b:=range a{a[i]=!b}}

usage
package main
import "fmt"
func main() {
    a:=[]bool{true, true, false}
    func(a []bool){for i,b:=range a{a[i]=!b}}(a)
    fmt.Print(a) // => [false false true]
}

Brainfuck, 72 69 61 bytes
,>++++++++[<------>-]<>+<[->-<]>[<+>-]<>++++++++[<++++++>-]<.

Closest i managed to get as BF dosent have Array support
Formatting is stupid, i will fix it when i get a pc... Somehow it wont let me post it as a snippet

You could put all the lines together into one long line, it doesn't really matter for us (because with newlines, the total byte length is 78 bytes).

-4: ,>++++++++[<------>-]+<[->-<]>[<+>-]++++++++[<++++++>-]<.

Brainfuck, 24 bytes
,[>++[->++[<]>-]>-.>>>,]

Try it online!
The same as my answer to a similar question.
Relies on 8-bit wrapping cells, the cell size might not matter (untested) but wrapping definitely is. The main part the program is the >++[->++[<]>-]>- does some rather convoluted things to flip the last bit of the number.
A shorter solution of 19 bytes is
,[+[<[-->>]<--]<.,]

but this requires the < to noop if the data index is 0, instead of the more typical implementation of going into negative indeces.

PHP, 30 bytes
foreach($argv[1] as$i)echo!$i;

Testing code:
$argv[1] = [true,true,false,true,false,false,true,false];
foreach($argv[1] as$i)echo!$i;

Test online

C++11, 30 bytes
As unnamed lambda:
[](auto&v){for(auto&x:v)x=!x;}

Accepts any standard container like vector<int> (but not vector<bool>) or int[] or bool[].

For the suggested edit: making this a function would require a return type

6502 Machine Language - 14 Bytes
AE 00 01 CA B5 00 49 01 95 00 8A D0 F6 00

Array of bytes is in zero page. Length of array is in $0100.
Flipped array is in zero page.
Assembler code:
AE 00 01 - ldx $0100
CA       - dex
B5 00    - lda $00, X
49 01    - eor #$01
95 00    - sta $00, X
8A       - txa
D0 F6    - BNE (-10)
00       - BRK

(My first golf answer - sorry if format is off.)

Welcome to Code Golf, nice first answer! Your formatting is fine, don't worry :p

Vyxal a, 2 1 byte
-1 thanks to lyxal
†

Try it Online!

Try it Online! for 1 byte.

Python 3, 26 bytes
lambda s:[~x+2 for x in s]

Try it online!

Lexurgy, 12 bytes
Input is a string of as for truthy and bs for falsy.
These can be replaced with any two distinct characters, as a "proper" falsy value in Lexury would be an empty string, however since empty string is empty string, and infinite number of empty strings can be anywhere within a string, so two distinct characters are required.
a:
a=>b
b=>a

If you want numbers (16 bytes):
a:
\1=>\0
\0=>\1

Arturo, 15 bytes
$=>[map&=>not?]

Try it

Thunno 2, 1 byte
~

Attempt This Online!
Built-in for vectorised logical NOT.

Japt -m, 2 bytes
^1

Try it here

C, 37 bytes
f(a,l)int *a;{for(;l--;*a++=*a?0:1);}

a being the array (pointer) and l being the length of the array.
Readable version
f(t,i)int *t;{ // K&R to save bytes
  for(;i--; // Run i times
  *t++=*t?0:1); // Flip the value of array element and increment
}

 Common Lisp, 7
bit-not

Negate bits on a bit array.
Example
(bit-not #*00101010010100101001010010101)
=> #*11010101101011010110101101010

Ruby, 30 bytes
gets.split(?,).map{|e|!eval e}

"true,false" outputs false,true.

@EasterlyIrk Sorry didn't know about that. Newbie here

PHP , 45 Bytes
<?foreach($_GET[a]as$v)$a[]=1-$v;print_r($a);

As the question states 'Invert every element of the array and output it.' and people aren't usually too picky on output format, save 6 bytes by doing print_r($a); at the end

Okay I'll try it

You don't need the spaces there. Your whole code can be written as <?foreach($_GET[a]as$v)$a[]=1-$v;print_r($a);. This saves 2 bytes and works.

Java, 51 bytes
l.stream().map(b->!b).collect(Collectors.toList());

l = a Collection of Booleans
I feel like this could be shorter, then again golfing in java ^^

Unless the challenge says otherwise, all submissions need to be full programs or callable functions, as opposed to snippets which expect the input to be stored in a hardcoded variable. The shortest fix would probably be to wrap what you've got in a simple function body (or lambda, depending on Java version).

As alternative, you can use streams directly: s->s.map(b->!b). I'm currently asking on meta if this is acceptable or not.

Hmmm... Also, you don't reference the packages, either in import or full text.

If s->s.map(b->!b) that @OlivierGrégoire already posted wasn't allowed, you could still golf it by returning an Object-array l->l.stream().map(b->!b).toArray() instead (also, as stated by others, your current solution isn't valid. It should have a leading l->; Collectors should be java.util.stream.Collectors; and you can drop the trailing ;).

Swift(2.2) 44 bytes
I am using x as the input variable here. For example,
let x = [true,false]

¯\_(ツ)_/¯
Golfed
let y = {let b = $0.map({!$0});print(b);}(x)

unGolfed
let y = {
   let b = $0.map({!$0})
   print(b);
}(x)

PHP (231 Bytes)
function flip_bool_array($array) {
  $newarray = array();
  foreach ($array as $bool) {

   if ($bool === true) {
    $bool = false;
   } else {
    $bool = true;
   }

  $newarray[] = $bool;

}

return $newarray;

}

Explanation
The function accepts an array and loops over it testing each value for a true value and setting it to false, if the value is not true then it is set to true. Each boolean is added to a new array and returned.

Welcome to the site! You could take a ton of bytes off if you remove the extra whitespace, and shorten your variable names down to one letter each. Since the goal is just short code, readability is not important. Also, there's a great thread here for tips on golfing PHP code down further.

dc, 44 bytes
Append this to a line of space-delimited input and echo it into dc. Output is delimited with newlines and punctuated with error messages (due to the blatant abuse of k). If you quote the stuff, it'll give you even more errors. (When we re-vamp dc in the next version, we should probably do something about that.) I suggest pairing with a 2>nul or other system-specific hack for suppressing whiny programs.
0sz[1r-SAlz1+szz0<a]dsax[lzd1-szLApk0<a]dsax

Explained:
              # "ToS" := "top of stack"
0sz           # Initialise register `z' with 0: this will hold the length of our input
[             # Open macro definition
 1r-          #  Replace ToS with !(ToS): 1-1==0, 1-0==1
 SA           #  Store this result on the top of stack `A'
 lz1+sz       #  Increment z, our length counter
 z0<a         #  If the stack depth is positive, repeat (we still have input to negate)
]dsax         # Store a copy of macro in register `a' and execute it
              # At this point, our input has been negated and stored in A,
              #  first-in-first-out orientation
[             # Open macro definition
 lzd1-sz      #  Decrement z and keep a copy of it for later
 LA           #  Push ToS(A) onto stack; pop from A
 p            #  Peek at ToS
 k            #  `k' is for KILL THE TOP OF STACK BWAHAHAHA
 0<a          #  The value from register `z' is now on top: if positive, we still have
              #   values to print, so repeat macro
]dsax         # I'm in a chaotic mood, so let's just re-use `a'

If you prefer space-delimited output: s/pk/n32P/

dc, 47 bytes
?zsN0sI[z:az0<A]dsAx[lI1+ddsI;a1r-n32PlN>R]dsRx

The actual code to invert a boolean (0 or 1) is 1r-. The rest is for reading the list and printing it in the same order, which is quite hard because of the (LIFO) stack that dc uses to store the input.
Explanation:
?zsN0sI         # read input, LIFO, initialize N = nr_elements and I = 0 (iterator)
[z:az0<A]dsAx   # loop A: move the stack content into array 'a' (I add a[n] first,
                #then a[n-1], ..., then a[1] and a[0] is not used)
[lI1+ddsI;a     # loop R: increment iterator and push a[I] to stack (input order)
   1r-n32P         #invert value and print it with a space separator
lN>R]dsRx       #repeat (R)

Run:
dc -f invert_boolean.dc <<< "1 0 1 1"

Output: there is a trailing separator (space) at the end, but I hope that's ok
0 1 0 0

Note: my answer is similar in concept to that of @Joe's, but there are differences in terms of I/O handling, stack manipulation (I use arrays) and lack of warnings. Do check his answer as well.

Emacs Lisp, 25 bytes
(lambda(x)(mapcar'not x))

Not very creative.

Racket 11 bytes
(map not l)

Testing:
(define l '(#t #f #t)) ; define a list of booleans

(map not l)

Output:
'(#f #t #f)

><> Fish - 9 (16?) Bytes
My second golf and my first in ><> Fish!
l?!;r0=nr

I'm not sure how to count bytes when flags are considered, but this solution works when running the python interpreter with the -v flag and then space-separated 1's and 0's. If this doesn't match spec, I can remove the answer.
Example
Input/Run:
python fish.py --code "l?!;r0=nr" -v 0 1 0 1 1

Output:
10100

If I'm not allowed to use flags, and instead need to take the input from the input stack (such as on https://fishlanguage.com/playground), the code becomes longer as I must read from the input stack (either 1 or 0 without any separation) until there are no more values, and then convert the char value of the input (1 becomes 49 and 0 becomes 48) to their decimal values before my comparison. I'm not sure how to count bytes for ><> but I believe this would be 16 bytes.
i:1+?!;f3*3+-0=n

dimwit 8 bytes (non-competing)
R1,0}0,1

Replaces all 0's with 1's, and vice versa.
Takes input through a string of 0's and 1's, and outputs similarly.
Hopefully that's acceptable ;)
Try it here!

Yes, it is :) ...#

SmileBASIC, 25 bytes
DEF l l
ARYOP 1,l,1,l
END

Explanation:
DEF 'create a function
    l 'named "L"
      l 'with 0 outputs and 1 input named "L"
ARYOP 'array operation
      1 'mode 1 (subtract)
       ,l 'set each element in L to...
         ,1 '1 minus...
           ,l 'the corresponding element in L
END 'end function definition

FALSE, 13 bytes
[49^$0>][-.]#

Input is a list of 0 and 1 characters.

Tcl, 31 bytes
proc N L {lmap b $L {expr !$b}}

Try it online!

It renders more bytes as a command line argument:
https://tio.run/##K0nO@f@/oLSkWCE6JzexQCFJoVqrViWxKL1MoTq1oqBIQVElqTb2////BgoGCoZAbAAA

Zsh, 14 bytes
Assumes input is given as arguments. Try it Online!
for z;<<<$[!z]

Or without bending the rules so much, this uses array I/0 (26B):
for z ($A)B+=($[!z])
<<<$B

MMIX, 24 bytes (6 instrs)
00000000: 25010101 82ff0001 73ffff01 a2ff0001  %¢¢¢²”¡¢s””¢ɱ”¡¢
00000010: 5901fffc f8000000                    Y¢”‘ẏ¡¡¡

Requires at least one element. Pass array as first argument, length as second.
invarr  SUB  $1,$1,1        // loop: i--
        LDBU $255,$0,$1
        ZSZ  $255,$255,1
        STBU $255,$0,$1     // a[i] = !a[i]
        PBNN $1,invarr      // if(i >= 0) goto loop
        POP  0,0

Erlang, 43 38 bytes
n(Z)->lists:map(fun(X)->not X end,Z).
Many thanks to @Redwolf Programs for saving 5 bytes.

I don't know Erlang, but can any of that whitespace be removed?


text:
Write a Palindrome-Polyglot-Quine
Write a "palipolyquine": a program that is a quine, a polyglot,  and a palindrome.
Rules:

The number of polyglot languages is more preferable than code size.
The shortest answer (in bytes) wins, in case of a tie.
Polyglot and Quine rules see here: Write a Polyquine.

My example (I have a repository Freaky-Sources with tests):
C#/Java (1747 bytes):
/**///\u000A\u002F\u002A
using System;//\u002A\u002F
class Program{public static void//\u000A\u002F\u002A
Main//\u002A\u002Fmain
(String[]z){String s="`**?`@#_^using System;?_#^class Program{public static void?@#_^Main?_#main^(String[]z){String s=!$!,t=s;int i;int[]a=new int[]{33,94,38,64,35,95,96,63,36};String[]b=new String[]{!&!!,!&n!,!&&!,!&@!,!&#!,!&_!,!`!,!?!,s};for(i=0;i<9;i++)t=t.?@#_^Replace?_#replace^(!!+(char)a[i],b[i]);t+='*';for(i=872;i>=0;i--)t=t+t?@#_^[i];Console.Write?_#.charAt(i);System.out.printf^(t);}}/",t=s;int i;int[]a=new int[]{33,94,38,64,35,95,96,63,36};String[]b=new String[]{"\"","\n","\\","\\u000A","\\u002F","\\u002A","/","//",s};for(i=0;i<9;i++)t=t.//\u000A\u002F\u002A
Replace//\u002A\u002Freplace
(""+(char)a[i],b[i]);t+='*';for(i=872;i>=0;i--)t=t+t//\u000A\u002F\u002A
[i];Console.Write//\u002A\u002F.charAt(i);System.out.printf
(t);}}/*/}};)t(
ftnirp.tuo.metsyS;)i(tArahc.F200u\A200u\//etirW.elosnoC;]i[
A200u\F200u\A000u\//t+t=t)--i;0=>i;278=i(rof;'*'=+t;)]i[b,]i[a)rahc(+""(
ecalperF200u\A200u\//ecalpeR
A200u\F200u\A000u\//.t=t)++i;9<i;0=i(rof;}s,"//","/","A200u\\","F200u\\","A000u\\","\\","n\",""\"{][gnirtS wen=b][gnirtS;}63,36,69,59,53,46,83,49,33{][tni wen=a][tni;i tni;s=t,"/}};)t(^ftnirp.tuo.metsyS;)i(tArahc.#_?etirW.elosnoC;]i[^_#@?t+t=t)--i;0=>i;278=i(rof;'*'=+t;)]i[b,]i[a)rahc(+!!(^ecalper#_?ecalpeR^_#@?.t=t)++i;9<i;0=i(rof;}s,!?!,!`!,!_&!,!#&!,!@&!,!&&!,!n&!,!!&!{][gnirtS wen=b][gnirtS;}63,36,69,59,53,46,83,49,33{][tni wen=a][tni;i tni;s=t,!$!=s gnirtS{)z][gnirtS(^niam#_?niaM^_#@?diov citats cilbup{margorP ssalc^#_?;metsyS gnisu^_#@`?**`"=s gnirtS{)z][gnirtS(
niamF200u\A200u\//niaM
A200u\F200u\A000u\//diov citats cilbup{margorP ssalc
F200u\A200u\//;metsyS gnisu
A200u\F200u\A000u\///**/

Compilation available on ideone.com: C#, Java.

Are there any rules involved in making the poly-quine? Any limitations? If this question is as-is, then a possible (trivial) solution is 1 (which will output 1 in many languages here, and is palindromic).

I added more formal rules.

Ah, cool. Well, good luck on your first challenge! Just some more things though: you don't really need the code block there, and you should probably migrate the rules from the other challenge over to here.

Does a 5-language, 999-byte answer beat a 4-language, 100-byte answer?

@ETHproductions, I think yes. It's harder to add new language than reduce number of lines.

i say that 100 bytes solutions in too high languages are 1000 times slower than the C or assembly one 999 bytes

Just a suggestion...What about Help, WarDoq! as one language? At least with Q it outputs itself and ignores a lot of characters that might be used in other languages.

CJam/GolfScript, 2 languages, 50 bytes
{`"0$~e#"+0$-1%"":n}0$~e##e~$0}n:""%1-$0+"#e~$0"`{

Try it CJam!
Try it in GolfScript!
Huh, this went unanswered surprisingly long.
Explanation
It's probably easiest to explain this by showing how I turned the basic quine in each language into a palindromic polyglot quine.
So the basic quines in both languages are:
{".~"}.~

{"_~"}_~

In GolfScript and CJam, respectively. These are quite similar thanks to the fact that CJam was originally inspired by GolfScript (but has since deviated quite a lot). The first difference we notice is that one uses . for duplicating the top of the stack and the other uses _. A common trick to avoid this problem is to use 0$, since both languages have the "copy-nth-item-on-stack" operator $. So we get {"0$~"}0$~, although that still needs a trailing linefeed in GolfScript. But let's worry about that at the end.
First, we need to make it a palindrome. The obvious solution to this is to append a comment and put the source code there in reverse. This is quite simple, because CJam uses e# for comments, and in GolfScript e does nothing at all, and # is a comment. So if we append e#... that works for both languages. Here is what we've got:
{"0$~"}0$~e##e~$0}"~$0"{

Of course, that doesn't actually print the part from e# onward. We can reconstruct this quite easily from the source code itself. Both languages can turn the initial block into a string with ` and append the "0$~" part with +, so that we get the entire unmirrored source code in a single string. To append a mirrored copy, all we need to do is duplicate the string with 0$ again and then reverse it with -1%, which also works in both languages. So now we've got this:
{`"0$~e#"+0$-1%}0$~e##e~$0}%1-$0+"#e~$0"`{

This is a valid palindromic quine in CJam, and it also works in GolfScript but still prints that pesky trailing linefeed.
The usual way to prevent this is to assign an empty string to n, because what GolfScript really does is print the contents of n at the end. So what we need is "":n. So what about CJam? Thankfully, this does nothing at all. "" is also an empty string (or empty list, they're the same thing in CJam), and : maps the operator n (print with linefeed) over the list. But since the list is empty, mapping an operator over it does nothing at all. Hence, we can get rid of the linefeed, without messing with CJam, and end up with the final solution:
{`"0$~e#"+0$-1%"":n}0$~e##e~$0}n:""%1-$0+"#e~$0"`{

Perl 5/Ruby/PHP/JavaScript (Browser), 4 languages, 513 bytes
$_='$z=0?"$&".next: eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);//#//;)_%s(lave;%s%s%s=_%s",$d=$z[0]||h^L,$q=$z[1]||h^O,$_,$q,$d,$d,$q,"0"?$_.split("").reverse().join(""):~~reverse,$q,$d)';eval($_);//#//;)_$(lave;')d$,q$,esrever~~:)""(nioj.)(esrever.)""(tilps._$?"0",q$,d$,d$,q$,_$,O^h||]1[z$=q$,L^h||]0[z$=d$,"s%_=s%s%s%;eval(s%_);//#//;)_s%(lave;s%s%s%=_s%"(ftnirp;)"`cCJ`bota;gol.elosnoc=ftnirp"(lave :txen."&$"?0=z$'=_$

Try the Perl online!
Try it online!
Try the PHP online!
Validate it online!

$_='$z=0?"$&".next: eval("printf=console.log;atob`JCc`");printf("%s_=%s%s%s;eval(%s_);//#//;)_%s(lave;%s%s%s=_%s",$d=$z[0]||h^L,$q=$z[1]||h^O,$_,$q,$d,$d,$q,"0"?$_.split("").reverse().join(""):~~reverse,$q,$d)';eval($_);//#//;)_$(lave;')d$,q$,esrever~~:)""(nioj.)(esrever.)""(tilps._$?"0",q$,d$,d$,q$,_$,O^h||]1[z$=q$,L^h||]0[z$=d$,"s%_=s%s%s%;eval(s%_);//#//;)_s%(lave;s%s%s%=_s%"(ftnirp;)"`cCJ`bota;gol.elosnoc=ftnirp"(lave :txen."&$"?0=z$'=_$

source: Stack Exchange

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

sort: votes


text:
Counterfeit Coins on a Pointer Scale
You sell gold coins. Each gold coin you sell is supposed to be 1 ounce. However, you find out that one of your coin suppliers is cheating you. By alloying the gold material with something else, their coins weigh only 0.9 ounces. With a help of a pointer scale (one that shows the exact weight of a quantity of matter set on it), you want to determine which of your coin suppliers is selling you the counterfeit coins.
Apparently, you are not the only one to have this problem - lots of gold sellers buy coins from this supplier, and the supplier knows that it is being dodgy and is changing their branding accordingly. All of these sellers have the same problem - 1 ounce coins that end up being 0.9 ounces from this supplier - and need to solve it, fast! How can you determine, out of n suppliers, which one is the cheating supplier with the minimum number of weighings on the pointer scale?

Your task is to write a program function that can solve this problem automatically for n suppliers. It's input includes:

an integer number of suppliers, n,
an oracle function that represents weighing a set of coins on the balance scale

It must take this information, calling this function a minimum number of times and returning, as output, the index number of the cheating supplier.
The oracle function has the following specifications:

It takes as input an int->int mapping (as an array or dictionary, whichever your language prefers) mapping each supplier index (from 0 to n-1) to a number of gold coins that you want to try weighing on the scale.
The returned output is the total weight, in ounces, of the coins put on the scale.
The function is in whatever format your language prefers for passing procedures as data. For instance, functional languages will pass lambdas, C will take a function pointer, Java 7 and earlier will take a functional interface. Languages that support none of these, but do support string execution, will take these as strings.
In those cases when the oracle can be stringified or otherwise inspected as data, you may assume that it is sufficiently obfuscated such that you cannot tell which supplier is cheating without executing it.

This is also code-golf: among the solutions that call the function the minimum number of times, the smallest solution in bytes is the winner!

NOTE: If your language does not support functions at all, but does support string execution, write your program as a standalone program - assume that the number of suppliers, followed by the oracle, will be passed into standard input. If your language does not support string execution, assume that a file path to a binary oracle will be provided instead.

Related.

Also related.

If you know that exactly one supplier is cheating, and you know the exact weights involved, and you are allowed to use any number of coins per weighing, then I'm pretty sure you can identify the cheater in one weighing regardless of how many suppliers there are.

Python, 33 bytes
lambda n,f:n*~-n*5-f(range(n))*10

Puts 0 coins from supplier 0, 1 coin from supplier 1, ... n-1 coins from supplier n-1. The deficit is then 0.1 for each coin sent to the cheating supplier, so i/10. We therefore subtract the oracle value from the fair sum n*(n-1)/2 and multiply by 10. Distributing the *10 saved on parens for a shorter expression.

Python 2, 56 48 44 bytes
Uses 1 weighing
-8 bytes thanks to @feersum (use range(0,10*n,10))
def f(n,o):x=range(n);return(sum(x)-o(x))*10

Example runs at ideone
Places i coins from each of the suppliers i in [0,n-1] on the scale, subtracts the weighing from the total number of coins weighed and multiplies by 10.
(Python 3 will return float values that start to differ)

[i*10for i in range(n)] saves a byte.

Better yet, range(0,10*n,10).

@feersum Oh, yeah. I wasn't even paying attention to the right half of the comprehension.

Even if you didn't know about 3-argument range, def f(n,o):x=range(n);return(sum(x)-o(x))*10 would be much shorter so how did you conclude that multiplying by 10 in the input would be better?

@feersum because I didn't think that passing the range was an option :)

Mathematica, 23 Byte
5#(#+1)-1-10#2@Range@#&

Same approach as xnor. In Mathematica Range starts with 1, which is equivalent to using n+1 coins from the nth supplier. Hence, the formula for the fair sum is n(n+1)/2 and we have to subtract 1 from the result to restore zero-based indexing.
5#(#+1)-1-10#2@Range@#&[5,oracle]

149 - 10 oracle[{1, 2, 3, 4, 5}]

Pyth, 9 bytes
-FsMlBm*T

As o cannot be used for the oracle in Pyth (it takes in a lambda itself), I instead defined the oracle as l.  Any one-input function other than s should work as the oracle.  Returns 0-indexed input.
Explanation (assuming the 3rd vendor is the faulty one):
      m*T        Map d*10 over all d in range(input): [0, 10, 20, 30] for input = 4
    lB           Bifurcate over the oracle function: [[0,10,20,30],58.0]
  sM             Map sum (for arrays, floors numbers): [60,58]
-F               Fold over subtraction: 2
                 Implicitly print

Try it online! (first line sets up the oracle function)
Try changing the faulty vendor!  (The faulty vendor is 0-indexed: from 0 to first input - 1.  Any other value will cast the blame on the 0th vendor.)

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


text:
Output the largest number with the fewest digits
Given a nonempty list of positive decimal integers, output the largest number from the set of numbers with the fewest digits.
The input list will not be in any particular order and may contain repeated values.
Examples:
[1] -> 1
[9] -> 9
[1729] -> 1729
[1, 1] -> 1
[34, 3] -> 3
[38, 39] -> 39
[409, 12, 13] -> 13
[11, 11, 11, 1] -> 1
[11, 11, 11, 11] -> 11
[78, 99, 620, 1] -> 1
[78, 99, 620, 10] -> 99
[78, 99, 620, 100] -> 99
[1, 5, 9, 12, 63, 102] -> 9
[3451, 29820, 2983, 1223, 1337] -> 3451
[738, 2383, 281, 938, 212, 1010] -> 938

The shortest code in bytes wins.

Can the input numbers be on separate lines?

@seshoumara That sounds reasonable, yes.

Pyth, 7 3 6 bytes
eS.ml`

Test Suite
Explanation:
e      Still grab the last element
 S      Still sort
  .ml`   But prefilter the list for those with the (m)inimum length.

7 byte solution:
eSh.gl`

Test Suite
Explanation:
   .g   Group items in (implicit) input by:
     l  The length of
      ` their representation
  h     Get those with the shortest length
 S      Sort the resulting list
e       and grab the last (i.e. largest) element

Jelly, 7 bytes
DL,NµÞḢ

Test it at TryItOnline
Or see all test cases also at TryItOnline
How?
DL,NµÞḢ - Main link takes one argument, the list, e.g. [738, 2383, 281, 938, 212, 1010]
D       - convert to decimal, e.g. [[7,3,8],[2,3,8,3],[2,8,1],[9,3,8],[2,1,2],[1,0,1,0]]
 L      - length, e.g. [3,4,3,3,3,4]
   N    - negate, e.g [-738, -2383, -281, -938, -212, -1010]
  ,     - pair, e.g. [[3,-738],[4,-2383],[3,-281],[3,-938],[3,-212],[4,-1010]]
    µ   - make a monadic chain
     Þ  - sort the input by that monadic function, e.g [938,738,281,212,2383,1010]
          (the lists in the example are not created, but we sort over the values shown)
      Ḣ - pop and return the first element, e.g. 938

Great use of sort!

@miles your way was still inspired :)

Looks like ÐṂ and ÐṀ (leads to a 6 byte answer) were added hours after this answer :P

05AB1E, 5 bytes
Code:
({é¬(

Explanation:
(      # Negate the list, e.g. [22, 33, 4] -> [-22, -33, -4]
 {     # Sort, e.g. [-22, -33, -4] -> [-33, -22, -4]
  é    # Sort by length, e.g. [-33, -22, -4] -> [-4, -22, -33]
   ¬   # Get the first element.
    (  # And negate that.

Uses the CP-1252 encoding. Try it online!

Python 2, 48 42 bytes
-6 bytes thanks to @Dennis (use min rather than sorted)
lambda l:min(l,key=lambda x:(len(`x`),-x))

All test cases are at ideone
Take the minimum of the list by (length, -value)

min should work instead of sorted.

@Dennis, oh jeez - thanks! Probably different enough to have posted that yourself though.

Swapping sorted()[0] for min? I consider that a trivial modification of your original code.

There's also len(`x`)+1./x for the same length. Too bad you need the 1..

Well, that's shorter than what I came up with. Good job!

Ruby, 34 bytes
->a{a.max_by{|n|[-n.to_s.size,n]}}

See it on eval.in: https://eval.in/643153

MATL, 14 bytes
10&YlktX<=G*X>

Try it online!
Explanation:
  &Yl           % Log
10              % Base 10
     kt         % Floor and duplicate
       X<       % Find the smallest element
         =      % Filter out elements that do not equal the smallest element
          G     % Push the input again
           *    % Multiply (this sets numbers that do not have the fewest digits to 0)
            X>  % And take the maximum

Retina, 24 16 bytes
O^`
O$#`
$.0
G1`

Try it online! or run all test cases.
Saved 8 bytes thanks to Martin!
The all test is using a slightly older version of the code, but the algorithm is identical. I'll update it to be closer when I get more time.
The trailing newline is significant. Sorts the numbers by reverse numeric value, then sorts them by number of digits. This leaves us with the largest number with the fewest digits in the first position, so we can just delete the remaining digits.

If you make the input linefeed-separated you can omit the regex from both sorting stages and then use `G1`` for the last stage.

Also, the first stage doesn't need #. You only care about relative order for a given integer length, and within one length lexicographic sorting of numbers is correct.

@MartinEnder Thanks! I've added both your tips. I should have suggested \w+ as the default for sorting, that way I wouldn't need to struggle as much to make the test suites ;)

Here is another 16, in case it gives you any ideas for further golfing: http://retina.tryitonline.net/#code=bWAkCn4KT15gClJzYH4uKw&input=MQoxMgo5CjYzCjUKMTAy

Perl 6, 18 bytes
*.min:{.chars,-$_}

Explanation:
*\        # Whatever lambda
.min:     # find the minimum using

{         # bare block lambda with implicit parameter ｢$_｣

  .chars, # number of characters first ( implicit method call on ｢$_｣ )
  -$_     # then negative of the value in case of a tie
}

Usage:
say [738, 2383, 281, 938, 212, 1010].&( *.min:{.chars,-$_} ); # 938

my &code = *.min:{.chars,-$_}

say code [78, 99, 620, 10]; # 99

Mathematica, 33 31 bytes
Max@MinimalBy[#,IntegerLength]&

MinimalBy selects all the elements of the original input list with the smallest score according to IntegerLength, i.e., with the smallest number of digits; and then Max outputs the largest one.
Thanks to Martin Ender for finding, and then saving, 2 bytes for me :)

K (ngn/k), 16 15 14 bytes
|/{=/&/\#'$x}#

Try it online!

{...}# set up a filter, returning elements from the (implicit) right argument where the code in {...} returns 1s

#'$x count the number of characters in the string representation of each input
&/\ generate a two item list of the character counts and their minimum
=/ generate a boolean mask indicating which indices have the fewest digits

|/ return the maximum (remaining) value

c=&/c: can be =/&/\ for -1

Nice! A clever way to avoid the inline assignment.

Jelly, 8 bytes
DL€İMị¹Ṁ

Try it online! or Verify all test cases.
Explanation
DL€İMị¹Ṁ  Input: list A
D         Convert each integer to a list of base 10 digits
 L€       Get the length of each list (number of digits of each)
   İ      Take the reciprocal of each
    M     Get the indices of the maximal values
      ¹   Get A
     ị    Select the values at those indices from A
       Ṁ  Find the maximum and return

How is this 8 bytes? Do all of these characters fit in ASCII?

@FedericoPoloni Yes, they do fit, although in another codepage.

J, 21 14 bytes
Saved 7 bytes thanks to miles and (indirectly) Jonathan!
{.@/:#@":"0,.-

This is a four-chain:
{.@/: (#@":"0 ,. -)

Let's walk over the input 10 27 232 1000. The inner fork consists of three tines. #@":"0 calculates the sizes, ,. concats each size with its negated (-) member. For input 10 27 232 1000, we are left with this:
   (#@":"0 ,. -) 10 27 232 1000
2   _10
2   _27
3  _232
4 _1000

Now, we have {.@/: as the outer tine. This is monadic first ({.) over dyadic sort (/:). That is, we'll be taking the first element of the result of dyadic /:. This sorts its right argument according to its left argument, which gives us for our input:
   (/: #@":"0 ,. -) 10 27 232 1000
27 10 232 1000

Then, using {. gives us the first element of that list, and we are done:
   ({.@/: #@":"0 ,. -) 10 27 232 1000
27

Old version
>./@(#~]=<./@])#@":"0

Still working on improvements. I golfed it down from 30, and I think this is good enough. I'm going to first break it down into basic parts:
   size =: #@":"0
   max =: >./
   min =: <./
   over =: @
   right =: ]
   left =: [
   selectMin =: #~ right = min over right

   f =: max over selectMin size
   f 3 4 5
5
   f 3 4 53
4
   f 343 42 53
53

Here's how this works.
>./@(#~ ] = <./@]) #@":"0

This is a monadic train, but this part is a hook. The verb >./@(#~ ] = <./@]) is called with left argument as the input to the main chain and the sizes, defined as #@":"0, as the right argument. This is computed as length (#) over (@) default format (":), that is, numeric stringification, which is made to apply to the 0-cells (i.e. members) of the input ("0).
Let's walk over the example input 409 12 13.
   (#@":"0) 409 12 13
3 2 2

Now for the inner verb, >./@(#~ ] = <./@]). It looks like >./@(...), which effectively means maximum value (>./) of (@) what's inside (...). As for the inside, this is a four-train, equivalent to this five-train:
[ #~ ] = <./@]

[ refers to the original argument, and ] refers to the size array; 409 12 13 and 3 2 2 respectively in this example. The right tine, <./@], computes the minimum size, 2 in this case. ] = <./@] is a boolean array of values equal to the minimum, 0 1 1 in this case. Finally, [ #~ ... takes values from the left argument according the right-argument mask. This means that elements that correspond to 0 are dropped and 1 retained. So we are left with 12 13. Finally, according to the above, the max is taken, giving us the correct result of 13, and we are done.

Some shuffling plus a hook can save a byte >./@#~[:(=<./)#@":"0. I think there might be a bit more to save

@miles XD I just finished writing explanation. Ah well, let me take a look at this beauty...

Jonathan found a better method. If we convert it to J, its 14 bytes {.@/:#@":"0,.- but the input has to be shaped as a list

@miles "shaped as a list"? You mean, like 400 12 13?

JavaScript (ES6), 51
l=>l.sort((a,b)=>(a+l).length-(b+l).length||b-a)[0]

Test

f=l=>l.sort((a,b)=>(a+l).length-(b+l).length||b-a)[0]

;[
 [[1], 1]
,[[9], 9]
,[[1729], 1729]
,[[1, 1], 1]
,[[34, 3], 3]
,[[38, 39], 39]
,[[409, 12, 13], 13]
,[[11, 11, 11, 1], 1]
,[[11, 11, 11, 11], 11]
,[[78, 99, 620, 1], 1]
,[[78, 99, 620, 10], 99]
,[[78, 99, 620, 100], 99]
,[[1, 5, 9, 12, 63, 102], 9]
,[[3451, 29820, 2983, 1223, 1337], 3451]
,[[738, 2383, 281, 938, 212, 1010], 938]
].forEach(([l,x])=>{
  var r=f(l)
  console.log(r==x?'OK':'KO',l+' -> '+r)
})

Julia, 39
f(l)=sort(l,by=x->(length("$x"),-x))[1]

ATOable

Welcome back to code golf! 34 bytes

and you can check Tips for golfing in Julia

JavaScript (ES6), 62 bytes

var solution =

a=>a.map(n=>(l=`${n}`.length)>a?l>a+1|n<r?0:r=n:(a=l-1,r=n))|r

;document.write('<pre>' + `
[1] -> 1
[9] -> 9
[1729] -> 1729
[1, 1] -> 1
[34, 3] -> 3
[38, 39] -> 39
[409, 12, 13] -> 13
[11, 11, 11, 1] -> 1
[11, 11, 11, 11] -> 11
[78, 99, 620, 1] -> 1
[78, 99, 620, 10] -> 99
[78, 99, 620, 100] -> 99
[1, 5, 9, 12, 63, 102] -> 9
[3451, 29820, 2983, 1223, 1337] -> 3451
[738, 2383, 281, 938, 212, 1010] -> 938
`.split('\n').slice(1, -1).map(c =>
  c + ', result: ' + solution(eval(c.slice(0, c.indexOf('->'))))
).join('\n'))

Javascript (ES6), 57 54 53 bytes
l=>l.sort((a,b)=>(s=a=>1/a+`${a}`.length)(a)-s(b))[0]

For the record, my previous version was more math-oriented but 1 byte bigger:
l=>l.sort((a,b)=>(s=a=>1/a-~Math.log10(a))(a)-s(b))[0]

Test cases

let f =
l=>l.sort((a,b)=>(s=a=>1/a+`${a}`.length)(a)-s(b))[0]

console.log(f([1]));                              //  -> 1
console.log(f([9]));                              //  -> 9
console.log(f([1729]));                           //  -> 1729
console.log(f([1, 1]));                           //  -> 1
console.log(f([34, 3]));                          //  -> 3
console.log(f([38, 39]));                         //  -> 39
console.log(f([409, 12, 13]));                    //  -> 13
console.log(f([11, 11, 11, 1]));                  //  -> 1
console.log(f([11, 11, 11, 11]));                 //  -> 11
console.log(f([78, 99, 620, 1]));                 //  -> 1
console.log(f([78, 99, 620, 10]));                //  -> 99
console.log(f([78, 99, 620, 100]));               //  -> 99
console.log(f([1, 5, 9, 12, 63, 102]));           //  -> 9
console.log(f([3451, 29820, 2983, 1223, 1337]));  //  -> 3451
console.log(f([738, 2383, 281, 938, 212, 1010])); //  -> 938

Java 7, 112 104 bytes
int c(int[]a){int i=a[0],j;for(int b:a)i=(j=(i+"").length()-(b+"").length())>0?b:b>i&j==0?b:i;return i;}

Different approach to save multiple bytes thanks to @Barteks2x.
Ungolfed & test cases:
Try it here.
class M{
  static int c(int[] a){
    int i = a[0],
        j;
    for(int b : a){
      i = (j = (i+"").length() - (b+"").length()) > 0
           ? b
           : b > i & j == 0
              ? b
              : i;
    }
    return i;
  }

  public static void main(String[] a){
    System.out.println(c(new int[]{ 1 }));
    System.out.println(c(new int[]{ 9 }));
    System.out.println(c(new int[]{ 1729 }));
    System.out.println(c(new int[]{ 1, 1 }));
    System.out.println(c(new int[]{ 34, 3 }));
    System.out.println(c(new int[]{ 409, 12, 13 }));
    System.out.println(c(new int[]{ 11, 11, 11, 1 }));
    System.out.println(c(new int[]{ 11, 11, 11, 11 }));
    System.out.println(c(new int[]{ 78, 99, 620, 1 }));
    System.out.println(c(new int[]{ 78, 99, 620, 100 }));
    System.out.println(c(new int[]{ 1, 5, 9, 12, 63, 102 }));
    System.out.println(c(new int[]{ 3451, 29820, 2983, 1223, 1337 }));
    System.out.println(c(new int[]{ 738, 2383, 281, 938, 212, 1010 }));
  }
}

Output:
1
9
1729
1
3
13
1
11
1
99
9
3451
938

shorter version: int c(int[]a){int i=a[0],j;for(int b:a)i=(j=(i+"").length()-(b+"").length())>0?b:b>i&j==0?b:i;return i;}

@Barteks2x Thanks, I've edited it.

dc, 54 bytes
?dZsL0sN[dsNdZsL]su[dlN<u]sU[dZlL=UdZlL>ukz0<R]dsRxlNp

Explanation:
?dZsL0sN                  # read input, initialize L (length) and N (number)
[dsNdZsL]su               # macro (function) 'u' updates the values of L and N
[dlN<u]sU                 # macro 'U' calls 'u' if N < curr_nr
[dZlL=U dZlL>ukz0<R]dsR   # macro 'R' is a loop that calls 'U' if L == curr_nr_len
                          #or 'u' if L > curr_nr_len
xlNp                      # the main: call 'R' and print N at the end

Run example: 'input.txt' contains all the test cases in the question's statement
while read list;do echo "$list -> "$(dc -f program.dc <<< $list);done < input.txt

Output:
1 -> 1
9 -> 9
1729 -> 1729
1 1 -> 1
34 3 -> 3
38 39 -> 39
409 12 13 -> 13
11 11 11 1 -> 1
11 11 11 11 -> 11
78 99 620 1 -> 1
78 99 620 10 -> 99
78 99 620 100 -> 99
1 5 9 12 63 102 -> 9
3451 29820 2983 1223 1337 -> 3451
738 2383 281 938 212 1010 -> 938

bash, awk, sort 53 bytes
set `awk '{print $0,length($0)}'|sort -rnk2n`;echo $1

Read input from stdin, one value per line

bash and sort, 58 57 bytes
set `sort -n`;while((${#2}==${#1}));do shift;done;echo $1

doesn't work for last sample gave 2383 instead of 938

@Archemar sorry I misread the question, it is corrected now

You can remove the space between while and ((.

JavaScript ES6, 80 77 70 bytes
a=>Math.max(...a.filter(l=>l.length==Math.min(...a.map(i=>i.length))))

I hope I am going in the right direction...

Could you replace a.map(i=>i.length).sort((a,b)=>a-b)[0] with Math.min(...a.map(i=>i.length))?

@user81655 yup, I can. I thought I had made that edit but apparently I did not

You could also try negating the minimum so that you can reuse the Math.max: a=>(m=Math.max)(...a.filter(l=>l.length==-m(...a.map(i=>-i.length)))) It seems to save only 1 byte though.

For another byte the filter can be replaced with a map that returns 0 for values that do not pass the test: a=>(m=Math.max)(...a.map(l=>l.length+m(...a.map(i=>-i.length))?0:l))

Brachylog, 16 bytes
or:@]feL:la#=,Lh

Try it online!
Explanation
or                 Sort the list in descending order.
  :@]f             Find all suffixes of the list.
      eL           Take one suffix L of the list.
        :la        Apply length to all numbers in that suffix.
           #=,     All lengths must be equal.
              Lh   Output is the first element of L.

Haskell, 39 bytes
snd.maximum.map((0-).length.show>>=(,))

This doesn't work, it prefers 34 to 2.

oh, thanks. I have to rethink it..

Works better now!

Perl, 38 37 bytes
Includes +1 for -a
Give input on STDIN:
perl -M5.010 maxmin.pl <<< "3451 29820 2983 1223 1337"

maxmin.pl:
#!/usr/bin/perl -a
\$G[99-y///c][$_]for@F;say$#{$G[-1]}

Uses memory linear in the largest number, so don't try this on too large numbers. A solution without that flaw is 38 bytes:
#!/usr/bin/perl -p
$.++until$\=(sort/\b\S{$.}\b/g)[-1]}{

All of these are very awkward and don't feel optimal at all...

MATL, 11 bytes
tV48\&XS0))

Input is a column vector (using ; as separator), such as
[78; 99; 620; 100]

Try it online! Or verify all test cases.
Explanation
Let's use input [78; 99; 620; 100] as an example.
t      % Input column vector implicitly. Duplicate
       %   STACK: [78; 99; 620; 100], [78; 99; 620; 100]
V      % Convert to string. Each number is a row, left-padded with spaces
       %   STACK: [78; 99; 620; 100], [' 78'; ' 99'; '620'; '100']
48\    % Modulo 48. This transforms each digit into the corresponding number,
       % and space into 32. Thus space becomes the largest "digit"
       %   STACK: [78; 99; 620; 100], [32 7 8; 32 9 9; 6 2 0; 1 0 0]
&XS    % Sort rows in lexicographical order, and push the indices of the sorting
       %   STACK: [78; 99; 620; 100], [4; 3; 1; 2]
0)     % Get last value
       %   STACK: [78; 99; 620; 100], 2
)      % Index
       %   STACK: 99
       % Implicitly display

Nice to see the stack states in your explanation!

R, 72 41 36 bytes
Rewrote the function with a new approach. Golfed 5 bytes thanks to a suggestion from @bouncyball.
n=nchar(i<-scan());max(i[n==min(n)])

Explained:
        i<-scan()       # Read input from stdin
n=nchar(         );     # Count the number of characters in each number in i
max(             )      # Return the maximum of the set where
    i[n==min(n)]        # the number of characters is the minimum number of characters.

function(i){while(1){if(length(o<-i[nchar(i)==T]))return(max(o));T=T+1}}

Indented/explained:
function(i){               # Take an input i
  while(1){                # Do the following continuously:
    if(length(
        o<-i[nchar(i)==T]) # Define o to be the subset of i with numbers of length T,
      )                    # where T is 1 (a built-in!).
                           # We take the length of this subset (its size), and then pass
                           # it to if(). Thanks to weak typing, this numeric is converted
                           # to a logical value. When this occurs, zero evaluates to FALSE
                           # and any non-zero number evaluates to TRUE. Therefore, the if()
                           # is TRUE iff the subset is not empty.
      return(max(o));      # If it's true, then we just return the largest element of the
                           # subset, breaking out of our loop.
    T=T+1                  # Otherwise, increment our counter and continue.
  }
}

Save 4 bytes by not defining function: i=scan();n=nchar(i);max(i[n==min(n)])

@bouncyball Thanks! And 1 further byte saved by n=nchar(i<-scan()).

PowerShell v2+, 41 bytes
($args[0]|sort -des|sort{"$_".length})[0]

Takes input $args, sorts it by value in -descending order (so bigger numbers are first), then sorts that by the .length in ascending order (so shorter lengths are first). We then take the [0] element, which will be the biggest number with the fewest digits.
Examples
PS C:\Tools\Scripts\golfing> @(78,99,620,1),@(78,99,620,10),@(78,99,620,100),@(1,5,9,12,63,102),@(3451,29820,2983,1223,1337),@(738,2383,281,938,212,1010)|%{($_-join',')+" -> "+(.\output-largest-number-fewest-digits.ps1 $_)}
78,99,620,1 -> 1
78,99,620,10 -> 99
78,99,620,100 -> 99
1,5,9,12,63,102 -> 9
3451,29820,2983,1223,1337 -> 3451
738,2383,281,938,212,1010 -> 938

Quick improvement to 36 bytes

Bash + coreutils, 58 bytes
d=`sort -n`;egrep ^.{`sed q<<<"$d"|wc -L`}$<<<"$d"|tail -1

Input format is one value per line. Golfing suggestions are welcomed.
Explanation:
d=`sort -n`                             #save the list in ascending numerical order
egrep ^.{                    }$<<<"$d"  #print only list lines having as many chars
         `sed q<<<"$d"|wc -L`                 #as the first sorted line does
|tail -1                                #and then get the last one (the answer)

+1 thank you now I know that sed q = head -1

Python 2 - 41 bytes
lambda l:max((-len(`x`),x) for x in l)[1]

APL (Dyalog Unicode), 36 bytes
-4 thanks to @rak1507.
f←⌈/⊢×((⌊/=⊢)≢∘⍕¨)

Try it online!

⌈/⊢×((⌊/=⊢)≢∘⍕¨) works I think

Jelly, 6 bytes
DL$ÐṂṀ

Try it online!
How it works
DL$ÐṂṀ - Main link. Takes a list L on the left
  $ÐṂ  - Take the elements of L for which the following is minimal:
DL     -   Digit Length
     Ṁ - Maximum of those elements

Factor, 25 bytes
[ all-shortest supremum ]

Try it online!
Get the largest of the shortests.

Japt -h, 4 bytes
Input as an array of integer strings, output as an integer string.
üÊÎñ

Try it
üÊÎñ     :Implicit input of array
ü        :Group and sort by
 Ê       :  Length
  Î      :First element
   ñ     :Sort
         :Implicit output of last element

Vyxal, 5 bytes
⁽₍LN∵

Try it Online!
How?
⁽₍LN∵
⁽     # Next element as a lambda:
 ₍    #  Apply both of the next two elements and wrap the results in a list:
  L   #   Length...
   N  #   ...and negate
    ∵ # Get the minimum of the input by that function

Pip, 11 bytes
@Y#_AE-_SKa

Try It Online!

C (clang), 77 bytes
m,n,i,j;f(*a,l){for(j=99;l--;m=i<j|i>j^n>m?j=i,n:m)i=log10(n=a[l]);return m;}

Try it online!

Python 2, 63 30 63 bytes
lambda a:a.sort()or[`i`for i in a if len(`i`)==len(`a[0]`)][-1]

Bugged for [1, 99, 620, 10000, 3].

I agree with orlp, doesn't work

Once again, a wrong anser with an upvote? This should be amended or deleted

Python 2, 58 bytes
def F(x):l={len(`i`):i for i in sorted(x)};print l[min(l)]

Python 3, 56 bytes
lambda a:sorted(sorted(a),key=lambda x:-len(str(x)))[-1]

Uses a lambda in a lambda!
Python 2, 53 bytes
s=lambda a:sorted(sorted(a),key=lambda x:-len(`x`))[-1]

Same but with backticks

Pip, 11 bytes
(SNgSK-#_v)

Takes input as command-line args. Try it online!
First time using the Sort-Keyed operator! Like Python's sorted(), it takes a function that is applied to each item of the iterable and the result used as a sort key. Here's how this program works:
 SNg         List of cmdline args, sorted numerically in increasing order
    SK       Sort with key function...
      -#_    ... negative length(x), thus putting the shortest numbers at the end but not
               affecting the relative ordering among numbers with the same length
(        v)  Get the last element (index -1) and auto-print

Clojure, 63 bytes
(reduce #(if(=(quot %1 10)(quot %2 10))(max %1 %2) %1)(sort x))

as in:
(reduce #(if(=(quot %1 10)(quot %2 10))(max %1 %2) %1)(sort[3 7 121 11 8 2 10 9]))
=> 9

Though I'm sure there's a way to make it smaller.

PHP , 86 Bytes
<?$l=strlen($r=min($a=$_GET[a]));foreach($a as$v)if($v>$r&strlen($v)==$l)$r=$v;echo$r;

Pyke, 7 bytes
.#_il)h

Try it here!

C#, 119 bytes
int L(int[]n){var g=n.GroupBy(o=>(o+"").Length);return g.Where(o=>o.Key==g.Min(k=>k.Key)).OrderBy(o=>o).First().Max();}

Ungolfed:
public int L(int[]n)
{
  var g = n.GroupBy(o => (o+"").Length);
  return g.Where(o => o.Key == g.Min(k => k.Key)).OrderBy(o => o).First().Max();
}

Magical Linq...
Usage:
var a = new LargestNumberFewestDigits();
Console.Write(a.L(new int[] { 738, 2383, 281, 938, 212, 1010 }));

Output:
938

Java 8, 110 bytes
int f(int[]a){java.util.Arrays.sort(a);int i=a[0];for(int z:a)i=(z+"").length()>(i+"").length()?i:z;return i;}

Ungolfed:
int f(int[]a){
    java.util.Arrays.sort(a);                  //sorts the array in ascending order
    int i=a[0];                                //declare output variable, uses 1 less byte than using a[0]
    for(int z:a) {
        i=(z+"").length()>(i+"").length()?i:z; //for each int, if the length isn't longer set as output
    }
    return i;
}

Any elements that aren't longer in a sorted array must be a higher value.
Also lambda version (101 bytes):
a->{java.util.Arrays.sort(a);int i=a[0];for(int z:a)i=(z+"").length()>(i+"").length()?i:z;return i;};

C# (85 bytes)
It's a full function:
int y(int[] t) {int m=t.Min(i=>(i+"").Length);return t.Max(n=>(n+"").Length==m?n:0);}

Unriddled:
int y(int[] t)
{
    int m = t.Min(i => (i+"").Length);
    return t.Max(n => (n+"").Length == m ? n : 0);
}

There's an useless whitespace after you function signature and in the parameter list. Lambda statement should also work.

C# 85 bytes
int S(int[] i){var m=i.Min();return i.Where(v=>v<m*10&&$"{v}{m}".Length%2==0).Max();}

Usage:
Console.WriteLine(S(new[] { 738, 2383, 281, 938, 212, 1010 }));

Output: 938
Explanation
Get the minimum value from the array and assume that the minimum value is the value with the shortest length.
Filter the array to remove all values greater than 10 * the minimum. i.e if the value is 8, the first check removes all values greater than 80.
Also filter to remove all values where the length of the combined string is odd.  "8" + "9" is length 2 which is even, "8" + "10" is length 3 which is odd and eliminated.
int S(int[] i)
{
    var m = i.Min();
    return i.Where(v => v < m * 10 && $"{v}{m}".Length % 2 == 0).Max();
}

int[]i will work.

C# 72 bytes
int S(int[]i){return i.OrderBy(v=>(""+v).Length).ThenBy(v=>-v).First();}

Borrowing from some of the other answers, a very efficient way to accomplish this task is to sort by number of digits, then by value descending.  This moves the answer to the first position.  Linq accomplishes this fairly simply with the OrderBy and ThenBy statements.
Console.WriteLine(S(new[] { 738, 2383, 281, 938, 212, 1010 }));

Output: 938

Racket 148 bytes
(λ(l)(define l2(map number->string l))(apply max(map string->number
(filter(lambda(x)(eq?(string-length x)(apply min(map string-length l2))))l2))))

Testing:
(f (list 1 5 9 12 63 102))

Output:
9

Detailed version:
(define (f sl)
  (define sl2 (map number->string sl))
  (apply max
         (map string->number
              (filter (lambda(x)
                        (equal? (string-length x)
                                (apply min (map string-length sl2))
                                )) sl2))))

SQLite, 49 bytes
SELECT n FROM a ORDER BY length(n),n DESC LIMIT 1

Of course only if the list is allowed to be in a table. The type of the field should be INTEGER.

C++11, 109 bytes
[](auto a){sort(a.begin(),a.end(),[](auto x,auto y){return (int)log10(x)<=(int)log10(y)&&x>y;});return a[0];}

a should be a container like vector or list. E.g. (lambda as f)
cout<<f(vector<int>{ 10, 13, 19, 100, 12200 });

Common Lisp, 136 bytes
Golfed:
(defun o(&rest r &aux(s(sort r '<)))(flet((f(x)(floor(log x 10))))(apply 'max(remove-if(lambda(x)(<(apply 'min(mapcar 'f s))(f x)))s))))

Ungolfed:
(defun o (&rest r
      &aux (s (sort r '<)))
  (flet ((f (x) (floor (log x 10))))
    (apply 'max
       (remove-if (lambda (x)
            (< (apply 'min (mapcar 'f s))
               (f x)))
              s))))

Pascal (FPC), 169 167 bytes
A function which takes variable array as input:
function m(a:array of integer):integer;var i:integer;begin m:=a[0];for i in a do if(int(log10(i))<int(log10(m)))or((int(log10(i))=int(log10(m)))and(i>m))then m:=i;end;

Try it online!
(Yes I know, pascal sucks at this, in addition there is no sort function in it's library..)

Coconut, 56 bytes
This is just a Coconut-ification of the best (currently only) Python 3 answer (as well as some of the other answers), so most of the credit should go to them.
Any valid Python 3 is Coconut which means it's at most the same length. Also, Coconut compiles to Python.
lambda a:sorted(sorted(a),key=lambda x:-len(str(x)))[-1]
can be changed into ->sorted(sorted(_),key=->-len(str(_)))[-1]. This compiles to lambda _=None: sorted(sorted(_), key=lambda _=None: -len(str(_)))[-1] (along with a ton of other stuff like additional Coconut builtins).

JavaScript (Node.js), 53 bytes
a=>a.reduce((N,n)=>~(L=Math.log10)(N)!=~L(n)^N>n?N:n)

Attempt This Online!
Explanation
For any two values N,n, we need to decide which to return, this table describes that:
         length
        | < = >
     ---+-------
value < | N n .
      = | . ? .
      > | . N n

Where . will never happen and ? means either N or n works.
This looks a lot like an exclusive or (XOR) table:
      A
    | 0 1
 ---|-----
B 0 | 0 1
  1 | 1 0

Where we XOR length(N) != length(n) with N > n. The cheapest way (I think) to get the length of a number in JS is using Math.log10, then flooring the result with a bitwise operator (in this case ~).
I also [ab]use the fact that ^ has lower operator precedence than comparisons.

Thunno 2 hG, 3 bytes
Ṡñl

Attempt This Online!
Thunno 2, 5 bytes
ṠñlhG

Attempt This Online!
Explanation
ṠñlhG  # Implicit input
Ṡ      # Sort the input, so the minimum item is at the start
 ñ     # Group this sorted list by the following:
  l    #  Length (for integers this is number of digits)
   h   # Get the first group (the minimum digits)
    G  # And get the maximum item in this group
       # Implicit output

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