न्यूनतम चल रहा है

Question

स्टैक ओवरफ्लो पर एक सवाल से प्रेरित । यहां शीर्षक पूरी तरह से मेरी गलती है।

---

चुनौती

कम से कम दो प्रविष्टियों वाले सकारात्मक पूर्णांकों की सूची को देखते हुए, प्रत्येक संख्या को स्वयं को छोड़कर सभी प्रविष्टियों के न्यूनतम द्वारा प्रतिस्थापित करें।

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

[4 3 2 5]    ->  [2 2 3 2]
[4 2 2 5]    ->  [2 2 2 2]
[6 3 5 5 8]  ->  [3 5 3 3 3]
[7 1]        ->  [1 7]
[9 9]        ->  [9 9]
[9 8 9]      ->  [8 9 8]

नियम

एल्गोरिथ्म को सैद्धांतिक रूप से किसी भी इनपुट आकार (एक से अधिक) और मूल्यों (सकारात्मक पूर्णांक) के लिए काम करना चाहिए। यह स्वीकार किया जाता है कि कार्यक्रम समय, मेमोरी या डेटा प्रकारों तक सीमित है और इसलिए केवल दिए गए मान तक संख्या के लिए काम करता है, या किसी दिए गए मूल्य तक इनपुट आकार के लिए।

प्रोग्राम या फ़ंक्शंस की अनुमति है, किसी भी प्रोग्रामिंग भाषा में । मानक खामियों को मना किया जाता है।

इनपुट किसी भी उचित माध्यम से लिया जा सकता है ; और किसी भी प्रारूप के साथ। आउटपुट के लिए भी। इनपुट और आउटपुट प्रारूप भिन्न हो सकते हैं।

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

Comments

क्या [4 3 2 2 5]आउटपुट चाहिए ?

— कृति लिथोस

@KritiiLithos ने दूसरे टेस्ट केस को कवर नहीं किया?

— लीक नून

@KritiiLithos इनपुट के [4 3 2 2 5]लिए आउटपुट होगा [2 2 2 2 2](यह दूसरे टेस्ट केस के समान है)

— लुइस मेंडू

ओह, मैं दूसरा टेस्ट केस मिस कर गया। लेकिन अब मुझे समझ में आया कि यह कैसे काम करता है

— क्रिति लिथोस

@LuisMendo आपने "पूर्णांक" को "किसी भी इनपुट आकार और मान" में बदल दिया है। क्या इसका मतलब है कि हमें सभी वास्तविक संख्याओं के लिए खाते की आवश्यकता है?

— लीक नून

Answer 1

जेली , ९ ६ ५ बाइट्स

JḟÐ € `ḟÐ € 
ṙJṖ € ị⁸Ṃ €
ṙJ z «/ तर्क: 1D सरणी (z)

 जे [१,२,३, ..., लेन (जेड)]
(उपरोक्त राशि में से प्रत्येक द्वारा घूमता z (वर्तमान सरणी 2D है)
  Ṗ अंतिम सरणी निकालें
   «/ घटाकर [संक्षेप से सदिश] न्यूनतम

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

एक बार में उन सभी को सत्यापित करें! (ज़रा - सा संशोधित)

मुझे पूरा यकीन है कि डेनिस इसे बाहर निकाल सकते हैं।

यह काम किस प्रकार करता है

एल्गोरिथ्म बल्कि जटिल है। आइए देखें कि यह क्या करता है [4,2,2,5]।

सबसे पहले, हम Jप्राप्त करने के लिए उपयोग करते हैं [1,2,3,4]। ध्यान दें कि जेली 1-इंडेक्सिंग का उपयोग करती है।

फिर, हम देखते हैं ṙ। यह दो तर्क लेता है: एक सरणी और एक पूर्णांक। यह पूर्णांक द्वारा निर्दिष्ट राशि द्वारा बाईं ओर सरणी को घुमाता है। इधर, ṙदेखना होगा [4,2,2,5]अपनी बाईं तरफ और [1,2,3,4]अपने अधिकार (यह कैसे काम करता है में पाया जा सकता के बारे में अधिक पर ट्यूटोरियल )। जेली में, आज्ञाएँ स्पष्ट रूप से वेक्टरित होती हैं। इसलिए, यह आदेश प्रत्येक व्यक्तिगत तत्व पर दाईं ओर किया जाएगा, यही कारण है कि हम एक 2D सरणी बनाएंगे:

इसलिए, [4,2,2,5]ṙ[1,2,3,4]बन जाता है [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], जो बन जाता है:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2],
 [4,2,2,5]]

ध्यान दें कि मूल तत्व अंतिम पंक्ति में हैं, क्योंकि उस पंक्ति में हम सरणी की लंबाई के बराबर एक राशि से बाईं ओर घूमते हैं, यही कारण है कि हम Ṗउस पंक्ति को हटाने के लिए अगले का उपयोग करते हैं , ताकि कॉलम संग्रह हैं सरणी के तत्व जो वर्तमान सूचकांक में नहीं हैं:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2]]

निम्नलिखित ऑपरेशन, «/भी काफी जटिल है। सबसे पहले, «इसके बाईं ओर और इसके दाईं ओर दिखाई देने वाले दो नंबरों का न्यूनतम रिटर्न। उदाहरण के लिए, 5«3रिटर्न 3। अब, यदि दो तर्कों में सरणियाँ हैं, तो यह वैरिफाई करेगा जैसा कि मैंने ऊपर कहा है। इसका मतलब यह है कि जो है [1,5,2,3]«[4,1,5,2]वह बन जाएगा । अब, है कि हम अंत तक प्रत्येक पंक्ति से अधिक आपरेशन करते हैं, जिसका अर्थ है। उदाहरण के लिए, बन जाएगा , जो कि सरणी का योग है ।[1«4,5«1,2«5,3«2][1,1,2,2]/reduce[1,2,3,4]+/((1+2)+3)+4[1,2,3,4]

इसलिए, यदि हम «/अभी प्राप्त किए गए 2D सरणी पर लागू होते हैं, तो हमें मिलेगा:

([2,2,5,4]«[2,5,4,2])«[5,4,2,2]

वैश्वीकरण के कारण, जो इसके बराबर होगा:

[2«2«5,2«5«4,5«4«2,4«2«2]

जो सूचकांक में तत्व के बिना हर सरणी की न्यूनतम गणना करता है।

Comments

ओह, आपका संपादन ... आप पहले वहाँ पहुँच गए।

— जोनाथन एलन

@JonathanAllan मुझे क्षमा करें।

— लीक नून

Answer 2

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

lambda l:[sorted(l)[x==min(l)]for x in l]

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

प्रत्येक तत्व के लिए xहम जाँचते हैं कि क्या x==min(l)। यदि नहीं, तो यह वह है False, जिसे सबसे छोटे तत्व को देते हुए 0सूची सूचकांक के रूप में उपयोग किया जाता है sorted(l)। अन्यथा, यह Trueउर्फ है 1, दूसरा सबसे छोटा तत्व दे रहा है, क्योंकि यह तत्व स्वयं सबसे छोटा है और इसे अनदेखा किया जाना चाहिए।

Comments

मुझे विश्वास है कि यह काम करता है।

— लीक नून

महान दृष्टिकोण!

— लुइस मेंडो

क्या आप एक स्पष्टीकरण जोड़ सकते हैं? यह बहुत जटिल नहीं किया जाएगा, लेकिन की चाल "हर संख्या कम से कम हो जाएगा, एक है कि के अलावा है कम से कम है, जो दूसरी सबसे छोटा हो जाएगा" और तथ्य यह है कि Falseपरिवर्तित हो जाता है 0और Trueपरिवर्तित हो जाता है 1वास्तव में कर रहे हैं शांत और के बारे में ^ W ^ Wexplained

— निक हार्टले

Answer 3

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

=Ṃ‘ịṢ

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

कैसे?

=Ṃ‘ịṢ - Main link: list a     e.g.  [4,3,2,5]
 Ṃ    - minimum of a                2
=     - equals? (vectorises)        [0,0,1,0]
  ‘   - increment                   [1,1,2,1]
    Ṣ - sort a                      [2,3,4,5]
   ị  - index into                  [2,2,3,2]

Comments

@LeakyNun यह एक बंदरगाह नहीं है, यह सिर्फ एक ही तरीका है, मैं अभी भी कम की तलाश कर रहा हूं ... मैंने उस उत्तर को अभी भी उतारा है :)

— जोनाथन एलन

@LeakyNun मैं यहाँ नया हूँ, लेकिन क्या आप हमेशा इस शत्रुतापूर्ण हैं? ऐसा नहीं है कि इस दृष्टिकोण के लिए अद्वितीय तरीके हैं। भले ही उसने इसे पोर्ट किया हो, फिर भी उसके पास इसका छोटा जवाब है।

— ग्रेसन केंट

@GraysonKent मैं अपनी कथित दुश्मनी के लिए माफी माँगता हूँ।

— लीक

@GraysonKent PPCG में आपका स्वागत है!

— लुइस मेंडू

@LeakyNun यह सरल चुनौतियों में बहुत कुछ होता है, आप वास्तव में यह नहीं कह सकते कि हर उत्तर प्रत्येक दूसरे का एक पोर्ट है

— केवल

Answer 4

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

संपादित करें:

• -1 बाइट थैंक्स टू निम्मी!
• -2 बाइट्स। एक धन्यवाद xnor के लिए! और एक अपने आप से।

fपूर्णांक (या किसी भी Ordप्रकार) की एक सूची लेता है और एक सूची देता है।

f(x:y)=minimum y:(fst<$>zip(f$y++[x])y)

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

fसूची को घुमाते समय पुनरावृत्ति होती है। xपहली सूची तत्व और yशेष है। चूंकि पुनरावृत्ति अनंत है, इसलिए परिणाम सूची को काट दिया जाना चाहिए: fst<$>zip...yकहने का एक छोटा तरीका है take(length y)...।

Comments

आप पूरी इनपुट सूची का नामकरण करके एक बाइट को बचा सकते हैं @और सूची को ज़िपित करने के लिए फ्लिप कर सकते हैं f l@(x:y)=fst<$>zip(minimum...)l:।

— नीमी

f(h:t)=minimum t:(fst<$>zip(f(t++[h]))t)

— xnor

Answer 5

ऑक्टेव, 26 बाइट्स

@(x)sort(x)((x==min(x))+1)

एक समान दृष्टिकोण के रूप में में इस्तेमाल किया इस जवाब है, जो के रूप में ही होता है यह ।

मैं वास्तव में सिर्फ अन्य उत्तरों को पोर्ट करने का प्रशंसक नहीं हूं, यही वजह है कि मैं इस बात पर ध्यान देना चाहता हूं कि मैंने अन्य लोगों को देखने से पहले एक समान विचार किया था।

स्पष्टीकरण:

जोनाथन एलन ने पहले से ही जेली-कोड के लिए एक अच्छी व्याख्या प्रदान की है, इसलिए यह ओक्टेव-बिट को कवर करता है, और यह क्यों काम करता है (और MATLAB में काम नहीं करेगा)।

@(x)                       % An unnamed anonymous function taking a vector x as input
    sort(x)                % Gives a sorted version of x
            (x==min(x))    % Checks if each element is equal to the minimum value
           ((x==min(x))+1) % Adds 1 to the boolean vector, to use as indices
@(x)sort(x)((x==min(x))+1) % Complete function

यह MATLAB में काम नहीं करता है, क्योंकि इनलाइन असाइनमेंट और डायरेक्ट इंडेक्सिंग काम नहीं करता है। sort(x)(1)MATLAB में एक त्रुटि देता है, क्रमबद्ध वेक्टर में पहला तत्व नहीं है।

Answer 6

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

a#(b:c)=minimum(a++c):(b:a)#c
a#b=b 
([]#)

प्रयोग उदाहरण: ([]#) [4,3,2,5]-> [2,2,3,2]। इसे ऑनलाइन आज़माएं!

एक खाली संचायक के साथ शुरू करें aऔर इनपुट सूची को नीचे चलाएं। आउटपुट सूची में अगला तत्व संचायक का न्यूनतम है aऔर सभी लेकिन इनपुट सूची (-> c) के पहले तत्व के बाद एक पुनरावर्ती कॉल पहले तत्व के साथ bसंचयकर्ता में जोड़ा गया और c। जब आप इनपुट सूची के अंत तक पहुँचते हैं तो रुकें।

Answer 7

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

a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))

संपादित करें: @Annauld के लिए 4 बाइट्स सहेजे गए।

Comments

a=>a.map(x=>Math.min(...a.filter(y=>x!=y)))43 बाइट्स के लिए।

— झबरा

@Shaggy मुझे नहीं लगता कि इस तरह के रूप में एक इनपुट के लिए है कि काम करता है3,3,3,3

— Arnauld

डी 'ओह! नहीं, यह काम नहीं करेगा अगर न्यूनतम मूल्य के 2 या अधिक घटनाएँ हैं।

— झबरा

हालाँकि, आप a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))46 के लिए कर सकते हैं।

— अरनौल्ड

@ अर्नुलद बहुत चालाक, धन्यवाद!

— नील

Answer 8

ब्रेकीलॉग , 13 12 बाइट्स

l+₁:?⊇ᶠ⁽⌋ᵐb↔

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

@ Ais523 को एक बाइट धन्यवाद दिया।

व्याख्या

l+₁:?            The list [length(Input) + 1, Input]
     ⊇ᶠ⁽         Find the length(Input) + 1 first subsets of the Input
        ⌋ᵐ       Get the min of each subset 
           b↔    Remove the first element and reverse

हम इस तथ्य का फायदा उठाते हैं कि ⊇सबसे बड़े से सबसे छोटे तक सबसेट को एकजुट करता है। उदाहरण के लिए [1,2,3], हमें जो सबसेट मिलते हैं, वे इस क्रम में हैं [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], []:।

हम देख सकते हैं कि सबसेट [1,2], [1,3], [2,3]वे हैं जिनसे हम न्यूनतम चाहते हैं, लेकिन इनपुट सूची (इसलिए ↔) की तुलना में रिवर्स ऑर्डर में हैं । हम केवल पहले length(Input) + 1सबसेट को खोजकर उन सबसेट का चयन कर सकते हैं , जिनमें सभी + पूरी सूची पहले शामिल होगी। हम उस पूरी सूची को छोड़ देते हैं b।

Comments

आप अपने "findall subset + minimal" को "findall subset" और "map न्यूनतम" में विभाजित करके एक बाइट बचा सकते हैं। (मुझे इसे Brachylog टिप्स थ्रेड में जोड़ने की आवश्यकता है, अब आपने मुझे इसकी याद दिला दी है।)

@ ais523 धन्यवाद, मैं हमेशा उस ट्रिक को भूल जाता हूं ...

— Fatalize

Answer 9

दरअसल , 13 बाइट्स

;;S╝m╗⌠╜=╛E⌡M

उसी तकनीक का उपयोग करता है जिसे एक्सनोर ने भी खोजा था ।

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

स्पष्टीकरण:

;;S╝m╗⌠╜=╛E⌡M
;;             make two extra copies of input list
  S╝           sort one and save it in register 1
    m╗         save the minimum of the other in register 0
      ⌠╜=╛E⌡M  for each value in list:
       ╜=╛E      return the minimum element of the input list if the value is not equal to the minimum, else return the second-smallest element

Comments

आपने अभी भी हमें अस्थायी स्टैक के अंदर वैश्विक स्टैक को देखने की अनुमति नहीं दी है?

— लीके नन

@LeakyNun अभी तक नहीं। वर्तमान स्थिति में है कि दुभाषिया कोड में है, यह बहुत मुश्किल होगा। जब मैं बड़ी रीफैक्टरिंग पर काम कर रहा था, उसे पूरा करने के बाद, मैं उस कार्यक्षमता को जोड़ने के बारे में देखूंगा।

— मेगो

आपने बड़े रिफैक्टिंग की शुरुआत कब की?

— लीक नून

Answer 10

आर, 46 31 बाइट्स

l=scan();sort(l)[(min(l)==l)+1]

आर, अफसोस में स्टेवी ग्रिफिन के समाधान को लागू करता है , मेरा मूल विचार 50% लंबा है! अभी भी स्टड से सूची पढ़ता है, लेकिन अब एक बहुत अधिक पढ़ने योग्य संख्यात्मक वेक्टर देता है।

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

पुराना कार्यान्वयन:

l=scan();Map(function(x)min(l[-x]),match(l,l))

स्टड से सूची में पढ़ता है। एक नकारात्मक सूचकांक l[-x]तत्व को सूची से बाहर करता है, और सूची match(l,l)के प्रत्येक तत्व की पहली घटना का सूचकांक देता है। एक सूची देता है।

Answer 11

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

मुझे पता है कि पहले से ही एक बेहतर पायथन समाधान है, लेकिन मैं अभी भी मेरा पोस्ट करना चाहता हूं।

lambda L:[min(L[:i]+L[i+1:])for i in range(len(L))]

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

Answer 12

गणितज्ञ 34 बाइट्स

Min[#~Drop~{i}]~Table~{i,Tr[1^#]}&

Answer 13

पॉवरशेल , 68 59 बाइट्स

($a=$args)|%{$b+=@((($c=$a|sort)[0],$c[1])[$_-eq$c[0]])};$b

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

मुझे पूरा विश्वास है कि इसे छोटा किया जा सकता है, मैं इसे देखता रहूंगा

Answer 14

सी, 85 बाइट्स

i,j,m;f(d,o,n)int*d,*o;{for(i=n;i--;)for(m=d[!i],j=n;j;o[i]=m=--j^i&&d[j]<m?d[j]:m);}

पहला तर्क इनपुट पूर्णांक सरणी है। दूसरा तर्क आउटपुट पूर्णांक सरणी है। तीसरा तर्क दोनों सरणियों के लिए तत्व गणना है।

इसे ऑनलाइन देखें ।

Answer 15

पर्ल 6 ,  26 24  19 बाइट्स

26

{.map: (.Bag∖*).min.key}

ध्यान दें कि ∖U + 2216 नहीं \U + 5C है

कोशिश करो

{.map: (.Bag⊖*).min.key}

कोशिश करो

24

{(.min X%$_)X||.sort[1]}

कोशिश करो

19

{.sort[.min X==$_]}

कोशिश करो

---

26

{           # bare block lambda with implicit parameter ｢$_｣

  .map:     # for each of the values in the input (implicit method call on ｢$_｣)
  (
    .Bag    # turn the block's input into a Bag
    ∖       # set-difference           ｢∖｣ U+2216 aka ｢(-)｣
    # ⊖     # symmetric-set-difference ｢⊖｣ U+2296 aka ｢(^)｣
    *       # turn expression into a WhateverCode lambda (this is the parameter)
  ).min.key # get the minimum pair from the Bag, and return its key
}

मैंने एससीआई समकक्षों के बजाय "फैंसी" यूनिकोड ऑपरेटरों का इस्तेमाल किया क्योंकि उन्हें उनके सामने एक स्थान की आवश्यकता होती ताकि वे .Bagविधि कॉल के हिस्से के रूप में पार्स न हों ।

24

{
  (.min X% $_) # the minimum cross modulus-ed with the input
  X||          # cross or-ed 
  .sort[1]     # with the second minimum
}

19

{
  .sort\        # sort the values
  [             # index into that
    .min X== $_ # the minimum cross compared with the input
  ]
}

---

(24 और 19 बाइट गोल्फ एक जेली कार्यान्वयन से प्रेरित थे )

Answer 16

क्लोजर, 36 81 62 71 बाइट्स

नवीनतम (वास्तव में इन जल्दी में प्रस्तुत नहीं करना चाहिए):

#(for[c[(zipmap(range)%)]i(sort(keys c))](apply min(vals(dissoc c i))))

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

Aaaand इस एक बग (62 बाइट्स) है, zipmap एक unordered नक्शा का उत्पादन करता है ताकि यह बड़े इनपुट के लिए सही अनुक्रम का उत्पादन न करे।

#(for[c[(zipmap(range)%)][i v]c](apply min(vals(dissoc c i))))

vवास्तव में किसी भी चीज़ के लिए उपयोग नहीं किया जाता है लेकिन यह इससे छोटा है i (keys c)।

81 बाइट्स पर पिछला:

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

#(let[r(range(count %))](for[i r](apply min(for[j r :when(not= i j)](nth % j)))))

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

ओह लानत है मूल (36 बाइट्स) काम नहीं करता है जब न्यूनतम संख्या दोहराई जाती है, तो [4 2 2 5]परिणाम [2 4 4 2]दोनों 2एस हटा दिए जाते हैं :(

#(for[i %](apply min(remove #{i}%)))

#{i}वह सेट है जिसमें केवल शामिल होता है i, यह iदूसरों के लिए सच्चाई और झूठे रिटर्न देता है , जिसका अर्थ है कि इनपुट सूची के भीतर अन्य सभी नंबरों से न्यूनतम गणना की जाती है।

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

Answer 17

पायथ, 8 7 बाइट्स

mh.-SQ]

-1 बाइट @ @acacg के लिए धन्यवाद

कोशिश करो!

Comments

आप dअंत में हटा सकते हैं - यह

— संक्षेप

@isaacg धन्यवाद, पता नहीं था कि

— KarlKastor

Answer 18

PHP, 72 बाइट्स

<?$k=$g=$_GET;sort($k);foreach($g as&$v)$v=$k[$v==$k[0]?:0];print_r($g);

ऑनलाइन संस्करण

Answer 19

PHP, 47 बाइट्स

while(++$i<$argc)echo@min([z,$i=>z]+$argv),' ';

Answer 20

स्काला, 37 बाइट्स

l.indices map(i=>l diff Seq(l(i))min)

l Int का कोई भी संग्रह है।

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

scala> val l = List(4,3,2,5)
l: List[Int] = List(4, 3, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 3, 2)

scala> val l = List(4,2,2,5)
l: List[Int] = List(4, 2, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 2, 2)

scala> val l = List(6,3,5,5,8)
l: List[Int] = List(6, 3, 5, 5, 8)

scala> l.indices map(i=>l diff Seq(l(i))min)
res2: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 5, 3, 3, 3)

scala> val l = List(7,1)
l: List[Int] = List(7, 1)

scala> l.indices map(i=>l diff Seq(l(i))min)
res3: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 7)

scala> val l = List(9,9)
l: List[Int] = List(9, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res4: scala.collection.immutable.IndexedSeq[Int] = Vector(9, 9)

scala> val l = List(9,8,9)
l: List[Int] = List(9, 8, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res5: scala.collection.immutable.IndexedSeq[Int] = Vector(8, 9, 8)

यह शायद अभी भी गोल्फ हो सकता है, मैं एक सूची से एक तत्व को हटाने के लिए एक छोटा रास्ता नहीं ढूंढ सकता था l diff Seq(l(i))

Answer 21

सी #, 36 बाइट्स

i.Select((x,a)=>i.Where((y,b)=>b!=a).Min())

तत्वों (i) को लेता है और न्यूनतम मूल्य के लिए वर्तमान आइटम के बिना तत्वों में दिखता है।

यह दुख की बात है, कि कुछ अन्य प्रयास काम नहीं करते हैं, जैसा कि हम आदिम प्रकार के साथ काम करते हैं, और इसलिए आइटमों की तुलना करने के लिए संदर्भों के साथ सूची नहीं है।

Answer 22

पॉवरशेल , 49 38 बाइट्स

^{-11 बाइट्स mazzy के लिए धन्यवाद}

($a=$args)|%{($c=$a|sort)[$_-eq$c[0]]}

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

साइनसॉइड के प्यारे उत्तर में सुधार । एक सरणी के निर्माण के बजाय स्पष्ट आउटपुट का उपयोग करके 10 बाइट्स बचाता है। अनुक्रमित सरणी में अनुक्रमित या तो 0 (यानी सबसे छोटा मान) या स्थान 1 पर स्थित है, अगर सशर्त सही है।

Comments

होशियार है। अधिक सहेजें :) इसे ऑनलाइन आज़माएं!

— mazzy

@ माज़ी अच्छा किया। यह स्पष्ट है कि अब मैं इसे देख रहा हूं लेकिन मैंने कभी इसे एक साथ नहीं रखा होगा।

— विस्कह

अच्छा काम! तुम्हारा और अधिक प्यारा है :)

— साइनसॉइड

Answer 23

पर्ल 5, 43 बाइट्स

sub{@x=sort{$a<=>$b}@_;map$x[$_==$x[0]],@_}

पायथन समाधान के बराबर। पर्ल है sortदुर्भाग्य से संख्या के लिए गलत डिफ़ॉल्ट (एक स्पष्ट तुलनित्र की आवश्यकता होती है), और minनिर्मित नहीं है, लेकिन यह लगभग द्वारा इसके लिए निर्माण करता है subकी तुलना में कम किया जा रहा है lambda, map$_,की तुलना में कम किया जा रहा है x for x in, और बदले और आर्ग सूचियों का implicitness।

Answer 24

रूबी, 30 बाइट्स

प्रत्येक तत्व के लिए, सरणी को सॉर्ट करें, वर्तमान तत्व को हटा दें और शेष सरणी के पहले तत्व को पकड़ो।

->a{a.map{|e|(a.sort-[e])[0]}}

यह एक अनाम फ़ंक्शन है जिसका उपयोग इस तरह किया जा सकता है:

f = ->a{a.map{|e|(a.sort-[e])[0]}}
p f[[6, 3, 5, 5, 8]] # => [3, 5, 3, 3, 3]

Answer 25

सीजेएम, 15 बाइट्स

{:S{S:e<=S$=}%}

अनिवार्य रूप से CJam में xnor के एल्गोरिथ्म का अनुवाद।

यह एक अनाम ब्लॉक है जो स्टैक से एक सरणी लेता है और स्टैक पर परिणाम छोड़ता है।

स्पष्टीकरण:

{
  :S     e# Save in S
  {      e# For X in S:
    S:e< e#   Push Min(S)
    =    e#   X == Min(S)
    S$=  e#   Sorted(S)[top of stack]
  }%     e# End
}

Comments

@LuisMendo वूप्स - मैं वास्तव में सरणी को सॉर्ट करना भूल गया। यह अब काम करना चाहिए।

— फल

Answer 26

05AB1E , 5 बाइट्स

{sWQè

पोर्ट ऑफ @xnor पायथन 2 उत्तर ।

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

स्पष्टीकरण:

{        # Sort the (implicit) input-list
         #  i.e. [4,1,3,6] → [1,3,4,6]
 s       # Swap, so the (implicit) input-list is at the top of the stack again
  W      # Get the minimum without popping from the list
         #  i.e. [4,1,3,6] → 1
   Q     # Check for each element if they are equal to this value (1/0 as truthy/falsey)
         #  i.e. [4,1,3,6] and 1 → [0,1,0,0]
    è    # Use these 0s and 1s to index in the sorted list
         #  i.e. [1,3,4,6] and [0,1,0,0] → [1,3,1,1]

Answer 27

जावा 8, 119 बाइट्स

a->{int t[]=a.clone(),m=a[0],i=a.length;for(int x:a)m=x<m?x:m;for(java.util.Arrays.sort(t);i-->0;)a[i]=t[a[i]==m?1:0];}

पोर्ट ऑफ @xnor पायथन 2 उत्तर ।

बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट-सरणी को संशोधित करता है।

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

स्पष्टीकरण:

a->{                  // Method with integer-array parameter and no return-type
  int t[]=a.clone(),  //  Make a copy of the input-array
      m=a[0],         //  Minimum `m`, starting at the first value of the input-array
      i=a.length;     //  Index-integer, starting at the length of the input-array
  for(int x:a)        //  Loop over the input-array
    m=x<m?            //   If the current item is smaller than the current `m`
       x              //    Replace `m` with this value
      :               //   Else:
       m;             //    Leave `m` the same
  for(java.util.Arrays.sort(t);
                      //  Sort the copy we've made of the input-array
      i-->0;)         //  Loop `i` in the range (length, 0]
    a[i]=             //   Modify the item at index `i` of the input-array to:
      t[              //    The item in the sorted array at index:
        a[i]==m?      //     If the current item and the minimum are equal:
         1            //      Use index 1 in the sorted array
        :             //     Else:
         0];}         //      Use index 0 in the sorted array

Answer 28

APL (Dyalog Extended) , 7 बाइट्स

पोर्ट ऑफ़ ज़्नोर का पायथन 2 उत्तर। आवश्यकता है ⎕IO←0:

∧⊇⍨⊢=⌊/

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

स्पष्टीकरण:

∧⊇⍨⊢=⌊/  ⍝ Monadic function train
      ⌊/  ⍝ The minimum element of the input
    ⊢=    ⍝ Element-wise compare the input to the above
          ⍝ Results in a boolean vector, let's call it "X"
∧         ⍝ Sort the input
 ⊇⍨      ⍝ Index into sorted input by X

Answer 29

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

यह पहले के हास्केल प्रविष्टियों की तुलना में काफी लंबा है, लेकिन यह पहला है जो केवल तुलनाओं की एक रैखिक संख्या और अतिरिक्त काम की एक रैखिक राशि का प्रदर्शन करता है।

f(x:y)|(z,w)<-x!y=z:w
a![x]=(x,[a])
a!(x:y)|(p,q)<-a#x!y=(x#p,a#p:q)
(#)=min

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

व्याख्या

!दो तर्क लेते हैं: एक न्यूनतम और एक गैर-रिक्त सूची। यह सूची में न्यूनतम मूल्य देता है और दी गई सूची का उपयोग करके चल रहे न्यूनतम प्रसंस्करण का परिणाम है।

Answer 30

मठगोल्फ , ९ 7 बाइट्स

s_╓?m=§

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

व्याख्या

मूल रूप से केविन क्रूज़सेन के 05AB1E उत्तर का एक बंदरगाह है, लेकिन मैं स्पष्ट रूप से काम करने के लिए 2 बाइट्स खो देता हूं।

s         sort(array)
 _        duplicate TOS
  ╓       minimum of two elements, min of list, minimum by filter
   ?      rot3 pops input on top of stack again
    m=    explicit map to check equality
      §   get from sorted array for each