Dada una lista no vacía de enteros decimales positivos, genera el número más grande del conjunto de números con la menor cantidad de dígitos.

La lista de entrada no estará en ningún orden en particular y puede contener valores repetidos.

Ejemplos:

[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

El código más corto en bytes gana.

Pyth, 7 3 6 bytes

eS.ml`

Banco de pruebas

Explicación:

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

Solución de 7 bytes:

eSh.gl`

Banco de pruebas

Explicación:

   .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

Python 2, 48 42 bytes

-6 bytes gracias a @Dennis (usar en minlugar de sorted)

lambda l:min(l,key=lambda x:(len(`x`),-x))

Todos los casos de prueba están en ideone

Tome el mínimo de la lista por (longitud, -valor)

Jalea , 7 bytes

DL,NµÞḢ

Pruébelo en TryItOnline
O vea todos los casos de prueba también en TryItOnline

¿Cómo?

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

05AB1E , 5 bytes

Código:

({é¬(

Explicación:

(      # 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.

Utiliza la codificación CP-1252 . Pruébalo en línea!

Ruby, 34 bytes

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

Véalo en eval.in: https://eval.in/643153

MATL , 14 bytes

10&YlktX<=G*X>

Pruébalo en línea!

Explicación:

  &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`

Pruébalo en línea! o ejecutar todos los casos de prueba .

¡Guardado 8 bytes gracias a Martin!

La prueba completa está utilizando una versión un poco más antigua del código, pero el algoritmo es idéntico. Lo actualizaré para estar más cerca cuando tenga más tiempo.

La nueva línea final es significativa. Ordena los números por valor numérico inverso, luego los ordena por número de dígitos. Esto nos deja con el número más grande con la menor cantidad de dígitos en la primera posición, por lo que podemos eliminar los dígitos restantes.

Mathematica, 33 31 bytes

Max@MinimalBy[#,IntegerLength]&

MinimalBy selecciona todos los elementos de la lista de entrada original con la puntuación más pequeña según IntegerLength, es decir, con el número más pequeño de dígitos; y luego Max saca el más grande.

Gracias a Martin Ender por encontrar y luego guardar 2 bytes para mí :)

Perl 6 , 18 bytes

*.min:{.chars,-$_}

Explicación:

*\        # 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
}

Uso:

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

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

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

Jalea , 8 bytes

DL€İMị¹Ṁ

Pruébalo en línea! o Verificar todos los casos de prueba.

Explicación

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

JavaScript (ES6), 51

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

Prueba

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)
})  

J, 21 14 bytes

¡Ahorró 7 bytes gracias a las millas y (indirectamente) a Jonathan!

{.@/:#@":"0,.-

Esta es una cadena de cuatro:

{.@/: (#@":"0 ,. -)

Pasemos por la entrada 10 27 232 1000. La horquilla interna consta de tres dientes. #@":"0calcula los tamaños, ,.concatena cada tamaño con su -miembro negado ( ). Para la entrada 10 27 232 1000, nos queda esto:

   (#@":"0 ,. -) 10 27 232 1000
2   _10
2   _27
3  _232
4 _1000

Ahora, tenemos {.@/:como el diente externo. Esto es monádico primero ( {.) sobre dyadic sort ( /:). Es decir, tomaremos el primer elemento del resultado de dyadic /:. Esto ordena su argumento derecho de acuerdo con su argumento izquierdo, que nos da para nuestra entrada:

   (/: #@":"0 ,. -) 10 27 232 1000
27 10 232 1000

Luego, usar {.nos da el primer elemento de esa lista, y hemos terminado:

   ({.@/: #@":"0 ,. -) 10 27 232 1000
27

Versión antigua

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

Todavía estoy trabajando en mejoras. Jugué golf desde 30, y creo que esto es lo suficientemente bueno. Primero lo dividiré en partes básicas:

   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

Así es como funciona esto.

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

Este es un tren monádico, pero esta parte es un gancho. El verbo >./@(#~ ] = <./@])se llama con argumento izquierdo como entrada a la cadena principal y los tamaños, definidos como #@":"0, como argumento derecho. Esto se calcula como longitud ( #) sobre ( @) formato predeterminado (": ), es decir, cadena de caracteres numérica, que se aplica para aplicar a las celdas 0 (es decir, miembros) de la entrada ( "0).

Veamos la entrada de ejemplo 409 12 13.

   (#@":"0) 409 12 13
3 2 2

Ahora para el verbo interior, >./@(#~ ] = <./@]). Parece >./@(...)que significa efectivamente el valor máximo ( >./) de ( @) lo que hay dentro (...). En cuanto al interior, este es un tren de cuatro, equivalente a este tren de cinco:

[ #~ ] = <./@]

[se refiere al argumento original y se ]refiere a la matriz de tamaño; 409 12 13y 3 2 2respectivamente en este ejemplo. El diente derecho <./@], calcula el tamaño mínimo, 2en este caso. ] = <./@]es una matriz booleana de valores igual al mínimo, 0 1 1en este caso. Finalmente, [ #~ ...toma valores del argumento izquierdo de acuerdo con la máscara de argumento derecho. Esto significa que los elementos que corresponden 0se descartan y 1retienen. Entonces nos quedamos con 12 13. Finalmente, de acuerdo con lo anterior, se toma el máximo, dándonos el resultado correcto de 13, y hemos terminado.

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'))

cc, 54 bytes

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

Explicación:

?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

Ejecute el ejemplo: 'input.txt' contiene todos los casos de prueba en la declaración de la pregunta

while read list;do echo "$list -> "$(dc -f program.dc <<< $list);done < input.txt

Salida:

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

Java 7, 112104 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;}

Enfoque diferente para guardar varios bytes gracias a @ Barteks2x .

Sin golf y casos de prueba:

Pruébalo aquí

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 }));
  }
}

Salida:

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

bash, awk, ordenar 53 bytes

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

Leer la entrada de stdin, un valor por línea

set `sort -n`;while((${#2}==${#1}));do shift;done;echo $1

JavaScript ES6, 80 77 70 bytes

a=>Math.max(...a.filter(l=>l.length==Math.min(...a.map(i=>i.length))))

Espero ir en la dirección correcta ...

Brachylog , 16 bytes

or:@]feL:la#=,Lh

Pruébalo en línea!

Explicación

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>>=(,))

Javascript (ES6), 57 54 53 bytes

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

Para el registro, mi versión anterior estaba más orientada a las matemáticas pero 1 byte más grande:

l=>l.sort((a,b)=>(s=a=>1/a-~Math.log10(a))(a)-s(b))[0]

Casos de prueba

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

MATL , 11 bytes

tV48\&XS0))

La entrada es un vector de columna (que se usa ;como separador), como

[78; 99; 620; 100]

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

Usemos la entrada [78; 99; 620; 100]como ejemplo.

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

Perl, 38 37 bytes

Incluye +1 para -a

Dar entrada en 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]}

Utiliza memoria lineal en el número más grande, así que no intente esto en números demasiado grandes. Una solución sin ese defecto es de 38 bytes:

#!/usr/bin/perl -p
$.++until$\=(sort/\b\S{$.}\b/g)[-1]}{

Todos estos son muy incómodos y no se sienten óptimos en absoluto ...

R, 72 41 36 bytes

Reescribió la función con un nuevo enfoque. Golfé 5 bytes gracias a una sugerencia de @bouncyball.

n=nchar(i<-scan());max(i[n==min(n)])

Explicado:

        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}}

Sangrado / explicado:

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.
  }
}

Bash + coreutils, 58 bytes

d=`sort -n`;egrep ^.{`sed q<<<"$d"|wc -L`}$<<<"$d"|tail -1

El formato de entrada es un valor por línea. Sugerencias de golf son bienvenidas.

Explicación:

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)

Python 2 - 41 bytes

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

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]

Utiliza una lambda en una lambda!

Python 2, 53 bytes

s=lambda a:sorted(sorted(a),key=lambda x:-len(`x`))[-1]

Lo mismo pero con backticks

Pip , 11 bytes

(SNgSK-#_v)

Toma entrada como argumentos de línea de comando. Pruébalo en línea!

Primera vez que utiliza el Sort- Koperador de ojos! Al igual que Python sorted(), toma una función que se aplica a cada elemento del iterable y el resultado se usa como una clave de clasificación. Así es como funciona este programa:

 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)) 

como en:

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

Aunque estoy seguro de que hay una manera de hacerlo más pequeño.

PHP, 86 bytes

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