सबसे कम अंकों के साथ सबसे बड़ी संख्या का उत्पादन

37

सकारात्मक दशमलव पूर्णांक की एक गैर-रिक्त सूची को देखते हुए, सबसे कम अंकों के साथ संख्याओं के सेट से सबसे बड़ी संख्या का उत्पादन।

इनपुट सूची किसी विशेष क्रम में नहीं होगी और इसमें बार-बार मूल्य शामिल हो सकते हैं।

उदाहरण:

[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

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  number  arithmetic 
— केल्विन के शौक
स्रोत
क्या इनपुट नंबर अलग-अलग लाइनों पर हो सकते हैं?
— शीशमारा
@ शीशमौरा उचित लगता है, हाँ।
— केल्विन के शौक

जवाबों:

13

पायथ, 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
— स्टीवन एच।
स्रोत
6

पायथन 2, 48 42 बाइट्स

-6 बाइट्स @ @ डेनिस के लिए धन्यवाद ( minइसके बजाय उपयोग करें sorted)

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

सभी परीक्षण के मामले विचारधारा पर हैं

सूची के अनुसार न्यूनतम लें (लंबाई -value)

— जोनाथन एलन
स्रोत
1
minके बजाय काम करना चाहिए sorted।
— डेनिस
@ डेनिस, ओह जीज़ - धन्यवाद! शायद इतना अलग है कि खुद को पोस्ट किया है।
— जोनाथन एलन
अदला-बदली sorted()[0]के लिए min? मैं समझता हूं कि आपके मूल कोड का एक मामूली संशोधन।
— डेनिस
वहाँ भी len(`x`)+1./xएक ही लंबाई के लिए है। बहुत बुरा आप की जरूरत है 1.।
— xnor
ठीक है, कि मैं क्या साथ आया था की तुलना में छोटा है। बहुत बढ़िया!
— mbomb007
6

जेली , 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
— जोनाथन एलन
स्रोत
1
सॉर्ट का महान उपयोग!
— मील
@ मील्स आपका तरीका अभी भी प्रेरित था :)
— जोनाथन एलन
5

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत
4

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
— DJMcMayhem
स्रोत
4

रेटिना ,24 16 बाइट्स

हे ^ `
हे $ # `
$ .0
G1`

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को चलाएं ।

मार्टिन को धन्यवाद दिया 8 बाइट्स बचाए!

सभी परीक्षण कोड के थोड़े पुराने संस्करण का उपयोग कर रहे हैं, लेकिन एल्गोरिथ्म समान है। अधिक समय मिलने पर मैं इसे अपडेट करूंगा।

अनुगामी न्यूलाइन महत्वपूर्ण है। संख्याओं को रिवर्स न्यूमेरिकल वैल्यू द्वारा सॉर्ट करता है, फिर उन्हें अंकों की संख्या से सॉर्ट करता है। यह हमें सबसे बड़ी संख्या के साथ पहले स्थान पर सबसे कम अंकों के साथ छोड़ता है, इसलिए हम केवल शेष अंकों को हटा सकते हैं।

— FryAmTheEggman
स्रोत
यदि आप इनपुट लाइन-अलग करते हैं, तो आप दोनों छँटाई चरणों में से रेगेक्स को छोड़ सकते हैं और फिर G1`अंतिम चरण के लिए उपयोग कर सकते हैं ।
— मार्टिन एंडर
इसके अलावा, पहले चरण की जरूरत नहीं है #। आप केवल किसी दिए गए पूर्णांक लंबाई के लिए सापेक्ष क्रम की परवाह करते हैं, और एक लंबाई के भीतर संख्याओं की लेक्सोग्राफ़िक छँटाई सही है।
— मार्टिन एंडर
@MartinEnder धन्यवाद! मैंने आपके दोनों सुझाव जोड़ दिए हैं। मुझे \w+छँटाई के लिए डिफ़ॉल्ट के रूप में सुझाव देना चाहिए था , इस तरह मुझे परीक्षण सूट बनाने के लिए ज्यादा संघर्ष करने की आवश्यकता नहीं होगी;)
— FryAmTheEggman
यहाँ एक और 16 है, अगर यह आपको आगे के गोल्फिंग के लिए कोई विचार देता है: retina.tryitonline.net/…
— मार्टिन
4

गणितज्ञ, ३३ ३१ बाइट्स

Max@MinimalBy[#,IntegerLength]&

MinimalBy मूल इनपुट सूची के सभी तत्वों IntegerLengthको सबसे छोटे अंकों के साथ सबसे छोटे अंकों के साथ चुनता है ; और फिर मैक्स सबसे बड़ा आउटपुट देता है।

मार्टिन एंडर को खोजने के लिए धन्यवाद, और फिर बचत, मेरे लिए 2 बाइट्स :)

— ग्रेग मार्टिन
स्रोत
4

पर्ल 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
— ब्रैड गिल्बर्ट b2gills
स्रोत
3

जेली , 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
— मील की दूरी पर
स्रोत
यह 8 बाइट्स कैसे है? क्या ये सभी पात्र ASCII में फिट हैं?
— फेडरिको पोलोनी
1
@FedericoPoloni हां, वे फिट होते हैं , हालांकि एक अन्य कोडपेज में।
— को आउटगॉल्फ
3

जावास्क्रिप्ट (ईएस 6), 51

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

परीक्षा

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)
})
स्निपेट का विस्तार करें

— edc65
स्रोत
3

जे, 21 14 बाइट्स

मील और (परोक्ष रूप से) जोनाथन के लिए धन्यवाद 7 बाइट्स सहेजे गए!

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

यह एक चार-श्रृंखला है:

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

चलिए इनपुट पर चलते हैं 10 27 232 1000। भीतरी कांटे में तीन टीने होते हैं। #@":"0आकार की गणना करता है, ,.प्रत्येक आकार को उसके नकारात्मक ( -) सदस्य के साथ जोड़ता है । इनपुट के लिए 10 27 232 1000, हमें इसके साथ छोड़ दिया गया है:

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

अब, हमारे पास {.@/:बाहरी टाइन के रूप में है। यह {.रंगाई प्रकार ( /:) से अधिक का पहला विमुद्रीकरण है । यही है, हम dyadic के परिणाम का पहला तत्व लेंगे /:। यह इसके बाएं तर्क के अनुसार इसके सही तर्क को हल करता है, जो हमें हमारे इनपुट के लिए देता है:

   (/: #@":"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और हम काम करते हैं।

— कोनोर ओ ब्रायन
स्रोत
कुछ फेरबदल प्लस एक हुक एक बाइट बचा सकता है >./@#~[:(=<./)#@":"0। मुझे लगता है कि बचाने के लिए थोड़ा और हो सकता है
— मीलों
@ मीलों XD मैंने सिर्फ स्पष्टीकरण लिखना समाप्त कर दिया। आह ठीक है, मुझे इस सुंदरता पर एक नज़र डालते हैं ...
— कॉनर ओ'ब्रायन
जोनाथन को एक बेहतर तरीका मिला। यदि हम इसे J में रूपांतरित करते हैं, तो इसकी 14 बाइट्स हैं {.@/:#@":"0,.-लेकिन इनपुट को एक सूची के रूप में आकार देना है
— मील
@ माइल "एक सूची के रूप में आकार"? तुम्हारा मतलब है, जैसे 400 12 13?
— कॉनर ओ'ब्रायन
2

जावास्क्रिप्ट (ईएस 6), 62 बाइट्स

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'))
स्निपेट का विस्तार करें

— user81655
स्रोत
2

डीसी, 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
— seshoumara
स्रोत
2

जावा 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;}

@ बारटेक्स 2 एक्स के लिए कई बाइट्स को बचाने के लिए अलग-अलग दृष्टिकोण ।

अनगढ़ और परीक्षण के मामले:

इसे यहाँ आज़माएँ।

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
— केविन क्रूज़सेन
स्रोत
1
छोटा संस्करण: int c (int [] a) {int i = a [0], j; for (int b: a) i = (j = (i + "")। length () - (b + "")। लंबाई ())> 0? b: b> i & j == 0? b: i; वापसी i?}
— barteks2x
@ Barteks2x धन्यवाद, मैंने इसे संपादित किया है।
— केविन क्रूज़सेन
2

बैश, awk, सॉर्ट 53 बाइट्स

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

स्टड से इनपुट पढ़ें, प्रति पंक्ति एक मान

बैश और सॉर्ट, 58 57 बाइट्स

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

— एम्मानुएल
स्रोत
अंतिम नमूने के लिए काम नहीं करता है 938 के बजाय 2383 दिया
— आर्केमर
@Archemar क्षमा करें, मैंने प्रश्न को गलत बताया, इसे अब ठीक कर लिया गया है
— इमैनुएल
आप के बीच की जगह को हटा सकते हैं whileऔर ((।
— शेषमारा
1

जावास्क्रिप्ट ईएस 6, 80 77 70 बाइट्स

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

मुझे उम्मीद है कि मैं सही दिशा में जा रहा हूं ...

— Downgoat
स्रोत
आप के a.map(i=>i.length).sort((a,b)=>a-b)[0]साथ बदल सकता है Math.min(...a.map(i=>i.length))?
— user81655
@ user81655 हाँ, मैं कर सकता हूँ। मुझे लगा कि मैंने वह संपादन किया है, लेकिन जाहिर है मैंने नहीं किया
— डाउनगेट
आप न्यूनतम को भी नकारने की कोशिश कर सकते हैं ताकि आप पुन Math.max: उपयोग कर सकें : a=>(m=Math.max)(...a.filter(l=>l.length==-m(...a.map(i=>-i.length))))ऐसा लगता है कि हालांकि केवल 1 बाइट की बचत होती है।
— user81655
एक और बाइट के लिए मानों के filterबदले mapउस रिटर्न के साथ बदला जा सकता है 0जो टेस्ट पास नहीं करता है:a=>(m=Math.max)(...a.map(l=>l.length+m(...a.map(i=>-i.length))?0:l))
— user81655
1

हास्केल, 39 बाइट्स

snd.maximum.map((0-).length.show>>=(,))
— डेमियन
स्रोत
यह काम नहीं करता है, यह पसंद करता 34है 2।
— xnor
धन्यवाद। मुझे इसे पुनर्विचार करना होगा ..
— डेमियन
अब बेहतर काम करता है!
— डेमियन
1

जावास्क्रिप्ट (ईएस 6), 57 54 53 बाइट्स

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

रिकॉर्ड के लिए, मेरा पिछला संस्करण अधिक गणित-उन्मुख था लेकिन 1 बाइट बड़ा था:

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

परीक्षण के मामलों

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
स्निपेट का विस्तार करें

— Arnauld
स्रोत
1

MATL , 11 बाइट्स

tV48\&XS0))

इनपुट एक कॉलम वेक्टर है ( ;विभाजक के रूप में), जैसे

[78; 99; 620; 100]

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

[78; 99; 620; 100]उदाहरण के रूप में इनपुट का उपयोग करते हैं ।

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
— लुइस मेंडो
स्रोत
1
आपकी व्याख्या में स्टैक राज्यों को देखकर अच्छा लगा!
— दोष
1

पर्ल, 38 37 बाइट्स

के लिए +1 शामिल है -a

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

सबसे बड़ी संख्या में मेमोरी रैखिक का उपयोग करता है, इसलिए बहुत बड़ी संख्या में यह कोशिश न करें। उस दोष के बिना एक समाधान 38 बाइट्स है:

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

ये सभी बहुत ही अजीब हैं और सभी में इष्टतम महसूस नहीं करते हैं ...

— टन हास्पेल
स्रोत
1

आर, 72 41 36 बाइट्स

नए दृष्टिकोण के साथ फ़ंक्शन को फिर से लिखें। @Bouncyball के एक सुझाव के लिए 5 बाइट्स के लिए धन्यवाद।

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

व्याख्या की:

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

इंडेंट / विस्तार से बताया:

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

— rturnbull
स्रोत
1
परिभाषित नहीं द्वारा 4 बाइट्स सहेजें function:i=scan();n=nchar(i);max(i[n==min(n)])
— बाउंसीबॉल
@bouncyball धन्यवाद! और 1 आगे बाइट द्वारा बचाया n=nchar(i<-scan())।
— rturnbull
1

बैश + कोरुटिल्स, 58 बाइट्स

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

इनपुट प्रारूप प्रति पंक्ति एक मान है। गोल्फ सुझावों का स्वागत किया जाता है।

स्पष्टीकरण:

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)
— seshoumara
स्रोत
+1 धन्यवाद अब मुझे पता है कि sed q=head -1
— इमैनुएल
0

पायथन 3, 56 बाइट्स

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

एक मेमने में एक मेमने का उपयोग करता है!

पायथन 2, 53 बाइट्स

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

वही लेकिन बैकटिक्स के साथ

— विनाशकारी नींबू
स्रोत
0

पिप , 11 बाइट्स

(SNgSK-#_v)

कमांड-लाइन आर्ग्स के रूप में इनपुट लेता है। इसे ऑनलाइन आज़माएं!

पहली बार Sort- Kआंखों वाले ऑपरेटर का उपयोग करना ! पायथन की तरह sorted(), यह एक ऐसा फंक्शन लेता है, जो इसे चलने-फिरने के प्रत्येक आइटम पर लागू किया जाता है और एक सॉर्ट कुंजी के रूप में उपयोग किया जाता है। यहां बताया गया है कि यह कार्यक्रम कैसे काम करता है:

 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
— DLosc
स्रोत
0

क्लोजर, 63 बाइट्स

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

जैसे की:

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

हालांकि मुझे यकीन है कि इसे छोटा करने का एक तरीका है।

— user3810626
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.