सबसे बड़ी और सबसे छोटी संभावित संख्या

Question

कार्य

गैर-ऋणात्मक संख्याओं की एक सरणी को देखते हुए, सबसे बड़ी और सबसे छोटी संभव संख्या को आउटपुट करें जो उन्हें जोड़कर बनाई जा सकती है।

नियम

इनपुट, आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकता है।

सरणी में अधिकतम 1 दशमलव संख्या हो सकती है।

उदाहरण

input:[22,33,44,55.55,33]
output:4433332255.55,55.5522333344

input:[34,900,3,11,9]
output:990034311,113349009

input:[99.93,9,3,39]
output:939399.93,99.933399

input:[45.45,45,45,45]
output:45454545.45,45.45454545

input:[12,21,34,43,45.1]
output:4334211245.1,45.112213443

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

Comments

क्या पहला आउटपुट नहीं होगा: 4422333355.55, 55.5544333322? वे क्रमशः छोटे और बड़े होते हैं।

— उलफाक

@ouflak, आपको सबसे बड़ा और सबसे छोटा आउटपुट देना होगा।

— वेदांत कंदोई

कोई बात नहीं, अभी देख लो। दशमलव स्थान के साथ भ्रमित हो गया।

— उलफाक

चाहेंगे [[55.55,22,33,33,44],[44,33,33,22,55.55]]एक स्वीकार्य उत्पादन प्रारूप हो सकता है?

— झबरा

कोई भी रास्ता ठीक नहीं है @ जोर्डन

— वेदांत

Answer 1

पायथन 2 , 84 80 78 76 बाइट्स

lambda a:[''.join(sorted(a,key=lambda s:'.'in s or s+s)[::i])for i in[-1,1]]

इसे ऑनलाइन आज़माएं!

_{-2 बाइट्स, धन्यवाद अरनौलद को}

Answer 2

05AB1E , 11 बाइट्स

œJΣ'.¡ï}Á2£

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

 œ             # get permutations of input
  J            # join each
   Σ    }      # sort by
    '.¡        # splitting into [before decimal, after decimal]
       ï       # and converting each to int
         Á     # rotate the result right
          2£   # and take the first 2 values

Comments

बहुत बुरा हम एक नहीं है cast to float। मुझे याद है कि लिगेसी में एक था, लेकिन मैंने अभी इसे देखा और जाहिर तौर पर यह एक था stringified cast to float, जो बहुत बेकार है क्योंकि आप स्ट्रिंग्स के बजाय

— तैरना

@ केविनक्रूजसेन: हाँ। हमारे पास एक is_numberदुर्भाग्य था लेकिन नहीं to_number।

— एमिगा

Answer 3

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

a=>[1,-1].map(n=>a.sort((a,b)=>[a%1||a]+b<[b%1||b]+a?n:-n).join``)

इसे ऑनलाइन आज़माएं!

कैसे?

इनपुट ऐरे में दो मानों की तुलना करने के लिए हम निम्नलिखित परीक्षण का उपयोग करते हैं:

[a % 1 || a] + b < [b % 1 || b] + a

x % 1 || x$x$$x$$x$

अभिव्यक्ति [x % 1 || x] + yउपरोक्त परिणाम को एक स्ट्रिंग के साथ जोड़ती है और इसे अन्य मूल्य के साथ समेटती है।

यदि सूची में कोई दशमलव संख्या है, तो इसे हमेशा सबसे छोटा मान होना चाहिए। हमारे रूपांतरण को लागू करने से, एक दशमलव संख्या को स्ट्रिंग में बदल दिया जाता है "0.", जो कि किसी भी चीज़ से पहले शाब्दिक रूप से आदेशित होता है।

उदाहरण:

  a |   b | [a%1||a]+b | [b%1||b]+a
----+-----+------------+------------
  4 |   5 | "45"       | "54"
 10 |  11 | "1011"     | "1110"
  8 |  80 | "880"      | "808"
  7 | 9.5 | "79.5"     | "0.57"

Answer 4

जाप, 14 11 बाइट्स

á m¬ñn é v2

कोशिश करो

1 बाइट ने लुइस को धन्यवाद दिया , कृपया +1उसका समाधान भी करें।

á               :Permutations
  m             :Map
   ¬            :  Join
    ñ           :Sort by
     n          :  Converting each to a number
       é        :Rotate right
         v2     :Remove & return the first 2 elements

Comments

ठीक है, यह बेहतर है !! अरे नहीं!! यह éसब छिपा हुआ था !!

— लुइस फेलिप डी जीसस मुनोज

Answer 5

जाप , 14 11 10 बाइट्स

á m¬ñn gJò

इसे ऑनलाइन आज़माएं!

Comments

अच्छा है। मैं á ®¬nÃnपहली पंक्ति के लिए था - अपने आप को लात मारना कि मैंने आपके रास्ते के बारे में नहीं सोचा था।

— झबरा

-hध्वज का उपयोग करते हुए 12 बाइट्स ।

— झबरा

-gझंडे का उपयोग करते हुए 11 बाइट्स । इसके íबजाय के साथ काम करता है ï।

— झबरा

@ सुग्गी उत्कृष्ट! धन्यवाद!!

— लुइस फेलिप डी जेउस मुनोज

डांग! लगता है मैंने जल्द ही हार मान ली; बहुत अच्छी तरह से किया।

— झबरा

Answer 6

जेली , 6 बाइट्स

Œ!VṢ.ị

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

Œ!VṢ.ị Arguments: x
Œ!     Permutations of x
  V    Concatenate the representations of each permutation's elements and evaluate the result as Jelly code
   Ṣ   Sort
    .ị Get element at index 0.5, i.e. elements at indices 0 (last) and 1 (first)

Comments

मैं कभी भी जेली में कार्यक्रम नहीं करता, लेकिन .ịएक सूची के पहले और आखिरी दोनों आइटम प्राप्त करने का एक अच्छा तरीका है। अच्छा उत्तर! मुझ से +1।

— केविन क्रूज़सेन

@KevinCruijssen यह वास्तव में अंतिम और पहला आइटम प्राप्त करता है। : P

— निकोलग्राफ

मैंने कभी भी जेली में प्रोग्राम नहीं किया है, लेकिन मैं उलझन में हूं कि कैसे .ịकाम करता है। यदि मैं डॉक्स को सही ढंग से पढ़ रहा हूं, तो मुझे लगता ịहै कि फर्श (x) और छत (x) पर y का तत्व मिलेगा , और .है 0.5। इसका मतलब यह नहीं है कि यह सूचकांक 0 और 1 पर y के तत्व प्राप्त करेगा?

— काउबुनघोल

क्या जेली 1-आधारित अनुक्रमित है? यह इस व्यवहार की व्याख्या करेगा, लेकिन डॉक्स में मुझे इसके बारे में कुछ भी नहीं दिखता है।

— काउबुनघोल

@Cowabunghole हां, जेली 1-अनुक्रमित है।

— निकोलग्राफ

Answer 7

रूबी , 56 45 बाइट्स

->a{a.permutation.map{|p|p.join.to_f}.minmax}

इसे ऑनलाइन आज़माएं!

-11 बाइट्स, धन्यवाद जॉर्डन

Comments

अच्छा काम! आप अपने तर्क के चारों ओर कोष्ठकों को गिराकर 2 बाइट्स बचा सकते हैं ( ->a{...और एक और 9 आसान minmaxविधि का उपयोग करके : tio.run/…

— जॉर्डन

Answer 8

पायथ, 13 12 बाइट्स

hM_BSvsM.p`M

आउटपुट के रूप में [smallest, largest]। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

hM_BSvsM.p`MQ   Implicit: Q=eval(input())
                Trailing Q inferred
          `MQ   Stringify all elements of Q
        .p      Generate all permutations of the above
      sM        Concatenate each permutation
     v          Evaluate each as a number
    S           Sort them
  _B            Pair the sorted list with its reverse
hM              Take the first element of each, implicit print

संपादित करें: मैपिंग फ़ंक्शन के बाहर कड़ाई ले जाकर एक बाइट को बचाया। पुराना वर्जन: hM_BSmvs`Md.p

Answer 9

पर्ल 6 , 41 बाइट्स

{.max,.min}o+<<*.permutations.map(*.join)

इसे ऑनलाइन आज़माएं!

विकल्प:

{.max,.min}o+<<*.permutations.map:{.join}
{.max,.min}o{[map +*.join,.permutations]}
{.max,.min}o{+<<map *.join,.permutations}

Answer 10

भूसी , 10 बाइट्स

§,▼▲morṁsP

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

व्याख्या

§,▼▲m(rṁs)P  -- example input: [2,3,1.1]
          P  -- permutations: [[2,3,1.1],[3,2,1.1],[1.1,3,2],[3,1.1,2],[1.1,2,3],[2,1.1,3]]
    m(   )   -- map the following
                (example with [1.1,2,3])
       ṁs    -- | show each and join: "1.123"
      r      -- | read: 1.123
             -- : [231.1,321.1,1.132,31.12,1.123,21.13]
§,           -- fork and join as tuple
  ▼          -- | min: 1.123
   ▲         -- | max: 321.1
             -- : (1.123,321.1)