काम

कार्य बहुत सरल है। केवल पूर्णांक और स्ट्रिंग्स वाले एक सरणी को देखते हुए , सबसे बड़ी संख्या और सबसे छोटी संख्या का उत्पादन करते हैं।

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

Input: [1, 2, 3, 4, 5, 6, 7, 8]
Output: 1, 8

Input: [5, 4, 2, 9, 1, 10, 5]
Output: 1, 10

Input: [7, 8, 10, "Hello", 5, 5]
Output: 5, 10

स्ट्रिंग्स में संख्याओं को पूर्णांक नहीं माना जाता है:

Input: [1, 2, 3, 4, "5"]
Output: 1, 4

यदि केवल एक पूर्णांक है, तो यह सबसे बड़ा और सबसे छोटा पूर्णांक दोनों है:

Input: [1]
Output: 1, 1

Input: ["1", "2", "3", "4", 5]
Output: 5, 5

नियम

आप मान सकते हैं कि एक सरणी में हमेशा कम से कम एक पूर्णांक होता है।
सभी पूर्णांक सकारात्मक हैं (0 से अधिक)
आउटपुट का क्रम मायने नहीं रखता।
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!
स्ट्रिंग्स में सभी मुद्रण योग्य ASCII वर्ण ( 32 - 126) हो सकते हैं और गैर-रिक्त हैं।

code-golf array-manipulation

— अदनान
स्रोत

इनपुट में दर्शाए गए उद्धरण चिह्नों के तार कैसे हैं?

— feersum

@ Faersum आपकी भाषा पर निर्भर नहीं करेगा?

— मार्टिन एंडर

@ Faersum शायद भागने वाले किरदारों के साथ है, लेकिन अगर भाषा यह नहीं संभालती है, तो ठीक है।

— अदनान

@ मार्टिनबटनर यदि इनपुट को स्टड से लिया जाता है, तो यह इस बात पर निर्भर नहीं होना चाहिए कि किस भाषा का उपयोग किया जाता है।

— feersum

3

@ Faersum मेरे लिए नया है। एसटीडीआईएन से भी [1, 2, 3] 1 2 3और {1; 2; 3}सभी वैध इनपुट प्रारूप हैं, इसलिए मैं यह नहीं देखता कि एसटीडीआईएन से प्राप्त स्ट्रिंग शाब्दिकों के लिए यह अलग क्यों होना चाहिए।

— मार्टिन एंडर

9

गंभीरता से, ९ ६ बाइट्स

,ì;M@m

यह ऑनलाइन की कोशिश करो

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

,                              Read list input
 ì                             Remove everything but numbers from it
  ;                            Make a copy
   m                           Extract its min value
    @M                         Extract the other one's max value
                               Implicit output (max then min)

— quintopia
स्रोत

आह, हाँ, मैं इस तरह के आदेश की तलाश में था। लेकिन डॉक्स को खोजना आसान नहीं है।

— क्विंटोपिया

मैं सहमत हूँ। डॉक्स मेरा अगला बड़ा लक्ष्य है।

— Mego

11

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

2 बाइट संपादित करें thx @Neil को बचाया

नोट: x===+xसच है अगर और केवल अगर xएक संख्या है

a=>[Math.max(...a=a.filter(x=>x===+x)),Math.min(...a)]

— edc65
स्रोत

3

क्यों बाहरी ()एस?

— नील

@ बाहरी क्या ()? पृथ्वी पर मुझे बाहरी () क्यों होना चाहिए?

— edc65

यह एक फ़ंक्शन देता है, आपको अभी भी इसे कॉल करने की आवश्यकता है। (या सिर्फ एक => निकालें)

— माइकल थेरोट

2

हाँ यह एक गुमनाम कार्य है। यह जावास्क्रिप्ट में एक उत्तर पोस्ट करने के लिए काफी सामान्य तरीका है @MichaelTheriot

— edc65

@MichaelTheriot डिफ़ॉल्ट रूप से , हम सबमिशन को हमेशा पूर्ण कार्यक्रमों की आवश्यकता के बजाय स्टैंडअलोन कार्यों के लिए अनुमति देते हैं।

— एलेक्स ए।

8

पायथ, 14 11 10 बाइट्स

hM_BS^I#1Q

इसे ऑनलाइन आज़माएं। परीक्षण सूट।

व्याख्या

Q: मूल्यांकित इनपुट
#: उस पर फ़िल्टर करें:
- I: मूल्य के बाद एक ही जा रहा है:
  - ^…1 इसे बढ़ाकर सत्ता में 1
S: उस तरह
_B: सरणी बनाएँ [previous, reversed(previous)]
hM: उस के प्रत्येक आइटम का पहला आइटम ले लो

सबसे मुश्किल हिस्सा स्ट्रिंग्स को हटाने के लिए गोल्फ है, जो वर्तमान में 4 बाइट्स लेता है। ^<str>1अनुक्रम के पहले कार्टेशियन शक्ति (मूल रूप से, स्ट्रिंग के पात्रों की सूची) को लेने के कारण वर्तमान दृष्टिकोण काम करता है , लेकिन ^<int>1सिर्फ पहचान समारोह है।

— PurkkaKoodari
स्रोत

एचआरएम, आप *#_1Qस्ट्रिंग्स को हटाने के लिए भी उपयोग कर सकते हैं, जो छोटा होगा यदि एक वेरिएबल को ऋणात्मक से प्रारंभ किया गया था ...

— FryAmTheEggman

7

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

पायथन 2 में, पूर्णांक हमेशा तुलना के दौरान तार से कम होते हैं, इसलिए एक साधारण min(s)से सबसे छोटा पूर्णांक मिलेगा। हालांकि अधिकतम पता करते समय, हमें पहले तारों को फ़िल्टर करना होगा। अनाम फ़ंक्शन एक अनुक्रम स्वीकार करता है और न्यूनतम और अधिकतम के साथ एक टपल लौटाता है।

lambda s:(min(s),max(x for x in s if''>x))

उदाहरण:

[1,'77', 6, '', 4] -> (1, 6)

— तर्क नाइट
स्रोत

3

lambda a:उससे पहले आपको एक अटक की जरूरत है।

— दरवाज़े

if x>0या if''>xएक बाइट बचाओ।

— GRC

@Doorknob, अब सुझाव के अनुसार लंबोदर।

— नाइट

1

@ डेनिस, मुझे इसकी जानकारी नहीं थी। मैंने यह स्पष्ट करने के लिए समाधान को संपादित किया है कि तुलना केवल पायथन 2 में काम करता है।

— लॉजिक नाइट

1

बिल्डिंग अप: lambda s:(min(s),-min(-1*_ for _ in s))(39 बाइट्स)

— फ्रेंक बोरसिक

7

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

|f¹Ṣ0,1ị

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

पृष्ठभूमि

एक आदर्श दुनिया में, यह स्वयं के चपटा संस्करण के साथ सूची को काटना होगा। स्ट्रिंग्स बस जेली में पात्रों की सूची है, इसलिए जब मूल सूची में पूर्णांक और तार होंगे, तो चपटे संस्करण में पूर्णांक और वर्ण होंगे, जिसमें केवल पूर्णांक को चौराहे पर छोड़ दिया जाएगा।

वास्तविक दुनिया में, इनपुट और स्ट्रिंग शाब्दिक दोनों के पार्सर्स लंबाई के तारों के बजाय वर्णों का उत्पादन करते हैं। एक फ़ंक्शन के लिए सिंगलटन स्ट्रिंग पास करने का एकमात्र तरीका इसे "मैन्युअल रूप से" के रूप में एन्कोड करना होगा, जैसे [”a], जो एक है एक सरणी में लिपटे चरित्र।

यह कुल 7 बाइट के लिए एक बाइट को बचाएगा, ( इसे ऑनलाइन आज़माएं! )।

fFṢ0,1ị

चूंकि यह संभवतः स्वीकार्य नहीं है, इसलिए हमें पूर्णांकों से वर्णों को अलग करने का एक तरीका भी चाहिए।

जेली के बिटवाइज़ परमाणु अपने तर्कों को पूर्णांकों में बदलने ~~की पूरी~~ कोशिश करते हैं। वे वेक्टराइज़ करके शुरू करते हैं जब तक कि वे गहराई 0 (संख्या या वर्ण) के प्रकार का सामना नहीं करते हैं, फिर उन्हें पूर्णांक में बदलने का प्रयास करते हैं। एक वर्ण जो पूर्णांक का प्रतिनिधित्व करता है, उसके लिए यह सफल होगा। दूसरों के लिए, एक डाइएडिक, बिटवाइज़ परमाणु बस छोड़ देगा और 0 लौटाएगा ।

उदाहरण के लिए, बिटवाइंड ओरिंग लिस्ट [1, "2", "34", "-5", "a", "bc"]अपने आप निकलेगी

[1, 2, [3, 4], [0, 5], 0, [0, 0]]

परिणाम को मूल सूची के साथ जोड़कर, हम उन सरणियों और पूर्णांक से छुटकारा पा लेते हैं जो मूल सूची में मौजूद नहीं थे।

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

|f¹Ṣ0,1ị  Main link. Input: A (list)

|         Bitwise OR the list A with itself.
 f¹       Filter the result by presence in A.
   Ṣ      Sort the resulting list of integers.
    0,1ị  Retrieve the elements at those indexes.
          Indices are 1-based and modular in Jelly, so 0 is the last (maximum),
          and 1 is the first (minimum).

— डेनिस
स्रोत

6

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

MinMax@*Select[#>0&]

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

MinMax@*Select[#>0&]@{1,2,3,4,"5"}
(* {1,4} *)

— njpipeorgan
स्रोत

1

वहाँ क्यों है *? ऐसा लगता है कि आप इसे काट कर सिर्फ 19 को प्राप्त कर सकते हैं।

— एक सिमंस 12

1

@ASimmons यह आवश्यक है। MinMax@Select[#>0&]एक वैध शुद्ध कार्य नहीं है।

— njpipeorgan

1

@ASimmons @*फ़ंक्शन रचना है, जबकि @फ़ंक्शन एप्लिकेशन है।

— मार्टिन एंडर

1

MinMax@Select[# > 0 &][{1, 2, 3, 4, "Hello", 5}]एक सही प्रतिक्रिया देता है

— A Simmons

1

@ASimmons MinMax@Select[# > 0 &]किसी प्रतीक को असाइन करने का प्रयास करें , या बस इसका मूल्यांकन करें।

— njpipeorgan

6

रूबी, 57 36 29 बाइट्स

यहाँ नौसिखिया, इसलिए मुझे नहीं पता कि बाइट्स की गणना के लिए कोई मानक या सार्वभौमिक रूप से स्वीकृत जगह / तरीका है, किसी भी मदद की बहुत सराहना की जाएगी!

मैनटवर्क और Doorknob की टिप्पणी के अनुसार संपादित!

->n{(n.map(&:to_i)&n).minmax}

परीक्षा

2.3.0 :076 > f=->n{[(n.map(&:to_i) & n).min, (n.map(&:to_i) & n).max]}
 => #<Proc:0x007ff7650ee868@(irb):76 (lambda)>
2.3.0 :077 > f[[7, 8, 10, "Hello", 5, 5]]
 => [5, 10]

— निरंजन पोखरेल
स्रोत

1

36 वर्ण:->n{[(x=n.map(&:to_i)&n).min,x.max]}

— मैनेटवर्क

2

29 बाइट्स, minmax का उपयोग कर:->a{(a.map(&:to_i)&a).minmax}

— दरवाज़े

5

सीजाम, 15 13 बाइट्स

{_:z&$2*_,(%}

एक अनाम ब्लॉक (फ़ंक्शन) जो स्टैक पर इनपुट सरणी की अपेक्षा करता है और आउटपुट सरणी को उसके स्थान पर छोड़ देता है।

सभी परीक्षण मामलों को चलाएं।

व्याख्या

_     e# Duplicate.
:z    e# Map over list: a) take abs() of integer elements (a no-op) or b) wrap strings
      e# in an array.
&     e# Set intersection: only the integers will appear in both arrays.
$     e# Sort.
2*    e# Repeat array twice (to make the code work with single-integer input).
_,    e# Duplicate, get length N.
(%    e# Decrement, get every (N-1)th element, i.e. the first and the last.

— मार्टिन एंडर
स्रोत

मैंने e) और e पर मुकदमा किया (to aditsu।) उन्होंने स्वीकार नहीं किया है कि

— username.ak

@ username.ak मुझे नहीं लगता कि वे वास्तव में उपयोगी हैं। एक दो-चार ऑपरेटर को जोड़ना जो वर्तमान समाधान पर केवल एक बाइट बचाता है, कुछ ऐसा नहीं है जिसे लागू करने की संभावना है, और मुझे यह भी लगता है कि उन लोगों के लिए उपयोग करने के लिए अधिक उपयोगी सुविधाएँ होनी चाहिए।

— मार्टिन एंडर

यह 3 बाइट्स बचाएगा:q~_e(ae)a+

— username.ak

@ username.ak खैर कि यह सोचते है कि e(और e)तार या कुछ और पर ध्यान न दें, जो असंगत लगता है। और अगर यह तार के साथ तुलना को शामिल किया था यह शायद एक ही तरीका है कि विफल हो जाएगा $और e>तार के साथ पूर्णांकों तुलना नहीं कर सकते।

— मार्टिन एंडर

5

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

f x=[minimum,maximum]<*>[[i|Left i<-x]]

हास्केल में किसी सूची के सभी तत्वों को एक ही प्रकार का होना चाहिए, इसलिए मैं मिश्रण नहीं कर सकता Integerऔर String। हालाँकि, Eitherदो प्रकारों को एक ही में मिलाने का प्रकार है। इनपुट सूची इसलिए टाइप Either Integer String^{1 की है} । fइंटेगर को फ़िल्टर करता है, Eitherरैपर को हटाता है , सूची को एक नए सूची (उदाहरण [[1,2,3]]) में एकल तत्व के रूप में रखता है , ताकि <*>पहले तर्क में दिए गए कार्यों को लागू कर सके।

प्रयोग उदाहरण: f [Left 1, Left 3, Right "Hello", Left 2]-> [1,3]।

संपादित करें: @xnor ने <*>खेल में लाया और 2 बाइट्स बचाए। धन्यवाद!

¹ वास्तव में यह दूसरे प्रकार में पूरी तरह से बहुरूपी है क्योंकि Stringसंपत्ति का उपयोग कभी नहीं किया जाता है।

— nimi
स्रोत

पैटर्न मैच के साथ अच्छा विचार है। आप दो f x=[minimum,maximum]<*>[[i|Left i<-x]]

— चार्ट

@xnor: बहुत अच्छा। आपका बहुत बहुत धन्यवाद!

— nimi

5

jq, 21 अक्षर

[.[]|numbers]|min,max

नमूना रन:

bash-4.3$ bin/jq '[.[]|numbers]|min,max' <<< '[7, 8, 10, "Hello", 5, 5]'
5
10

ऑन-लाइन परीक्षण:

— आदमी काम पर है
स्रोत

4

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

MinMax[#/._String->Nothing]&

— एक सीमन्स
स्रोत

मैं अब भी आपके जुनून को नहीं समझता Nothing... इसका कोई खास मतलब नहीं है ... इसके अलावा, 23 बाइट्स के लिए:MinMax@*Select[NumberQ]

— LegionMammal978

@ LegionMammal978 "सभी पूर्णांक सकारात्मक हैं" का उपयोग करें! मेरा जवाब देखिए।

— njpipeorgan 11

1

अच्छा समाधान दोस्तों, मुझे ऐसा करने के बारे में सोचना चाहिए था! @ LegionMammal978, Nothingका एक विशेष अर्थ है। 10.2 गणित के बाद से, यह स्वचालित रूप से सूचियों से हटा दिया जाता है।

— एक सीमन्स

@ LegionMammal978 Nothingनवीनतम संस्करणों में एक प्रलेखित कार्य है।

— श्री। छिपकली

4

PHP, 50 48 बाइट्स

<?=min($a=array_filter($a,is_int)).', '.max($a);

— PaulSkinner
स्रोत

1

मुझे 2 मिनट से हराया :)।

— टीएमएच

2

यह आम तौर पर माना जाता है कि इनपुट पहले से ही चर में है। वैसे, आप 'आसपास को हटाकर दो बाइट्स बचा सकते हैं is_int।

— ब्लैकहोल

@ ब्लेकहोल धन्यवाद। एहसास नहीं हुआ। मैंने आपके उद्धरण हटाने का उपयोग किया है :)

— पॉलस्किनर

4

रेटिना , 71

गोल्फ की मदद के लिए @ (मार्टिनबटनर को) हमेशा की तरह धन्यवाद।

प्रतिस्पर्धी गोल्फ-वार नहीं, लेकिन रेटिना में पूर्णांक बबल सॉर्टिंग को लागू करने के लिए इसका दिलचस्प।

मान लें कि इनपुट में सभी स्ट्रिंग्स "डबल-कोटेड हैं और किसी भी बची हुई डबल कोट्स को शामिल नहीं करते हैं \"।

A`"
¶

\d+
$&$*a $&$*a
+`\b(a+) +\1(a+)\b
$1$2 $1
 +[a ]+ +

(a)+
$#1

इनपुट न्यूलाइन-सेपरेटेड है।

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

— डिजिटल आघात
स्रोत

मुझे लगता है कि <space>.*<space>लालच के कारण आप दूसरे से अंतिम चरण में उपयोग कर सकते हैं ।

— FryAmTheEggman

4

गणितज्ञ , १४

#&@@@MinMax@#&

उदाहरण:

tests = {
   {1, 2, 3, 4, 5, 6, 7, 8},
   {5, 4, 2, 9, 1, 10, 5},
   {7, 8, 10, "Hello", 5, 5},
   {1, 2, 3, 4, "5"},
   {1},
   {"1", "2", "3", "4", 5}
 };

# & @@@ MinMax@# & /@ tests

{{1, 8}, {1, 10}, {5, 10}, {1, 4}, {1, 1}, {5, 5}}

स्पष्टीकरण:

जब MinMaxगैर-संख्यात्मक इनपुट प्राप्त होता है तो यह समस्या को कम कर देता है जहाँ तक यह हो सकता है, तब इसमें लिपटे हुए शब्दों को छोड़ देता है ( Minऔर Max:

MinMax @ {7, 8, 10, "Hello", 5, 5}

{Min[5, "Hello"], Max[10, "Hello"]}

स्वत: आदेश देने के कारण जो तार लेता है, पूर्णांक का अनुसरण करता है।

Applyपर levelspec {1}, आशुलिपि @@@, तो गैर-परमाणु तत्वों का पहला तर्क को खींचने के लिए प्रयोग किया जाता है। ध्यान दें कि 5यहाँ अछूता है:

foo @@@ {5, Max[10, "Hello"]}

{5, foo[10, "Hello"]}

— Mr.Wizard
स्रोत

3

Oracle SQL 11.2, 189 बाइट्स

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i))FROM(SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i FROM DUAL CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2)WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

संयुक्त राष्ट्र के golfed

SELECT MIN(TO_NUMBER(i)),MAX(TO_NUMBER(i)) 
FROM  (
        SELECT REGEXP_SUBSTR(:1,'[^,]+',1,LEVEL)i 
        FROM   DUAL 
        CONNECT BY LEVEL<REGEXP_COUNT(:1,',')+2
      )
WHERE TRIM(TRANSLATE(i,' 0123456789',' '))IS NULL;

उप-क्वेरी सरणी को पार्स करती है और इसे प्रति पंक्ति एक तत्व के साथ दृश्य को पॉप्युलेट करने के लिए विभाजित करती है। फिर गैर-संख्यात्मक तत्वों को फ़िल्टर किया जाता है।

काश, मुझे इसे LEAST और GREATEST के साथ करने का एक तरीका मिल जाता, लेकिन एक पैरामीटर के रूप में सरणी को कैसे संभालना है, इसके साथ कोई भाग्य नहीं।

— Jeto
स्रोत

यदि आप []सरणी के पहले या अंतिम तत्व हैं, तो आप सरणी में जा रहे हैं, इसलिए आप अधिकतम या मिनट का चयन नहीं कर रहे हैं। आपको अपने WHERE क्लॉज़ की भी आवश्यकता नहीं है, आप पहले से ही समुच्चय का चयन कर रहे हैं ताकि आपको फ़िल्टर करने की आवश्यकता न हो। अपने रेगीज़ में सांख्यिक वर्णों की खोज करें और संख्या-रूपांतरण को उप-क्वेरी के लिए नीचे धकेलें (बहुत कम खतरे की आशंका है) और यह 126 बाइट्स बन जाता है:

select min(i),max(i)from(select to_number(regexp_substr(&1,'\d+',1,level))i from dual connect by level<=regexp_count(&1,'\d'))

— बेन

+यहाँ दूसरी रेगेक्स में कोई ज़रूरत नहीं है क्योंकि इससे कोई फर्क नहीं पड़ता कि आप कुछ अतिरिक्त पंक्तियाँ बनाते हैं (बाइट बचाता है)। हालांकि यह भी ध्यान देने योग्य है कि अगर आपके पास एक स्ट्रिंग है जो पूरी तरह से संख्याओं से बनी है तो आप इसे यहां अनदेखा नहीं करेंगे; एक ही पैकेज में अतिभारित कार्यों की आवश्यकता होती है, इसलिए यह बिल्कुल सुंदर नहीं है।

— बेन

3

विम्सस्क्रिप्ट, 25 बाइट्स

g/"/d
sort n
t.
t.
2,$-1d

हाँ, यह सही है, vimscript है।

प्रपत्र में इनपुट की अपेक्षा करता है

और फॉर्म में आउटपुट

1
4

स्पष्टीकरण:

g/"/d    delete all lines that contain quotes
sort n   sort numerically
t.       duplicate the first line
t.       duplicate it again
2,$-1d   delete from line 2 to line (END-1)

एकल पंक्ति के इनपुट के किनारे के मामले को संभालने के लिए पहली पंक्ति को दो बार दोहराया जाना चाहिए । ऐसा इसलिए है क्योंकि अंतिम कमांड शिकायत करेगा यदि पहुंचते समय केवल दो लाइनें हैं, क्योंकि यह समाप्त हो रहा है 2,1dजो एक बैकवर्ड रेंज है।

— Doorknob
स्रोत

3

पर्ल 44 39 + 3 = 41 बाइट्स

@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"

-paझंडे की आवश्यकता है :

$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 5 4'
1 5
$ perl -pae'@a=sort{$a-$b}grep!/"/,@F;$_="@a[0,-1]"' <<< '1 2 3 4 "5"'
1 4

कुछ बाइट्स बंद करने के लिए @manatwork का धन्यवाद

— andlrc
स्रोत

कौन सा पर्ल संस्करण? आपके दूसरे उदाहरण के लिए मुझे अलग परिणाम मिले: pastebin.com/judJys5g

— manatwork

@manatwork आप सही हैं, चित्र I को नहीं हटा सकते हैंsort{$a-$b}grep...

— andlrc

आवश्यकता यह नहीं बताती है कि आउटपुट को बिल्कुल उदाहरणों में स्वरूपित किया जाना है और इस कार्य में स्पष्ट रूप से स्वरूपण बिंदु नहीं है। हम में से कई लोगों ने सिर्फ अपनी पसंद की भाषा में जो इस्तेमाल किया है, वह है। पर्ल में मैं इसे इस तरह से करूंगा $_="@a[0,-1]":।

— मैनटवर्क

एक वर्ण छोटा फ़िल्टरिंग grep!/"/:।

— मैनटवर्क

यह कहता है कि सरणी संख्या और स्ट्रिंग्स होगी। प्रश्न में सभी उदाहरण दोहरे-उद्धृत स्ट्रिंग्स के साथ हैं, लेकिन मुझे यह कहते हुए कुछ भी दिखाई नहीं देता कि वे एकल-उद्धृत नहीं हो सकते। मुझे लगता !/\D/है कि इसके बजाय आवश्यक है !/"/, एक और बाइट के लिए।

— msh210

3

जूलिया, 35 बाइट्स

x->extrema(filter(i->isa(i,Int),x))

यह एक लंबोदर फ़ंक्शन है जो किसी सरणी को स्वीकार करता है और पूर्णांकों का एक टपल लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

जूलिया में extremaएक ट्यूपल के रूप में एक सरणी के न्यूनतम और अधिकतम तत्व प्राप्त करने के लिए एक अंतर्निहित फ़ंक्शन है । हालांकि, चूंकि सरणी में तार भी हो सकते हैं, इसलिए हमें पहले उन लोगों को फ़िल्टर करना होगा। हम परीक्षण कर सकते हैं कि क्या प्रत्येक तत्व एक पूर्णांक का उपयोग कर रहा है isa।

— एलेक्स ए।
स्रोत

3

जाप, 23 बाइट्स

[V=Uf_bZÃn@X-Y})g Vw g]

इसे ऑनलाइन टेस्ट करें!

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

[V=Uf_  bZÃ n@  X-Y})g Vw g]
[V=UfZ{ZbZ} nXY{X-Y})g Vw g]

UfZ{ZbZ}   // Filter out the items Z in U where Z.b(Z) is falsy.
           // For numbers, this the original number, which is always non-0 (non-falsy).
           // For strings, this returns Z.indexOf(Z), which is always 0 (falsy).
nXY{X-Y}   // Sort by subtraction. Small items move to the front, large to the back.
V=         // Set variable V to the resulting array.
)g Vw g    // Take the first item in V, and the first in V.reverse().
[       ]  // Wrap them in an array so both are sent to output.

— ETHproductions
स्रोत

3

बैश, 40 31 30 बाइट्स

sort -n|sed /\"/d|sed '1p;$p;d'

एक अलग सूची की आवश्यकता है:

$ echo $'5\n4\n2\n9\n1\n"10"\n5' | sort -n|sed /\"/d|sed '1p;$p;d'
1
9

कुछ बाइट्स से दाढ़ी करने के लिए @manatwork का धन्यवाद

— andlrc
स्रोत

sed '1p;$p;d'एक बाइट बचाता है।

— डेनिस

3

पॉवरशेल, 53 36 बाइट्स

@($args[0]|?{$_-is[int]}|sort)[0,-1]

_{@ बोगी के लिए 17 बाइट्स का धन्यवाद}

OOOF ... पॉवरशेल आमतौर पर कास्टिंग के साथ बहुत तेज और ढीली खेलता है, जो आमतौर पर गोल्फिंग के लिए एक अच्छी बात है, लेकिन यहां दर्द होता है।

हमारे इनपुट को लेता है $args[0]और इसे एक Where-Objectस्टेटमेंट ( ?) में पाइप करता है जो केवल पूर्णांकों का चयन करेगा और उन्हें पाइप लाइन के साथ पास करेगा, और कुछ भी छोड़ देगा। चूंकि डायनामिक री-कास्टिंग आपके लिए पृष्ठभूमि में ऑन-द-फ्लाई होता है (उदाहरण के लिए, 1+"5"रिटर्निंग 6पूरी तरह से वैध है PowerShell), हमें डेटा प्रकारों के बीच अंतर करने के लिए -isऑपरेटर का उपयोग करने की आवश्यकता है ।

वहां से, हम उस संग्रह को पाइप करते हैं Sort-Object, जो पूर्णांकों को सबसे छोटे से सबसे बड़े तक छांटेगा। बाहरी ()आवश्यक है, इसलिए हम पहले और अंतिम तत्वों को संदर्भित कर सकते हैं [0,-1](जैसे, सबसे छोटा और सबसे बड़ा), लेकिन ध्यान दें कि हमें केवल एक ऑब्जेक्ट @के sortरूप में एक सरणी के आउटपुट को बाध्य करने के लिए बाहरी की आवश्यकता है (यदि परिणाम के रूप में) ?, या केवल एक ही वस्तु इनपुट) था।

— AdmBorkBork
स्रोत

1

यहां-is टाइप ऑपरेटर पर एक नज़र डालें । मुझे लगता है कि आप बदल सकते के साथ करने के लिए सेव 17 बाइट्स.GetType().Name-eq"Int32"-is[int]

— goric

@ भगदड़ सुपर कमाल! बड़े पैमाने पर गोल्फ के लिए धन्यवाद!

— AdmBorkBork

3

MATL , 23 बाइट्स

"@Y:tX%1)2\?x]N$htX<wX>

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

"       % implicitly input cell array. For loop that iterates on each cell
  @     %   push each cell
  Y:    %   cell's contents (either a number or a string)
  tX%   %   duplicate and push class. This will produce 'char'  or 'double'
  1)    %   get first letter: either 'c' or 'd'
  2\    %   is its ASCII code odd?
  ?     %   if so...
    x   %     delete (it's a string)
  ]     %   end if
  N$h   %   concatenate all stack into an array. This array will contain up to
        %   three numbers: minimum up to now, maximum up to now, new value (if any)
  tX<   %   duplicate. Push minimum
  wX>   %   swap. Push maximum.
        % implicitly end for
        % implicitly display stack contents

— लुइस मेंडो
स्रोत

ओह, मेरा बुरा: पी। हालांकि अच्छा जवाब :)

— अदनान

@ अदनान धन्यवाद! थोड़ा बहुत लंबा :-)

— लुइस मेंडो

2

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

function a(b){m=Math;b=b.filter(function(c){return c===+c});alert(m.min.apply(m,b)+','+m.max.apply(m,b))}

उपयोग: a([1,2,3,'4'])

सिर्फ कोशिश कर रहा हूं :)

"Ungolfed":

function a(b){
  m=Math;
  b=b.filter(function(c){
    return c===+c
  });
  alert(m.min.apply(m,b) + ',' + m.max.apply(m,b))
}

— एलेक्स
स्रोत

2

अजगर, 11 बाइट्स

hJSf!>TkQeJ

स्पष्टीकरण:

   f    Q   - filter([V for T in >], Q)
    !>Tk    - not(T>"")
  S         - sorted(^)
hJ       eJ - print first and last element

यहाँ यह कोशिश करो!

— नीला
स्रोत

2

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

स्पष्ट उत्तर यह होगा जो कुछ भी लांबाडा होगा

*.grep(Int).minmax.bounds

अगर इसे पूरा कार्यक्रम बनाना है

put get.words».&val.grep(Int).minmax.bounds

इस पूर्ण कार्यक्रम के लिए इनपुट मानों की एक अलग सूची है

प्रयोग

# give it a lexical name
my &code = *.grep(Int).minmax.bounds;

say code [1, 2, 3, 4, 5, 6, 7, 8];  # (1 8)
say code [5, 4, 2, 9, 1, 10, 5];    # (1 10)
say code [7, 8, 10, "Hello", 5, 5]; # (5 10)
say code [1, 2, 3, 4, "5"];         # (1 4)
say code [1];                       # (1 1)
say code ["1", "2", "3", "4", 5];   # (5 5)

say code []; # (Inf -Inf)

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

S, 16 चार्ट / 20 बाइट्स

[МƲ(ï⇔⒡≔=+$⸩,МƵï

Try it here (Firefox only).

बुरा नहीं बुरा नहीं...

व्याख्या

यह अधिकतम और न्यूनतम दोनों युक्त सरणी को आउटपुट करता है। (ï⇔⒡≔=+$⸩,मूल रूप से इनपुट में सभी स्ट्रिंग्स को फ़िल्टर करता है, इनपुट МƲमें अधिकतम प्राप्त करता है, और МƵन्यूनतम प्राप्त करता है।

बस एक नोट: यह पहली चुनौती है, जहां मुझे उपयोग करना है ⇔, जो मूल रूप से बदल जाता ï⇔है ï=ï।

— मामा फन रोल
स्रोत

2

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

lambda x:[m(t for t in x if str(t)!=t)for m in(min,max)]

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

— डेनिस
स्रोत

2

APL (Dyalog) , 13 बाइट्स

(⌊/,⌈/)⎕AV~⍨∊

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

∊ enlist (समतल - यह बड़ी सूची में वर्णों के सभी तार बनाता है)

⎕AV~⍨A टोमिक V ector में सभी वर्णों को हटाएं (वर्ण सेट - संख्याएं छोड़ता है)

(… ) निम्नलिखित टैसिट फ़ंक्शन लागू करें:

⌊/ न्यूनतम पार

, के लिए संलग्न है

⌈/ भर में अधिकतम

— एडम
स्रोत

2

जावा (ओपनजेडके 8) , 124 बाइट्स

a->{int s[]={0,0},t;for(Object i:a)try{t=(int)i;s[0]=s[0]<1|t<s[0]?t:s[0];s[1]=s[1]<t?t:s[1];}catch(Exception e){}return s;}

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

जावा 8 लंबो फ़ंक्शन, इनपुट के रूप में सरणी लेता है और सरणी देता है {min, max}। गैर-प्रतिस्पर्धात्मक, क्योंकि इनपुट को एक पूर्णांक सरणी होना चाहिए।

केविन क्रूज़सेन के लिए फिक्स्ड और -1 बाइट धन्यवाद

— HyperNeutrino
स्रोत

आप वस्तुओं की सूची लेकर और यह जांच कर सकते हैं कि कोई वस्तु पूर्णांक या स्ट्रिंग है या नहीं।

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

@ केविनक्रूजसेन ने किया, धन्यवाद

— हाइपरनेट्रिनो

<iअब पूर्णांक-कास्ट के बिना एक त्रुटि देता है। इसके अलावा, अपने प्रारंभिक कोड (और साथ ही यह एक) के लिए काम नहीं करता है min, क्योंकि यह हमेशा उत्पादन होगा 0के लिए min। यहाँ एक संभावित फिक्स है। संपादित करें: प्रयास करें-पकड़ 1 बाइट कम हो रहा है की तुलना में if(i instanceof Integer)।

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

@KevinCruijssen ओह ने ध्यान नहीं दिया कि, धन्यवाद!

— HyperNeutrino

1

जोल्फ, 20 बाइट्स

मैं शायद इसे गोल्फ कर सकता हूं ... मुझे टाइप-चेकिंग छोटे समाधानों को लागू करने की आवश्यकता है।

γ fxd='nF~tH0ͺZkγZKγ
 _fx                 filter the input
    d='nF~tH0        checking for number type
γ                    call that "γ"
             ͺ       pair
              ZkγZKγ  the min and max of the array

— कोनोर ओ ब्रायन
स्रोत

किसी सरणी में सबसे बड़ी और सबसे छोटी संख्या ज्ञात कीजिए

काम

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

नियम

गंभीरता से, ९ ६ बाइट्स

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

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

पायथ, 14 11 10 बाइट्स

व्याख्या

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

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

पृष्ठभूमि

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

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

रूबी, 57 36 29 बाइट्स

सीजाम, 15 13 बाइट्स

व्याख्या

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

jq, 21 अक्षर

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

PHP, 50 48 बाइट्स

रेटिना , 71

गणितज्ञ , १४

Oracle SQL 11.2, 189 बाइट्स

विम्सस्क्रिप्ट, 25 बाइट्स

पर्ल 44 39 + 3 = 41 बाइट्स

जूलिया, 35 बाइट्स

जाप, 23 बाइट्स

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

बैश, 40 31 30 बाइट्स

पॉवरशेल, 53 36 बाइट्स

MATL , 23 बाइट्स

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

अजगर, 11 बाइट्स

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

प्रयोग

S, 16 चार्ट / 20 बाइट्स

व्याख्या

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

APL (Dyalog) , 13 बाइट्स

जावा (ओपनजेडके 8) , 124 बाइट्स

जोल्फ, 20 बाइट्स