Biorąc pod uwagę niepustą listę dodatnich liczb całkowitych dziesiętnych, wypisz największą liczbę z zestawu liczb o najmniejszej liczbie cyfr.

Lista wejściowa nie będzie w żadnej określonej kolejności i może zawierać powtarzające się wartości.

Przykłady:

[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

Najkrótszy kod w bajtach wygrywa.

Pyth, 7 3 6 bajtów

eS.ml`

Pakiet testowy

Wyjaśnienie:

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

7 bajtowe rozwiązanie:

eSh.gl`

Pakiet testowy

Wyjaśnienie:

   .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 bajtów

-6 bajtów dzięki @Dennis ( minzamiast używać sorted)

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

Wszystkie przypadki testowe są w ideone

Weź minimum listy według (długość, -wartość)

Galaretka , 7 bajtów

DL,NµÞḢ

Przetestuj w TryItOnline
Lub zobacz wszystkie przypadki testowe również w TryItOnline

W jaki sposób?

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 bajtów

Kod:

({é¬(

Wyjaśnienie:

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Rubinowy, 34 bajty

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

Zobacz na eval.in: https://eval.in/643153

MATL , 14 bajtów

10&YlktX<=G*X>

Wypróbuj online!

Wyjaśnienie:

  &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

Siatkówka ,24 16 bajtów

O ^ `
O $ #
0,0 $
G1`

Wypróbuj online! lub uruchom wszystkie przypadki testowe .

Zaoszczędź 8 bajtów dzięki Martinowi!

Cały test wykorzystuje nieco starszą wersję kodu, ale algorytm jest identyczny. Zaktualizuję go, aby był bliżej, gdy będę miał więcej czasu.

Końcowy znak nowej linii jest znaczący. Sortuje liczby według odwrotnej wartości liczbowej, a następnie sortuje je według liczby cyfr. Pozostaje nam największy numer z najmniejszą liczbą cyfr na pierwszej pozycji, więc możemy po prostu usunąć pozostałe cyfry.

Mathematica, 33 31 bajtów

Max@MinimalBy[#,IntegerLength]&

MinimalBy wybiera wszystkie elementy oryginalnej listy wprowadzania z najmniejszym wynikiem według IntegerLength, tj. Z najmniejszą liczbą cyfr; a następnie Max generuje największy.

Dzięki Martinowi Enderowi za znalezienie, a następnie zapisanie 2 bajtów dla mnie :)

Perl 6 , 18 bajtów

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

Wyjaśnienie:

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

Stosowanie:

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

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

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

Galaretka , 8 bajtów

DL€İMị¹Ṁ

Wypróbuj online! lub Zweryfikuj wszystkie przypadki testowe.

Wyjaśnienie

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 bajtów

Zaoszczędzono 7 bajtów dzięki kilometrom i (pośrednio) Jonathanowi!

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

Jest to cztero łańcuchowy:

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

Przejdźmy przez dane wejściowe 10 27 232 1000. Widelec wewnętrzny składa się z trzech zębów. #@":"0oblicza rozmiary, ,.konkatuje każdy rozmiar z jego negowanym ( -) elementem . W przypadku danych wejściowych 10 27 232 1000pozostaje nam to:

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

Teraz mamy {.@/:zewnętrzny ząb. Jest to monadyczne pierwsze ( {.) przed sortowaniem dyadycznym ( /:). Oznacza to, że weźmiemy pierwszy element wyniku dyadic /:. To sortuje swój prawy argument zgodnie z lewym argumentem, co daje nam nasze dane wejściowe:

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

Następnie użycie {.daje nam pierwszy element tej listy i gotowe:

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

Stara wersja

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

Nadal pracuję nad ulepszeniami. Grałem w golfa z 30 i myślę, że to wystarczy. Najpierw podzielę to na podstawowe części:

   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

Oto jak to działa.

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

To monadyczny pociąg, ale ta część to hak. Czasownik >./@(#~ ] = <./@])jest wywoływany z lewym argumentem jako wejściem do głównego łańcucha, a rozmiary zdefiniowane jako #@":"0jako prawy argument. Jest to obliczane jako domyślny format length ( #) ponad ( @) ":, to znaczy łańcuchowe numerowanie, które stosuje się do komórek 0 (tj. Elementów) wejścia ( "0).

Przejrzyjmy przykładowe dane wejściowe 409 12 13.

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

Teraz na wewnętrznej czasownika >./@(#~ ] = <./@]). Wygląda na to >./@(...), co faktycznie oznacza maksymalną wartość ( >./) z ( @) tego, co jest w środku (...). Jeśli chodzi o wnętrze, jest to cztero-pociąg, odpowiednik tego pięcio-pociągu:

[ #~ ] = <./@]

[odnosi się do oryginalnego argumentu i ]odnosi się do tablicy rozmiarów; 409 12 13i 3 2 2odpowiednio w tym przykładzie. Właściwy <./@]ząb, 2w tym przypadku , oblicza minimalny rozmiar . ] = <./@]jest boolowską tablicą wartości równą minimum, 0 1 1w tym przypadku. Na koniec [ #~ ...pobiera wartości z lewego argumentu zgodnie z maską z prawym argumentem. Oznacza to, że odpowiednie elementy 0są upuszczane i 1zachowywane. Więc zostajemy z 12 13. Wreszcie, zgodnie z powyższym, maksimum jest brane, dając nam prawidłowy wynik 13i gotowe.

JavaScript (ES6), 62 bajty

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

dc, 54 bajty

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

Wyjaśnienie:

?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

Uruchom przykład: „input.txt” zawiera wszystkie przypadki testowe w instrukcji pytania

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

Wydajność:

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 bajtów

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

Różne podejście do zapisywania wielu bajtów dzięki @ Barteks2x .

Przypadki bez golfa i testy:

Wypróbuj tutaj.

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

Wydajność:

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

bash, awk, sortuj 53 bajty

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

Czytaj dane wejściowe ze standardowego wejścia, jedna wartość na linię

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

JavaScript ES6, 80 77 70 bajtów

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

Mam nadzieję, że idę w dobrym kierunku ...

Brachylog , 16 bajtów

or:@]feL:la#=,Lh

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

JavaScript (ES6), 57 54 53 bajtów

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

Dla przypomnienia, moja poprzednia wersja była bardziej zorientowana na matematykę, ale 1 bajt większy:

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

Przypadki testowe

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 bajtów

tV48\&XS0))

Dane wejściowe to wektor kolumny (wykorzystujący ;jako separator), taki jak

[78; 99; 620; 100]

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie

[78; 99; 620; 100]Jako przykład weźmy dane wejściowe .

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 bajtów

Obejmuje +1 dla -a

Podaj dane na 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]}

Używa pamięci liniowo w największej liczbie, więc nie próbuj tego na zbyt dużych liczbach. Rozwiązanie bez tej wady ma 38 bajtów:

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

Wszystko to jest bardzo niezręczne i wcale nie wydaje się optymalne ...

R, 72 41 36 bajtów

Przepisz funkcję z nowym podejściem. Grał w golfa 5 bajtów dzięki sugestii @bouncyball.

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

Wyjaśnił:

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

Wcięte / wyjaśnione:

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 bajtów

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

Format wejściowy to jedna wartość na linię. Sugestie dotyczące gry w golfa są mile widziane.

Wyjaśnienie:

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 bajtów

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

Python 2, 58 bajtów

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

Python 3, 56 bajtów

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

Używa lambda w lambda!

Python 2, 53 bajty

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

To samo, ale z backticksami

Pip , 11 bajtów

(SNgSK-#_v)

Pobiera dane wejściowe jako argumenty wiersza polecenia. Wypróbuj online!

Pierwszy raz skorzystaj z Sortodontycznego Koperatora! Podobnie jak Python sorted(), wymaga funkcji, która jest stosowana do każdego elementu iterowalnego, a wynik jest używany jako klucz sortowania. Oto jak działa ten program:

 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 bajty

(reduce #(if(=(quot %1 10)(quot %2 10))(max %1 %2) %1)(sort x)) 

jak w:

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

Chociaż jestem pewien, że istnieje sposób, aby go zmniejszyć.

PHP, 86 bajtów

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