Bei einer nicht leeren Liste positiver Dezimalzahlen geben Sie die größte Zahl aus der Zahlenmenge mit den wenigsten Stellen aus.

Die Eingabeliste ist nicht in einer bestimmten Reihenfolge und kann wiederholte Werte enthalten.

Beispiele:

[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

Der kürzeste Code in Bytes gewinnt.

Pyth, 7 3 6 Bytes

eS.ml`

Test Suite

Erläuterung:

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

7 Byte Lösung:

eSh.gl`

Test Suite

Erläuterung:

   .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 dank @Dennis ( mineher verwenden als sorted)

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

Alle Testfälle sind auf ideone

Nimm das Minimum der Liste durch (Länge, Wert)

Gelee , 7 Bytes

DL,NµÞḢ

Testen Sie es bei TryItOnline
Oder sehen Sie sich alle Testfälle auch bei TryItOnline an

Wie?

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

Code:

({é¬(

Erläuterung:

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Ruby, 34 Bytes

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

Sehen Sie es auf eval.in: https://eval.in/643153

MATL , 14 Bytes

10&YlktX<=G*X>

Probieren Sie es online!

Erläuterung:

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

Probieren Sie es online! oder führen Sie alle Testfälle aus .

8 Bytes gespart dank Martin!

Der All-Test verwendet eine etwas ältere Version des Codes, der Algorithmus ist jedoch identisch. Ich werde es aktualisieren, um näher zu sein, wenn ich mehr Zeit habe.

Der abschließende Zeilenumbruch ist erheblich. Sortiert die Zahlen nach dem umgekehrten numerischen Wert und sortiert sie dann nach der Anzahl der Ziffern. Dies lässt uns die größte Nummer mit den wenigsten Stellen an der ersten Stelle, so dass wir nur die verbleibenden Stellen löschen können.

Mathematica, 33 31 Bytes

Max@MinimalBy[#,IntegerLength]&

MinimalBy wählt alle Elemente der ursprünglichen Eingabeliste mit der geringsten Punktzahl aus IntegerLength, dh mit der geringsten Anzahl von Ziffern. und dann gibt Max den größten aus.

Vielen Dank an Martin Ender für das Finden und Speichern von 2 Bytes für mich :)

Perl 6 , 18 Bytes

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

Erläuterung:

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

Verwendung:

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

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

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

Gelee , 8 Bytes

DL€İMị¹Ṁ

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Erläuterung

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]

Prüfung

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

Dank Meilen und (indirekt) Jonathan 7 Bytes gespart!

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

Dies ist eine Viererkette:

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

Lassen Sie uns über die Eingabe gehen 10 27 232 1000. Die innere Gabel besteht aus drei Zinken. #@":"0berechnet die Größen, ,.fasst jede Größe mit ihrem negierten ( -) Element zusammen . Bei der Eingabe 10 27 232 1000bleibt uns Folgendes übrig:

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

Nun haben wir {.@/:als äußere Zinke. Dies ist zuerst monadisch ( {.) über dyadisch ( /:). Das heißt, wir nehmen das erste Element des Ergebnisses von dyadic /:. Dies sortiert sein rechtes Argument nach seinem linken Argument, was uns zu unserer Eingabe verhilft:

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

Dann {.gibt uns using das erste Element dieser Liste und wir sind fertig:

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

Alte Version

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

Wir arbeiten immer noch an Verbesserungen. Ich habe es von 30 golfen und ich denke, das ist gut genug. Ich werde es zuerst in grundlegende Teile zerlegen:

   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

So funktioniert das

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

Dies ist ein monadischer Zug, aber dieser Teil ist ein Haken. Das Verb >./@(#~ ] = <./@])wird mit dem linken Argument als Eingabe für die Hauptkette und den Größen #@":"0als dem rechten Argument aufgerufen . Dies wird berechnet als length ( #) over ( @) Standardformat (": ) , d. H. Als numerische Zeichenfolge, die für die 0-Zellen (dh Mitglieder) der Eingabe ( "0) angewendet wird .

Lassen Sie uns über die Beispieleingabe gehen 409 12 13.

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

Nun zum inneren Verb >./@(#~ ] = <./@]). Es sieht so aus >./@(...), als ob dies effektiv den Maximalwert ( >./) von ( @) bedeutet, was darin enthalten ist (...). Was das Innere betrifft, ist dies ein Vierzug, der diesem Fünfzug entspricht:

[ #~ ] = <./@]

[verweist auf das ursprüngliche Argument und ]auf das Größenarray; 409 12 13und 3 2 2jeweils in diesem Beispiel. Der rechte Strich <./@]berechnet 2in diesem Fall die Mindestgröße . ] = <./@]ist 0 1 1in diesem Fall ein boolesches Array von Werten, die dem Minimum entsprechen . Übernimmt schließlich [ #~ ...Werte aus dem linken Argument gemäß der Maske mit den rechten Argumenten. Dies bedeutet, dass die entsprechenden Elemente 0gelöscht und 1beibehalten werden. Also bleiben wir mit 12 13. Schließlich wird gemäß dem oben Gesagten das Maximum genommen, was uns das korrekte Ergebnis von gibt 13, und wir sind fertig.

JavaScript (ES6), 62 Byte

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

Gleichstrom, 54 Bytes

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

Erläuterung:

?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

Beispiel ausführen : 'input.txt' enthält alle Testfälle in der Anweisung der Frage

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

Ausgabe:

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

Anderer Ansatz zum Speichern mehrerer Bytes dank @ Barteks2x .

Ungolfed & Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

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

Bash, awk, sortiere 53 Bytes

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

Liest die Eingabe von stdin, ein Wert pro Zeile

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

Ich hoffe ich gehe in die richtige Richtung ...

Brachylog , 16 Bytes

or:@]feL:la#=,Lh

Probieren Sie es online!

Erläuterung

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]

Meine vorherige Version war mathematisch orientierter, aber 1 Byte größer:

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

Testfälle

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

Die Eingabe ist ein Spaltenvektor (der ;als Trennzeichen verwendet wird), z

[78; 99; 620; 100]

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

Erläuterung

Verwenden wir [78; 99; 620; 100]als Beispiel die Eingabe .

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

Beinhaltet +1 für -a

Geben Sie Input auf 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]}

Verwendet linearen Speicher in der größten Anzahl. Versuchen Sie es also nicht mit zu großen Zahlen. Eine Lösung ohne diesen Fehler ist 38 Bytes:

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

All dies ist sehr umständlich und fühlt sich überhaupt nicht optimal an ...

R 72 41 36 Bytes

Die Funktion wurde mit einem neuen Ansatz umgeschrieben. Golf 5 Bytes dank eines Vorschlags von @bouncyball.

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

Erklärt:

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

Eingerückt / erklärt:

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

Das Eingabeformat ist ein Wert pro Zeile. Golfvorschläge sind willkommen.

Erläuterung:

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]

Verwendet einen Lambda in einem Lambda!

Python 2, 53 Bytes

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

Gleich, aber mit Backticks

Pip , 11 Bytes

(SNgSK-#_v)

Übernimmt Eingaben als Befehlszeilenargumente. Probieren Sie es online!

Zum ersten Mal mit dem S Augenoperator K! Wie bei Python sorted()wird eine Funktion verwendet, die auf jedes Element der Iteration angewendet und das Ergebnis als Sortierschlüssel verwendet wird. So funktioniert dieses Programm:

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

wie in:

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

Obwohl ich mir sicher bin, dass es einen Weg gibt, es kleiner zu machen.

PHP, 86 Bytes

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