Враховуючи непорожній список позитивних десяткових цілих чисел, виведіть найбільше число з набору чисел з найменшими цифрами.

Список вводу не буде в певному порядку і може містити повторні значення.

Приклади:

[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

Виграє найкоротший код у байтах.

Pyth, 7 3 6 байт

eS.ml`

Тестовий сюїт

Пояснення:

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

7-байтний розчин:

eSh.gl`

Тестовий сюїт

Пояснення:

   .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 байт

-6 байт завдяки @Dennis (використання, minа не sorted)

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

Усі тестові справи знаходяться на ideone

Візьміть мінімум списку за (довжина, -значення)

Желе , 7 байт

DL,NµÞḢ

Перевірте його в TryItOnline
Або подивіться всі тестові приклади також на TryItOnline

Як?

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 байт

Код:

({é¬(

Пояснення:

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

Використовує кодування CP-1252 . Спробуйте в Інтернеті!

Рубін, 34 байти

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

Дивіться це на eval.in: https://eval.in/643153

MATL , 14 байт

10&YlktX<=G*X>

Спробуйте в Інтернеті!

Пояснення:

  &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

Сітківка ,24 16 байт

О ^ `
O $ # `
$ .0
G1`

Спробуйте в Інтернеті! або запустити всі тестові приклади .

Збережено 8 байт завдяки Мартіну!

У всіх тестах використовується трохи старша версія коду, але алгоритм ідентичний. Я оновлю його, щоб було ближче, коли отримаю більше часу.

Новий рядок є важливим. Сортуйте числа за зворотним числовим значенням, потім сортуйте їх за кількістю цифр. Це залишає нам найбільшу кількість з найменшою кількістю цифр на першій позиції, тому ми можемо просто видалити інші цифри.

Mathematica, 33 31 байт

Max@MinimalBy[#,IntegerLength]&

MinimalBy вибирає всі елементи вихідного списку вхідних даних з найменшим балом відповідно IntegerLength, тобто з найменшою кількістю цифр; а потім Макс виводить найбільший.

Дякую Мартіну Ендеру, що знайшов, а потім заощадив, 2 байти для мене :)

Perl 6 , 18 байт

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

Пояснення:

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

Використання:

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

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

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

Желе , 8 байт

DL€İMị¹Ṁ

Спробуйте в Інтернеті! або Перевірте всі тестові випадки.

Пояснення

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]

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

J, 21 14 bytes

Saved 7 bytes thanks to miles and (indirectly) Jonathan!

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

This is a four-chain:

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

Давайте пройдемося над входом 10 27 232 1000. Внутрішня вилка складається з трьох зубців. #@":"0обчислює розміри, ,.стискає кожен розмір з його запереченим ( -) членом. Для введення 10 27 232 1000нам залишається це:

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

Тепер ми маємо {.@/:як зовнішній зубчик. Це монадичний перший ( {.) над діадичним сортом ( /:). Тобто ми візьмемо перший елемент результату діадику /:. Це сортує його правий аргумент відповідно до лівого аргументу, який дає нам наш внесок:

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

Потім, використовуючи {.дає нам перший елемент цього списку, і ми закінчили:

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

Стара версія

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

Ще працюю над вдосконаленнями. Я гольфував його з 30, і думаю, що це досить добре. Я спершу розбию його на основні частини:

   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

Ось як це працює.

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

Це монастирський потяг, але ця частина - гачок. Дієслово >./@(#~ ] = <./@])називається лівим аргументом як входом до основного ланцюга та розмірами, визначеними як #@":"0правий аргумент. Це обчислюється як формат за замовчуванням ( #) над ( @) за замовчуванням ( ":), тобто числова строфікація, яка робиться для застосування до 0-комірок (тобто членів) вводу ( "0).

Давайте пройдемося по прикладу введення 409 12 13.

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

Тепер для внутрішнього дієслова >./@(#~ ] = <./@]). Це схоже >./@(...), що фактично означає максимальне значення ( >./) того, @що знаходиться всередині (...). Щодо внутрішньої сторони, це чотирипоїзд, еквівалентний цьому п’ятипотягу:

[ #~ ] = <./@]

[посилається на вихідний аргумент і ]відноситься до масиву розмірів; 409 12 13і 3 2 2відповідно в цьому прикладі. Правий зубчик, <./@]обчислює мінімальний розмір, 2в цьому випадку. ] = <./@]- булевий масив значень, рівний мінімуму, 0 1 1в цьому випадку. Нарешті, [ #~ ...приймає значення з лівого аргументу відповідно до маски правого аргументу. Це означає, що елементи, які відповідають 0, скидаються та 1зберігаються. Отже, ми залишилися 12 13. Нарешті, відповідно до вищесказаного, макс приймається, даючи нам правильний результат 13, і ми закінчили.

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

постійного струму, 54 байти

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

Пояснення:

?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

Приклад запуску: 'input.txt' містить усі тестові випадки у виписці запитання

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

Вихід:

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, 112 104 байт

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 .

Невикористані та тестові справи:

Спробуйте тут.

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

Вихід:

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

bash, awk, sort 53 bytes

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

Read input from stdin, one value per line

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

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

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

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

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

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

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

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)

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]

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;