सबसे छोटा मिनमॉड फंक्शन

24

Minmod समारोह परिचित का एक संस्करण है मिनट है, जो आंशिक अंतर समीकरणों के लिए ढाल सीमित उच्च संकल्प योजनाओं में प्रकट होता है। कई ढलानों को देखते हुए, यह समतल ढलान को बाहर निकालता है, जबकि ढलानों के बीच सापेक्ष संकेतों का ध्यान रखता है।

फ़ंक्शन मापदंडों की एक मनमानी संख्या लेता है। फिर माइनमॉड (x 1 , x 2 , ..., x n ) को इस प्रकार परिभाषित किया गया है:

  • न्यूनतम (x 1 , x 2 , ..., x n ) , यदि सभी x i कड़ाई से सकारात्मक हैं
  • अधिकतम (x 1 , x 2 , ..., x n ) , यदि सभी x i कड़ाई से नकारात्मक हैं
  • ० , अन्यथा।

हम केवल पूर्णांक इनपुट पर विचार करेंगे, क्योंकि यह वास्तव में कार्यान्वयन को प्रभावित नहीं करता है और कुछ (गूढ़) भाषाओं के लिए अधिक समावेशी होना चाहिए।

एक प्रोग्राम या फ़ंक्शन लिखें, जो STDIN, ARGV या फ़ंक्शन तर्क के माध्यम से n हस्ताक्षरित पूर्णांक ( n> 0 के लिए ) लेता है (यदि आप एक सरणी का उपयोग कर सकते हैं यदि यह एक वैरेडिक फ़ंक्शन से अधिक सुविधाजनक है), और रिटर्न या प्रिंट (STDOUT के लिए) परिणाम की मिनमोड (ए, बी) ।

आपको बिल्ट-इन मिन या अधिकतम फ़ंक्शंस का उपयोग नहीं करना चाहिए (और जाहिर है, कोई बिल्ट-इन मिनमोड या तो, यदि आप वास्तव में पा सकते हैं)। इसके अलावा, आपको किसी भी निर्मित सॉर्टिंग फ़ंक्शन का उपयोग नहीं करना चाहिए, सिवाय आइटम की एक निश्चित छोटी संख्या (5 से कम) को सॉर्ट करने के लिए ।

यदि आपकी भाषा में हस्ताक्षरित प्रकार नहीं हैं, तो आप एक अहस्ताक्षरित प्रकार का उपयोग कर सकते हैं और इसे दो के पूरक के रूप में व्याख्या कर सकते हैं । उदाहरण के लिए यदि अपनी भाषा केवल अहस्ताक्षरित बाइट्स का उपयोग करता है, तो आप उपयोग कर सकते हैं 255के लिए में खड़े रहने के लिए -1और 128के लिए में खड़े रहने के लिए -128, आदि

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

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

Input          Output

2              2
-3             -3
0              0
3 -5           0
2 4 1          1
0 1 2          0
-1 1 2         0
-4 -2 -3 -2    -2
-5 0 -1        0
1 0 -1         0

लीडरबोर्ड

निम्नलिखित स्टैक स्निपेट एक नियमित लीडरबोर्ड और भाषा द्वारा विजेताओं का अवलोकन दोनों उत्पन्न करता है। यहां तक ​​कि अगर आपकी पसंद की भाषा आपको पूरी चुनौती जीतने नहीं देती है, तो दूसरी सूची पर स्पॉट छीनने की कोशिश क्यों न करें?

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

कोड स्निपेट दिखाएं

code-golf  math  restricted-source 
— मार्टिन एंडर
स्रोत
1
हो सकता है कि प्रत्येक भाषा में कितने उत्तर हों, इसके लिए एक कॉलम जोड़ें
— गर्वित हेकेलर
1
@proudhaskeller हम्म, मुझे यह पसंद है कि दो टेबल वर्तमान में स्निपेट पूर्ण स्क्रीन को खोले बिना एक-दूसरे के बगल में फिट हैं - मुझे लगता है कि अगर मैंने एक और कॉलम जोड़ा, तो यह थोड़ा बहुत crammed होगा। यदि आपकी टिप्पणी मेरी तुलना में काफी अधिक बढ़ जाती है, तो मैं देखूंगा कि मैं क्या कर सकता हूं। ;)
— मार्टिन एंडर
1
@ ऑप्टिमाइज़र मैंने तय किया कि नियमों का पिछला संस्करण लोगों के उत्तरों की रचनात्मकता को अधिक नुकसान पहुंचा रहा था, जैसा कि मैंने इरादा किया था। इसके अलावा, मैं उस उत्तर के लिए एक इनाम देने जा रहा था जो वैसे भी नियम बदलने से पहले अग्रणी था, इसलिए मुझे नहीं लगता कि प्रतिनिधि के संदर्भ में कोई नुकसान हुआ है। (हां, मैं मानता हूं कि नियम में बदलाव इतना अच्छा विचार नहीं है, लेकिन मुझे लगा कि यह इस मामले में इसके लायक होगा।)
— मार्टिन एंडर
1
@ MartinBüttner - मुझे अब नए उत्तरों में कोई रचनात्मकता नहीं दिख रही है। यह सब एक जोड़ीदार मिनीमॉड को कम करने के लिए नीचे आया है। रचनात्मकता xnor के उत्तरों या मिग के दृष्टिकोण पर थी, जिस पर कई अन्य उत्तर प्रभावित होते हैं।
— ऑप्टिमाइज़र
2
@ ऑप्टिमाइज़र, यह बताना हमेशा संभव नहीं होता है कि क्या एक नया उत्तर वास्तव में एक पुराने के समान रचनात्मक है जो कि इसके समान है या क्या यह एक अकल्पनीय बंदरगाह है।
— पीटर टेलर

जवाबों:

13

GolfScript, 10 9 बाइट्स

~{0]$1=}*

प्रारूप में स्टडिन से इनपुट ग्रहण करता है [-4 -2 -3 -2]

यह अंतर्निहित सॉर्ट फ़ंक्शन का उपयोग करता है $, लेकिन हर बार इसे लागू करने पर यह 3 तत्वों की एक सरणी पर होता है, जिसकी अनुमति है।

ऑनलाइन डेमो

— पीटर टेलर
स्रोत
कूल, हमारे उत्तर 1 सेकंड से कम के हैं, जिसका अर्थ है कि मेरा उत्तर सबसे छोटा था। ;)
— टाइमटेक
1
+1, यह मेरे समाधान की तुलना में अधिक छोटा और होशियार है। (पीएस; यदि किसी को इसमें संदेह है, तो हाँ, यह समाधान सही है, और इसे प्रेरण द्वारा साबित करना काफी आसान है। पीटर का कोड बार-बार पिछले मिनमोड मूल्य, अगले इनपुट मूल्य और शून्य के मध्यांक की गणना करता है; एक परीक्षा संभावित मामलों से पता चलता है कि यह वास्तव में नए माइनोड मूल्य का लाभ देता है।)
— इल्मरी करोनें
क्या ... ठीक है, वहाँ हमेशा सामान की बहुत दुबला करने के लिए है: O
— TheBlastOne
24

मैथेमेटिका, 19 बाइट्स

Median[#~Riffle~0]&

मार्टिन ब्यूटनर को कोड और गोल्फिंग धन्यवाद।

यह एक अनाम शुद्ध फ़ंक्शन है जो इनपुट के रूप में पूर्णांकों की सूची में लेता है। जैसे चाहे आह्वान करें

Median[#~Riffle~0]&[{-2, -3, -2, -4}]

या इसी तरह चर के लिए बचाया।

कोड पहले इनपुट सूची के हर दो तत्वों के बीच एक शून्य को रिफल करता है, जो तत्वों के n-1बीच शून्य डालता है n। फिर, उत्तर का निर्माण करने के लिए माध्यक लेता है।

यह मिन-मॉड देता है क्योंकि यह प्रत्येक मामले को संभालता है:

  1. सभी संख्याएं सकारात्मक हैं, इस मामले में शून्य उनके नीचे हैं और मध्यमा सबसे कम सकारात्मक संख्या है।

  2. सभी संख्याएँ नकारात्मक हैं, इस स्थिति में शून्य उनके ऊपर हैं और माध्यिका सबसे कम ऋणात्मक संख्या है।

  3. एक सकारात्मक और नकारात्मक संख्या दोनों है, और इसलिए मध्य तत्व एक शून्य है।

यदि Mathematica रैखिक-समय चयन एल्गोरिथ्म का उपयोग करके अपने मंझले को लागू करता है , तो यह O (n) भी है।

— XNOR
स्रोत
11

हास्केल, 62 61 39 38 37 बाइट्स

f s=last[x|x<-0:s,and[x*x<=x*y|y<-s]]

कुछ तुलना जादू का उपयोग करके @ ज़र्गब के उत्तर *, अर्थात् x*x<=x*y।

x*x<=x*yकेवल जब सच है xऔर yएक ही हस्ताक्षर है और yके निरपेक्ष मूल्य बड़ा है। ध्यान दें कि जब xहै 0यह हमेशा सच है।

हम पाते हैं कि xपरिणाम iff उसमें शामिल किया जाता है s, और कहा कि सभी के लिए yमें s xके रूप में एक ही हस्ताक्षर है yऔर निरपेक्ष मूल्य में छोटा होता है। यदि कोई sपरिभाषा इस परिभाषा को संतुष्ट नहीं करती है , तो 0इसका परिणाम है।

fफिर sइसे संतुष्ट करने के लिए एक तत्व की खोज करके काम करता है , और 0डिफ़ॉल्ट के रूप में उपयोग करता है ।

* हालांकि वह इसका उपयोग उन कारणों के लिए नहीं कर रहा है जो मैं इसका उपयोग कर रहा हूं, और वह वास्तव में अब तक इससे छुटकारा पा चुका है

— गर्वित हेकलर
स्रोत
हास्केल के लिए दुर्लभ यह गोल्फ (और विडंबना यह है कि अभी भी पठनीय है)। इसे प्यार करना।
— इसियाह मीडोज
10

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

a=>a.reduce((p,c)=>p*c>0?p*p>c*c?c:p:0)
— माइकल एम।
स्रोत
1
इसे प्रेम करें। ES6 का अच्छा उपयोग।
— Qix
6

पायथन 2, 53

lambda l:reduce(lambda a,b:sorted([a,b,0])[1],l,l[0])

reduceदो-इनपुट मिन-मॉड खोजक को एक n-input में बदलने के लिए उपयोग करने के लिए विचार है । मैं इसे स्वतंत्र रूप से उपयोग करने वाले अन्य उत्तरों के साथ आया था। केवल पायथन 2 का समर्थन करता है reduce।

दो-इनपुट समाधान बस दो संख्याओं और शून्य के माध्य का पता लगाता है। देखो मेरामाध्यिका का उपयोग करने के अधिक प्रत्यक्ष तरीके के लिए गणितज्ञ उत्तर को ।

कम गोल्फ वाला:

def f(l):
 A=l[0]
 for x in l:A=sorted([a,b,0])[1]
 return A

अजगर 2 और अजगर 3 का एक काल्पनिक मिश्रण अजगर 3 और से तारांकित काम के साथ एक चरित्र कम, होगा input()और printअजगर 2 से।

#Not real code!
A,*l=input()
for x in l:A=sorted([A,x,0])[1]
print A

पुराना कोड, बिना छांटे:

lambda l:reduce(lambda a,b:[a,b][a*a>b*b]*(a*b>0),l,l[0])
— XNOR
स्रोत
हम्म, हां, मैंने इस बीच उस साइड-इफेक्ट पर ध्यान दिया, लेकिन मुझे ऐसा लगता है कि इसे ठीक करने में अब बहुत देर हो चुकी है। मैथेमेटिका में एक अंतर्निहित Medianहालांकि है।
— मार्टिन एंडर
आपका बाद वाला दृष्टिकोण अब भी मान्य है।
— मार्टिन एंडर
6

मारबेलस, 210 बाइट्स

@0
00
]]\\&002
/\..//&0@0
00..02
MMMMMM//\\
:M
}0}1}0}1}0}1}0}2..}2
^7^7||||&0&1&4<3&0=2{>
EqalLteq{0{<{<<2&1--
&2..&3..}100..&2\/{>
>0&6=0&4&5&6..\/
&3..&5\/{<{0
\/..\/
:|
}000}0
&0Subt
{0&1
}0{0
^7
=0&1
&0
\/

यहां तीन बोर्ड इस्तेमाल किए गए हैं।

|बोर्ड ( Abपठनीय संस्करण में) (या तो पारित कर दिया संगमरमर या शून्य शून्य से पारित कर दिया संगमरमर वापस लौट कर के रूप में Marbelous में सभी गणित अहस्ताक्षरित है) एक संगमरमर का निरपेक्ष मान लेता है।

Mबोर्ड ( Minabsपाता और बाईं या तो पहली या दूसरी संगमरमर से पारित कर दिया (जो भी एक छोटे निरपेक्ष मूल्य है), और अगर एक अलग हस्ताक्षर किए संगमरमर पारित हो जाता है बाहर निकलने के लिए आउटपुट पठनीय संस्करण में)।

Mबोर्ड भी संगमरमर नीचे के बजाय बाई ओर यह धारण विज्ञप्ति एक बार stdin से अंतिम वर्ण प्राप्त किया गया है।

Mबोर्ड किसी भी समय पर सभी की जाँच मूल्यों की minmod स्टोर करने के लिए, के रूप में यह जो फिर वापस सीधे रास्ते से फिर गया है मूल्य बाई ओर सहेजने के लिए, विज्ञप्ति मुख्य बोर्ड में प्रयोग किया जाता है।

ट्रैशबिन ( \/) को केवल सिंक्रनाइज़र के तहत रखा गया था जो अन्यथा STDIN पर प्रिंट होता था।

इनपुट / आउटपुट STDIN / STDOUT का उपयोग करता है। दोनों 8-बिट मूल्यों के साथ सौदा करते हैं (यदि आप + 0x30 और + 0x38 पास करना चाहते हैं, तो 08STDIN में रखें)।

पुस्तकालय और बेलनाकार बोर्ड दोनों आवश्यक हैं। दशमलव संख्याओं के रूप में आउटपुट देखने की सिफारिश की जाती है (ध्यान दें कि यह मिनमोड परिणाम के अहस्ताक्षरित मूल्य को प्रदर्शित करता है)।

इसका परीक्षण यहां करें।

नोट: अधिक मानव-अनुकूल इनपुट / आउटपुट के लिए, Dpमुख्य बोर्ड की अंतिम पंक्ति (पहले :M) के ]]साथ Rdजोड़ें, साथ बदलें , और नीचे निम्नलिखित जोड़ें:

:Rd
}0}0}0
]]]]]]{>
-O-O-O
-O-O-O
*A
Plus
\\*A
..Plus
..{0
:*A
}0}0
<<<<
<<
<<
Plus
{0

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

पठनीय संस्करण:

बोर्ड की तस्वीर

— es1024
स्रोत
5

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

यह संभवतः सबसे कम संभव हास्केल समाधान नहीं है (और निश्चित रूप से यहां दूसरों को नहीं हराएगा), लेकिन यह एक शुरुआत है। संपादित करें: अब 50% से अधिक कम! EDIT2: एक बाइट कम ...

a#b|a*b<0=0|a*a<b*b=a|1<2=b
m=foldr1(#)

यह सिर्फ एक सरल गुना है (या कम करने, कुछ भाषाओं इसे कहते हैं) द्विआधारी ऑपरेटर द्वारा #, जो की औसत की गणना करता है a, bऔर 0। भले ही नियम अब मुझे छोटी सूचियों को क्रमबद्ध करने की अनुमति देंगे, इसके लिए हास्केल में एक आयात की आवश्यकता है और एक उच्च बाइट गिनती ( 49 बाइट्स) में परिणाम होता है , लेकिन 31 आयात के बिना):

import Data.List
a#b=sort[a,b,0]!!1
m=foldr1(#)
— Zgarb
स्रोत
\a-> (signum a,a)signum>>=(,)फ़ंक्शन मोनड उदाहरण का उपयोग करने के समान है । (मेरी पोस्ट "
— हैस्केल
टिप के लिए धन्यवाद, लेकिन यह अब मूट है। :)
— ज़गरब
@Zgarb आह ठीक है।
— ऑप्टिमाइज़र
5

टीआईएस -100, 696 526 बाइट्स

@1
MOV UP ACC
SAV
ADD 999
JEZ A
SWP
MOV 1 ANY
MOV ACC ANY
JRO -7
A:MOV 12 ANY
@5
S:JRO UP
MOV UP ACC
JLZ A
JEZ B
MOV 1 DOWN
JMP B
A:MOV 7 DOWN
NEG
B:MOV 1 RIGHT
MOV ACC RIGHT
MOV ACC RIGHT
JMP S
MOV 14 DOWN
MOV 9 RIGHT
@6
MOV 999 ACC
L:JRO LEFT
SAV
SUB ANY
JGZ A
MOV ANY NIL
SWP
JMP L
A:MOV ANY ACC
JMP L
MOV ACC ANY
@9
S:JRO UP
JEZ A
SUB 1
JEZ A
JMP X
A:MOV 1 ACC
JMP S
JEZ B
SUB 2
JEZ B
X:MOV 6 ACC
JMP S
B:MOV 2 ACC
JMP S
MOV ACC ANY
@10
MOV LEFT ACC
ADD 1
JRO ACC
JRO 6
MOV UP ANY
MOV UP ACC
NEG
MOV ACC ANY
!NOP
MOV 0 ANY

अनुक्रम द्वारा समाप्त किए जाने की अपेक्षा करता है -999। टीआईएस -100 इस सवाल से नया है, लेकिन यह वैसे भी यहां मायने नहीं रखता।

नोड 9 इस बात पर नज़र रखता है कि क्या हम सभी सकारात्मक, सभी नकारात्मक या मिश्रित हैं। नोड्स 5 और 6 सभी इनपुट संख्याओं के निरपेक्ष मान को खोजने के लिए काम करते हैं। नोड 10 तब नोड 9 की स्थिति के आधार पर न्यूनतम, न्यूनतम नकारात्मक या 0 का चयन करता है।

यहाँ छवि विवरण दर्ज करें

— Sp3000
स्रोत
मैंने TIO के लिए एक TIS एमुलेटर लागू किया है, इसलिए अब आप इसे ऑनलाइन आज़मा
— फेल्क्स
4

CJam, 20 बाइट्स (या 10 बाइट्स)

q~{]__~z\z<=\~*0>*}*

@ Xnor के दृष्टिकोण का उपयोग करते हुए, सरणी से एक बार में 2 नंबर की माइनमोड की गणना करना कम करें।

अगर :zकाम किया जाता तो यह 19 बाइट्स होती

लघु सरणियों पर प्रकारों के उपयोग के नए नियम का उपयोग करना:

q~{0]$1=}*

जो @ पीटर के उत्तर के बराबर है

पिछले 26 बाइट्स asnwer:

q~_{g}%_|:+\(z\{za+_~>=}/*

यह आगे गोल्फ हो सकता है ...

इनपुट (STDIN के माध्यम से) पूर्णांक सरणी है जैसे:

[-4 -2 -3 -2]

और आउटपुट इनपुट ऐरे की मिनमोड है

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

यदि केवल :gऔर :zकाम किया जाता है, तो यह 4 बाइट्स छोटा होता।

— अनुकूलक
स्रोत
25 बाइट्स: q~_{g}%_|:+\{z\za+_~>=}**।
— jimmy23013
एकल इंट सरणी के लिए विफल। मैंने इसे भी आजमाया :)
— ऑप्टिमाइज़र
हालांकि वहाँ एक 26 बाइट समाधान है। उसके लिए धन्यवाद :)
— ऑप्टिमाइज़र
4

जावा, 84 बाइट्स

यह अपनी सारी महिमा में जावा है। थोड़ा अधिक 900% के एक कारक द्वारा GolfScript धड़कता है।

int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

वर्ग में लिपटे:

public class MinModGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModGolfed().f(numbers));
    }

    int f(int[]a){int b=a[0],c;for(int d:a)b=(c=d<0?-1:1)*b<0?0:d*c<b*c?d:b;return b;}

}

टिप्पणियों के साथ विस्तारित:

public class MinModExpandedGolfed{

    public static void main(String[] args){
        int[] numbers = new int[args.length];
        for (int i = 0; i < args.length; i++){
            numbers[i] = Integer.parseInt(args[i]);
        }
        System.out.println(new MinModExpandedGolfed().f(numbers));
    }

    int f(int[]a){                  //a is the input numbers
        int b=a[0],c;             //b is the best number found so far.
        for(int d:a)               //Iterate over a with current element as d.
            b=(c=d<0?-1:1)         //c is equal to the sign of d.
                    *b<0?
                        0:          //If b has opposite sign of d, b = 0.
                        d*c<b*c?d:b;//If the absolute value of d is less than b, b = d. 
        return b;
    }

}

नोट: यह जावा 8 का उपयोग करके सुधार किया जा सकता है।

नोट: जावा 8 में सुधार करने का प्रयास विफल रहा।

— नंबर एक
स्रोत
मुझे अभी बहुत कुछ सीखना है। +1।
— रोडोल्फो डायस
4

जम्मू, 20 12 बाइट्स

सूची को तर्क के रूप में लेना। गोल्फस्क्रिप्ट / सीजेएम / जो भी हो, से चोरी।

(1{0/:~@,,)/

का माइनमोड xऔर तीन आइटम सूची yका माध्यिका (सॉर्ट /:~और बीच में लेना 1{) है 0,x,y। आसन्न तत्वों के बीच इस मिनीमॉड को ले जाकर सूची ( जे पार्लेंस में तह ) को कम करें ।

REPL में उपयोग में। (J इसके नकारात्मक चिन्ह को दर्शाता है _।)

   (1{0/:~@,,)/ _4 _2 _3 _2
_2
   f =: (1{0/:~@,,)/    NB. give it a name
   f 1 1 2
1
   f 0 1 2
0
   f _1 1 2
0

पुराने कचरा, इससे पहले मैंने देखा लघु प्रकार की अनुमति है: 0:`<.`>.@.(*@]*0<*))/के minmod xऔर y0 है ( 0:अगर 0 से अधिक है या के उत्पाद के बराबर) xऔरy , वरना यह मिनट (है<. ) या अधिकतम ( >.) के बीच xऔर yहस्ताक्षर के आधार पर । इसे पूरी सूची में मोड़ो।

— algorithmshark
स्रोत
4

TI-BASIC, 19 बाइट्स

प्रारूप में इनपुट मानता है {-2,4,3} ।

Xnor के उत्तर के समान कार्य करता है:

Input L₁              get user input into the L1 array
dim(L₁)2-1→dim(L₁     get the length of the array; multiply by 2 and subtract 1
                      make this the new length (new elements always default to 0)
median(L₁             calculate and return (since it's the last line) median of new array
— Timtech
स्रोत
3
कोड साइज गिनने का दिलचस्प तरीका ...
— Ypnypn
3
— मार्टिन एंडर
मेरा कोड, साथ ही median(augment(Ans,0ΔList(Ansकेवल आठ बाइट्स, आयाम एक की सूची में विफल रहता है। If variance(Ans:augment(Ans,0ΔList(Ans:median(Ansअब से तुम्हारा है। यदि केवल TI-BASIC ने खाली सूचियों का समर्थन किया है ...
— lirtosiast
तुम सही हो। ऐसा लगता है कि मेरा कोड आकार 12 से 15 बाइट्स तक है।
— टाइमटेक
मुझे लगता हे तुम सही हो। वहां +4 बाइट्स।
— टाइमटेक
3

पायथन 2, 82 79 71 69 61 बाइट्स

lambda l:reduce(lambda G,H:[H,G][(G>H)^(G>0)]*(G*H>0),l,l[0])

यह मेरे पाइथ के उत्तर पर आधारित है, जो मिग के द्वारा प्रेरित था उत्तर ।

पुराना उत्तर:

l=input()
m=l[0]
k=1-2*(m<0)
for i in l:m=[m,i][m>i*k]
print(k*m>0)*m

यह बहुत लंबा जवाब है। मुझे लगता है कि 2 चर एक बेकार है ...?मैं सही था...? ish? , पी

— FryAmTheEggman
स्रोत
3

KDB / Q, फ़ंक्शन बॉडी परिभाषा के लिए 43 वर्ण

पिछली पोस्ट के महान विचारों के लिए धन्यवाद:

f:{$[all 1_0<(*':)x;{$[<[x*x;y*y];x;y]}/[x];0]}

एनलिस्ट का उपयोग करके एकल नंबर दर्ज करें

f[enlist 2]
f[enlist 0]
f[enlist -2]
f[2 4 1]
f[0 1 2]
f[1 0 2]
f[-1 1 2]
f[-4 -2 -3 -2]
f[-5 0 -1]
f[-5 -0 -1]
f[1 0 -1]

मुझे यकीन है कि कुछ क्यू गुरु कम लोगों के साथ आ सकते हैं।

— space889
स्रोत
शायद कुछ पसंद है {asc[0,x,y]1}/?
— एल्गोरिथमशार्क
3

पायथ, २५ २२ २० १२

uhtS[0GH)QhQ

शायद उपन्यास नहीं, लेकिन मूल: पी

पूर्व-छँटाई की अनुमति है

u*?Gx>GH>G0H>*GHZQhQ

Pyth

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

मिग के जवाबreduce से बेतुके बयानों का उपयोग करने का विचार और बेशर्मी से चुराया गया था , लेकिन मुझे कोई विचार नहीं है अगर ये एल्गोरिदम भी समान हैं, जैसा कि मैं टर्नेरी स्टेटमेंट नहीं पढ़ सकता हूं।

स्पष्टीकरण:

Q=eval(input)         : implicit
u                QhQ  : print reduce(lambda G,H: ..., Q, Q[0])
 *          >*GHZ     : ... * (G*H>0)
  ?G       H          : G if ... else H
    x>GH>G0           : G>H xor G>0
— FryAmTheEggman
स्रोत
की कोई जरूरत नहीं tQ। Qकाम भी करेगा
— ऑप्टिमाइज़र
बिलकुल सही! मुझे यह भी लगता है कि मैं एक के ?लिए एक *...
— FryAmTheEggman
3

सी #, 101 बाइट्स

कोड गोल्फिंग में मेरा पहला प्रयास है और एक सुंदर गोल्फ की शत्रुतापूर्ण भाषा में। कम करने पर आधारित ( AggregateLINQ में) और मिग द्वारा जावास्क्रिप्ट जवाब के समान । की तरह चलाया जा सकता है (new System.Linq.M()).m(new[] {1, 2, 3})। सभी परीक्षण मामलों को पास करता है, लेकिन खाली इनपुट सरणियों को संभालता नहीं है।

namespace System.Linq{class M{public int m(int[]i){return i.Aggregate((a,b)=>a*b>0?a*a<b*b?a:b:0);}}}
— जैकब बुंडगार्ड
स्रोत
1
खाली इनपुट को संभालने की कोई आवश्यकता नहीं है, क्योंकि मैंने उस मामले के लिए फ़ंक्शन को परिभाषित नहीं किया था।
— मार्टिन एंडर
3

जे, 12 बाइट्स

   (=&**>&|{,)/

फ़ंक्शन /अभिव्यक्ति के साथ सूची ( जे में तह ) कहा जाता है :

(signum(x) == signum(y)) * [x,y][abs(x)>abs(y)] कहा पे

[x,y][abs(x)>abs(y)]है yअगर abs(x) > abs(y)किसी और x।

उदाहरण:

   (=&**>&|{,)/ 5 2 6
2

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

— randomra
स्रोत
2

गेम मेकर लैंग्वेज, 489 बाइट्स

गेम मेकर लैंग्वेज के बारे में

सरणी को बदल देता है (शून्य जोड़ दिया जाता है) और माध्य लौटाता है (मेरे अन्य उत्तर के समान)

i=0a=argument0
while(variable_local_array_get(a,i))i++
for(j=0;j++;j<i-1)a[j+i]=0var i,j,d,m=0d=ds_list_create()if variable_local_exists(a){if variable_local_array_get(a,0){for(i=0;i<32000;i++){if variable_local_array_get(a,i)=0break
ds_list_add(d,variable_local_array_get(a,i))}ds_list_sort(d,0)i=ds_list_find_value(d,ds_list_size(d) div 2)j=ds_list_find_value(d,(ds_list_size(d) div 2)-1)m=ds_list_find_value(ds,ds_list_size(d) mod 2)ds_list_destroy(d)}if m return (i+j)/2return i
break}
— Timtech
स्रोत
@ मार्टिनबटनर पहली 2.5 पंक्तियों में राइफल का प्रदर्शन करते हैं, और बाकी मंझला पाते हैं। 32000के रूप में सॉफ्टवेयर के द्वारा सीमित सरणी का अधिकतम आकार है।
— टाइमटेक
@ मार्टिनबटनर हां, मध्य भाग के भीतर, पूरी सूची को क्रमबद्ध नहीं किया गया है।
— टाइमटेक
@ मार्टिनबटनर इसे हर पुनरावृति के रूप में क्रमबद्ध करता है ... इसलिए 3
— टिमटेक
अच्छा ऐसा। इस तरह की चिंताजनक भाषा को पढ़ने के लिए यह कोड आश्चर्यजनक रूप से कठिन है। ^ ^
— मार्टिन एंडर
@ गोल्फ के लिए MartinBüttner यह बहुत अच्छा (बहुत ढीला सिंटेक्स) लेकिन यह कई मानक बिल्ट-इन कार्य (यह शामिल नहीं है है खेल डिजाइन की ओर उन्मुख)।
— टाइमटेक
2

जावा, 353 304 124 बाइट्स

दुनिया के सबसे बुरे गोल्फर के साथ कोड गोल्फ के लिए सबसे खराब भाषा को एक साथ रखें और आप प्राप्त करें ... 

int m(int[]a){int m=a[0];if(m<0)for(int i:a){m=(i>m)?i:m;m=(i>0)?0:m;}else for(int i:a){m=(i<m)?i:m;m=(i<0)?0:m;}return m;}}

इसे Ungolf करें और आप प्राप्त करें:

int m(int[] a) {
    int m = a[0];
    if (m < 0) {
        for (int i : a) {
            m = (i > m) ? i : m;
            m = (i > 0) ? 0 : m;
        }
    } else {
        for (int i : a) {
            m = (i < m) ? i : m;
            m = (i < 0) ? 0 : m;
        }
    }
    return m;
}

यह एक फ़ंक्शन है (यदि यह स्पष्ट रूप से बहुत स्पष्ट नहीं था), जो संख्याओं की एक सरणी प्राप्त करता है और अपने मूल्यों को संसाधित करता है, मिनमोड मान लौटाता है।

मेरी पुरानी बेनिमोथ भी शामिल है, जो एक संपूर्ण कार्यक्रम है - हमेशा की तरह।

class M{public static void main(String[]a){java.util.Scanner s=new java.util.Scanner(System.in);int n,m=0;try{m=s.nextInt();if(m<0)while(true){n=s.nextInt();m=(n>m)?n:m;m=(n>0)?0:m;}else while(true){n=s.nextInt();m=(n<m)?n:m;m=(n<0)?0:m;}}catch(java.util.InputMismatchException e){System.out.print(m);}}}

इसे Ungolf करें और आप प्राप्त करें:

class M {

    public static void main(String[] a) {
        java.util.Scanner s = new java.util.Scanner(System.in);
        int n = 0, m = 0;
        try {
            m = s.nextInt();
            if (m < 0) {
                do {
                    n = s.nextInt();
                    m = (n > m) ? n : m;
                    m = (n > 0) ? 0 : m;
                } while (true);
            } else {
                do {
                    n = s.nextInt();
                    m = (n < m) ? n : m;
                    m = (n < 0) ? 0 : m;
                } while (true);
            }
        } catch (java.util.InputMismatchException e) {
            System.out.print(m);
        }
    }
}

अनंत संख्या प्राप्त करता है, तब रुकता है जब एक गैर-संख्या मान दर्ज किया जाता है, मिनम मूल्य को प्रस्तुत करता है।

— रोडोल्फो डायस
स्रोत
आपका कोड पहले मान को छोड़ देता है, इसलिए यह उदाहरण के लिए गलत उत्तर देगा 1 2 3। आपको यह भी लगता है कि आप एक ऐसा कार्य लिख सकते हैं, जो एक ऐसे कार्यक्रम के बजाय इसके तर्कों को संसाधित करता है जो स्टड से पढ़ता है।
— पीटर टेलर
@PeterTaylor मूर्खतापूर्ण, मेरी पहली वृत्ति हमेशा एक पूर्ण कार्यक्रम लिखने के लिए होती है, भले ही यह कहा जाए कि यह एक फ़ंक्शन हो सकता है। उस बग के बारे में, जाहिरा तौर पर मैंने इसे पर्याप्त परीक्षण नहीं किया, चूहों। इसे अब ठीक करने की कोशिश करेंगे - और फंक्शन-वर्जन को भी बेहतर बनाएंगे ...
— रोडोल्फो डायस
2

आर, 20 वर्ण

आर आमतौर पर कोडगोल्फ के लिए अच्छा नहीं है, लेकिन मैं इसे अपने काम के लिए उपयोग करता हूं इसलिए मैं कोशिश करना चाहता था। इससे पहले कि मैं कोशिश करता, मुझे नहीं पता था कि आर इस तरह के एक गंदे वाक्य को स्वीकार करने को तैयार है! :-) 52 वर्ण :

if((q=summary(x))[6]<0)q[6]else if(q[1]>0)q[1]else 0

तब मैंने अन्य उत्तरों को देखा, मैंने @ xnor के जीनियन मेडियन ट्रिक की कोशिश की, जो बहुत अच्छा है!

median(c(x-x,x)[-1])
— टॉमस
स्रोत
आपका पहला संस्करण कैसे काम करता है? क्या करता summaryहै? कर रहे हैं q[1]और q[6]न्यूनतम और अधिकतम क्रमश:? उस स्थिति में, यह मान्य नहीं है, क्योंकि आप अंतर्निहित न्यूनतम / अधिकतम का उपयोग नहीं कर सकते हैं।
— मार्टिन एंडर
@ मार्टिनबटनर यह मूल रूप से क्वांटाइल्स और एक माध्य का एक वेक्टर प्रदान करता है। 1 और 6 0 और 1 मात्राएँ हैं। मैंने आपके नियमों के अनुसार, अंतर्निहित मिन / अधिकतम फ़ंक्शन का उपयोग नहीं किया है।
— टॉमस
2

पायथन, 52

मैं अभी भी यह महसूस करने में मदद नहीं कर सका कि दो lambdaएस होना बुरा है । यह फ़ंक्शन एक सूची में लेता है और फिर एक-तत्व सूची देता है जिसमें परिणाम होता है।

f=lambda a:a[1:]and[sorted([a.pop(),0]+f(a))[1]]or a

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

— feersum
स्रोत
1

मतलाब / ऑक्टेव, 26

यह मूल रूप से xnor द्वारा Mathematica उत्तर का अनुवाद है । यह इनपुट वेक्टर की लंबाई से कम एक शून्य जोड़कर काम करता है। ध्यान दें कि एक और को जोड़ने से काम नहीं चलेगा, तब से परिणाम हर समय 0 होगा। इस समाधान के -4 वर्णों के लिए मार्टिनबटनर का धन्यवाद =)

@(x)median([x,0*x(2:end)])
— flawr
स्रोत
@ मार्टिनबटनर आप बिल्कुल सही हैं। मैंने अब इसे बदल दिया: कार्यक्रम केवल एक शून्य इनपुट से कम संलग्न करेगा। इस तरह यह सुनिश्चित किया जाता है कि हमारे पास हमेशा विषम संख्या में तत्व होते हैं और मंझला बाकी चीजों की देखभाल करता है।
— दोष
या अपने पिछले समाधान से पिछले 0 पॉप।
— ऑप्टिमाइज़र
@ मार्टिनबटनर धन्यवाद, बिल्कुल बेहतर तरीका है। @ ऑप्टिमाइज़र आप ऐसा कैसे करेंगे?
— 13:
मुझे पता नहीं है। मैंने सोचा कि अंतिम तत्व को बस पॉप करने का एक तरीका होना चाहिए, कुछ ऐसा @(x)median([0*x,x](2:end))। हालांकि ऐसा लगता है कि इसकी बाइट्स अब जैसी हैं।
— ऑप्टिमाइज़र
@ ओप्टिमाइज़र मुझे पहले से ही लगता था कि मैंने मतलब की एक महत्वपूर्ण विशेषता याद कर ली =) यह बहुत बुरा है कि आपके द्वारा सुझाया गया अंकन काम नहीं करता है, यह कभी-कभी बहुत आसान होगा!
— दोष
1

अजगर, 72 60 बाइट्स

यह पहला उपाय है जिसके बारे में मैंने सोचा था, और यह काफी भोला है। दूसरी छमाही मूल रूप से कोड की पहली छमाही की नकल है, लेकिन मुझे यकीन नहीं था कि इसे कैसे पतला किया जाए। मुझे आश्चर्य है कि अगर इसे इस्तेमाल करके छोटा किया जा सकता हैeval ...

संपादित करें: परिवर्तन के लिए लंबोदा परिवर्तन।

उन्हें यहाँ की कोशिश करो

lambda l:min(l)*all(x>0for x in l)+max(l)*all(x<0for x in l)

यह केवल 4 वर्ण लंबा है, लेकिन अभी भी देखने के लायक है, Sp3000 के TIP का उपयोग कर रहा है ।

lambda l:eval("+m%s%s(l)*all(x%s0for x in l)"*2%tuple("ax<in>"))
— mbomb007
स्रोत
1

जावास्क्रिप्ट, 63

a=>a.reduce((p,c)=>p<0?c<0?Math.max(p,c):0:c>0?Math.min(p,c):0)

अधिक पठनीय संस्करण:

function (arr) {
    return arr.reduce(function (p, c) {
        if (p < 0) {
            if (c < 0) {
                return Math.max(p, c);
            } else {
                return 0;
            }
        } else {
            if (c > 0) {
                return Math.min(p, c);
            } else {
                return 0;
            }
        }
    });
}
— अफोंसो माटोस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.