[Question]
  [
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.**
  
[Answer]
# Pyth, ~~7~~ ~~3~~ 6 bytes
```
eS.ml`
```
[Test Suite](http://pyth.herokuapp.com/?code=eS.ml%60&test_suite=1&test_suite_input=%5B1%5D%0A%5B9%5D%0A%5B1729%5D%0A%5B1%2C+1%5D%0A%5B34%2C+3%5D%0A%5B38%2C+39%5D%0A%5B409%2C+12%2C+13%5D%0A%5B11%2C+11%2C+11%2C+1%5D%0A%5B11%2C+11%2C+11%2C+11%5D%0A%5B78%2C+99%2C+620%2C+1%5D%0A%5B78%2C+99%2C+620%2C+10%5D%0A%5B78%2C+99%2C+620%2C+100%5D%0A%5B1%2C+5%2C+9%2C+12%2C+63%2C+102%5D%0A%5B3451%2C+29820%2C+2983%2C+1223%2C+1337%5D%0A%5B738%2C+2383%2C+281%2C+938%2C+212%2C+1010%5D&debug=0)
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](http://pyth.herokuapp.com/?code=eSh.gl%60&test_suite=1&test_suite_input=%5B1%5D%0A%5B9%5D%0A%5B1729%5D%0A%5B1%2C+1%5D%0A%5B34%2C+3%5D%0A%5B38%2C+39%5D%0A%5B409%2C+12%2C+13%5D%0A%5B11%2C+11%2C+11%2C+1%5D%0A%5B11%2C+11%2C+11%2C+11%5D%0A%5B78%2C+99%2C+620%2C+1%5D%0A%5B78%2C+99%2C+620%2C+10%5D%0A%5B78%2C+99%2C+620%2C+100%5D%0A%5B1%2C+5%2C+9%2C+12%2C+63%2C+102%5D%0A%5B3451%2C+29820%2C+2983%2C+1223%2C+1337%5D%0A%5B738%2C+2383%2C+281%2C+938%2C+212%2C+1010%5D&debug=0)
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
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
DL,NµÞḢ
```
Test it at **[TryItOnline](http://jelly.tryitonline.net/#code=REwsTsK1w57huKI&input=&args=WzczOCwgMjM4MywgMjgxLCA5MzgsIDIxMiwgMTAxMF0)**  
Or see all test cases also at **[TryItOnline](http://jelly.tryitonline.net/#code=REwsTsK1w57huKIKxbzDh-KCrOG5hOKCrMK1&input=&args=W1sxXSwgWzldLCBbMTcyOV0sIFsxLCAxXSwgWzM0LCAzXSwgWzM4LCAzOV0sIFs0MDksIDEyLCAxM10sIFsxMSwgMTEsIDExLCAxXSwgWzExLCAxMSwgMTEsIDExXSwgWzc4LCA5OSwgNjIwLCAxXSwgWzc4LCA5OSwgNjIwLCAxMF0sIFs3OCwgOTksIDYyMCwgMTAwXSwgWzEsIDUsIDksIDEyLCA2MywgMTAyXSwgWzM0NTEsIDI5ODIwLCAyOTgzLCAxMjIzLCAxMzM3XSwgWzczOCwgMjM4MywgMjgxLCA5MzgsIDIxMiwgMTAxMF1d)**
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
```
[Answer]
# [05AB1E](http://github.com/Adriandmen/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!](http://05ab1e.tryitonline.net/#code=KHvDqcKsKA&input=WzM0NTEsIDI5ODIwLCAyOTgzLCAxMjIzLCAxMzM3XQ)
[Answer]
# 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](http://ideone.com/IbYFyJ)**
Take the minimum of the list by (length, -value)
[Answer]
# Ruby, 34 bytes
```
->a{a.max_by{|n|[-n.to_s.size,n]}}
```
See it on eval.in: <https://eval.in/643153>
[Answer]
# [MATL](http://github.com/lmendo/MATL), 14 bytes
```
10&YlktX<=G*X>
```
[Try it online!](http://matl.tryitonline.net/#code=MTAmWWxrdFg8PUcqWD4&input=Wzc4LCA5OSwgNjIwLCAxMDBd)
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
```
[Answer]
# [Retina](http://github.com/mbuettner/retina), ~~24~~ 16 bytes
```
O^`
O$#`
$.0
G1`
```
[Try it online!](http://retina.tryitonline.net/#code=T15gCk8kI2AKJC4wCkcxYA&input=MQoxMgo5CjYzCjUKMTAy) or [run all test cases](http://retina.tryitonline.net/#code=JShHYApPXmBcZCsKTyQjYFxkKwokLjAKIC4rCg&input=MQo5CjE3MjkKMSAxCjM0IDMKMzggMzkKNDA5IDEyIDEzCjExIDExIDExIDEKMTEgMTEgMTEgMTEKNzggOTkgNjIwIDEKNzggOTkgNjIwIDEwCjc4IDk5IDYyMCAxMDAKMSA1IDkgMTIgNjMgMTAyCjM0NTEgMjk4MjAgMjk4MyAxMjIzIDEzMzcKNzM4IDIzODMgMjgxIDkzOCAyMTIgMTAxMA).
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.
[Answer]
# 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 :)*
[Answer]
# [Perl 6](https://perl6.org), 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
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~16~~ ~~15~~ 14 bytes
```
|/{=/&/\#'$x}#
```
[Try it online!](https://ngn.codeberg.page/k/#eJxlUNtqwzAMffdXCFp2AY9EVtpYNduPZIHupTA2GJQ9tHTdt+9IbtZ2g/hyLlaks1l9NYfH5qZ5nt3Od8dZCJ+rw3zYf29XGyLalfXHW7lbb15e38uu7Mv2fjzCM0QuPNqpRf3kPmmxzRDTSZaOpIjfMokWcblrlTgRS2HXGP761VdnDMKZPpMqLVM7WS6Itqj+pSaOaUGJ/G9LAZ9qt9ItmJJmeLFDSAmbSF9M8WLoNwmklJnUgDXc2s8kjyE0YeCRHp6Iw6B+UTA2vpO4AEb69UgXSRwIQAaoToEPccCZsKqDYWF7PK2pyBV5YkH3KKcogdEvzNdsW3vUf/xZQNEFpNrKUkxM02QWS6yJ+WEqMoseWh0EjmCxRc8tWnDRkosWXfTsajXJP9wzhD8=)
* `{...}#` set up a filter, returning elements from the (implicit) right argument where the code in `{...}` returns `1`s
	+ `#'$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
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 8 bytes
```
DL€İMị¹Ṁ
```
[Try it online!](http://jelly.tryitonline.net/#code=REzigqzEsE3hu4vCueG5gA&input=&args=WzM0NTEsIDI5ODIwLCAyOTgzLCAxMjIzLCAxMzM3XQ) or [Verify all test cases.](http://jelly.tryitonline.net/#code=REzigqzEsE3hu4vCueG5gArDh-KCrA&input=&args=W1sxXSwKIFs5XSwKIFsxNzI5XSwKIFsxLCAxXSwKIFszNCwgM10sCiBbMzgsIDM5XSwKIFs0MDksIDEyLCAxM10sCiBbMTEsIDExLCAxMSwgMV0sCiBbMTEsIDExLCAxMSwgMTFdLAogWzc4LCA5OSwgNjIwLCAxXSwKIFs3OCwgOTksIDYyMCwgMTBdLAogWzc4LCA5OSwgNjIwLCAxMDBdLAogWzEsIDUsIDksIDEyLCA2MywgMTAyXSwKIFszNDUxLCAyOTgyMCwgMjk4MywgMTIyMywgMTMzN10sCiBbNzM4LCAyMzgzLCAyODEsIDkzOCwgMjEyLCAxMDEwXV0)
## 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
```
[Answer]
# 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)
})  
```
[Answer]
# 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.
[Answer]
# Julia, 39
```
f(l)=sort(l,by=x->(length("$x"),-x))[1]
```
[ATO](https://ato.pxeger.com/run?1=jZBNTsMwEIXFsjlFZCGRSAlK7P7EEolgyYITVCyM6kCQ5Va2C0UqJ2HTTQ9VTsNz3AAVG6Q4mXnvm6dxPvbPa9WJ3eHGiFdCSJuotLZL4xKVPbzVm7xJlNSP7ikh5xuSZvkmTeflPchtE4xtszKddkrv167Nq8PFPyOO-Hu7NLHqdIzHSLFAKW1i3aLTaTQSxmRG2tquVIe8Tmckb0gw6jvpxOVKGCsTtOm2kS9CRSPPB_VWOz8N_FpYK7FR25N13atSL8ISu8-zK2wU501cRnPeFzyalzMaal-gzeJvho2zmPUNQ1OhCSQDNy44SIoTiBJI6YeHM4SciEcV8gxxHBFTWvyCT9Ui7Mj_6D8GQiewwipT5k063IyNJ7Apr_wQPt6l1L8Zm4WLgEC4vxpl3qcVJnjf93crhh1YFYW_-AU)able
[Answer]
# 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'))
```
[Answer]
## 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
```
[Answer]
## 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
```
[Answer]
# 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.](https://ideone.com/Zo6o2f)
```
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
```
[Answer]
# 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
```
[Answer]
# 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...
[Answer]
# [Brachylog](http://github.com/JCumin/Brachylog), 16 bytes
```
or:@]feL:la#=,Lh
```
[Try it online!](http://brachylog.tryitonline.net/#code=b3I6QF1mZUw6bGEjPSxMaA&input=WzM0NTE6Mjk4MjA6Mjk4MzoxMjIzOjEzMzdd&args=Wg)
### 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.
```
[Answer]
# Haskell, 39 bytes
```
snd.maximum.map((0-).length.show>>=(,))
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), 11 bytes
```
tV48\&XS0))
```
Input is a column vector (using `;` as separator), such as
```
[78; 99; 620; 100]
```
[Try it online!](http://matl.tryitonline.net/#code=dFY0OFwmWFMwKSk&input=WzczODsgMjM4MzsgMjgxOyA5Mzg7IDIxMjsgMTAxMF0) Or [verify all test cases](http://matl.tryitonline.net/#code=YAp0VjQ4XCZYUzApKQpEVA&input=WzFdCls5XQpbMTcyOV0KWzE7IDFdClszNDsgM10KWzM4OyAzOV0KWzQwOTsgMTI7IDEzXQpbMTE7IDExOyAxMTsgMV0KWzExOyAxMTsgMTE7IDExXQpbNzg7IDk5OyA2MjA7IDFdCls3ODsgOTk7IDYyMDsgMTBdCls3ODsgOTk7IDYyMDsgMTAwXQpbMTsgNTsgOTsgMTI7IDYzOyAxMDJdClszNDUxOyAyOTgyMDsgMjk4MzsgMTIyMzsgMTMzN10KWzczODsgMjM4MzsgMjgxOyA5Mzg7IDIxMjsgMTAxMF0).
### 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
```
[Answer]
# 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...
[Answer]
## PowerShell v2+, 41 bytes
```
($args[0]|sort -des|sort{"$_".length})[0]
```
Takes input `$args`, `sort`s it by value in `-des`cending order (so bigger numbers are first), then `sort`s 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
```
[Answer]
# 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.
  }
}
```
[Answer]
## 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)
```
[Answer]
# **Python 2 - 41 bytes**
```
lambda l:max((-len(`x`),x) for x in l)[1]
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 36 bytes
-4 thanks to @rak1507.
```
f←⌈/⊢×((⌊/=⊢)≢∘⍕¨)
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHPR36j7oWHZ6uofGop0vfFsjWfNS56FHHjEe9Uw@t0Pz/qG8qUFmagrmxhY6CkbGFMZC0MNRRsATzDY10FAwNDA24YMqAMqZASaAoUMbMGCRr9B8A "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
DL$ÐṂṀ
```
[Try it online!](https://tio.run/##ZU8rDsJAEPU9xQpkSboz/a1BERSahDSVGNIL4JoaEhQXwIBFItoge5LtRZa3XRZoELM77zMvM/tdVR2MWa5n/Vl3je5qo9uT7m5DfSl1e92s@mOgn4/@ODT3rTGFLMV8IWRQqLFRQSEzcr1tAEPx8XAcCh4BA@QAzsnwxZGCk1DOIWGRdtiXD5mQbxZ0hjiFiJSiH/OUjdyO6o//CghNILlVUrYi@cs4TiCTyu0QPqsS2Zc5c4fAgXB7GrHVKceEGvF4W@R34PwF "Jelly – 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
```
]