संख्या के लिए निकटतम मान प्राप्त करें

Question

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

आउटपुट इनपुट के लिए निकटतम संख्या हो सकती है।

उदाहरण:

value: (Input) 5 --- [1,2,3] --- 3

और, प्रोग्राम नकारात्मक संख्याओं के साथ काम कर सकता है।

उदाहरण:

value: (Input) 0 --- [-1,3,5] --- -1


value: (Input) 2 --- [1, 5, 3] --- 1 (Because it gives priority to lower numbers)

नियम:

जैसा कि पहले उल्लेख किया गया है, इसे नकारात्मक संख्याओं के साथ काम करना होगा।

यदि दो उत्तर हैं (उदाहरण: 0 - [5, -5]), तो कार्यक्रम सबसे कम संख्या को प्राथमिकता देता है। (-5)

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

Comments

यह कम संख्या को प्राथमिकता देता है जिसका उल्लेख नियमों में किया जाना चाहिए।

— डेनिस

यदि लक्ष्य संख्या सूची में मौजूद है, तो क्या आउटपुट उस संख्या या सूची से निकटतम अन्य संख्या होना चाहिए?

— ट्राइकोप्लाक्स

मुझे पता है, स्वीकृत उत्तर लौकिक है।

— एलेक्सिनएफ

@ एलेक्स 82 निश्चित रूप से, आप जानते हैं कि यदि आप बेहतर उत्तर देते हैं तो आप स्वीकार किए गए उत्तर को बदल देंगे, लेकिन कुछ लोगों को उन चुनौतियों से दूर रखा जाता है, जिनके पास पहले से ही एक स्वीकृत उत्तर होता है, क्योंकि दुर्भाग्य से हर चुनौती लेखक की नहीं होती है। इसलिए यह कम है कि क्या जल्दी स्वीकार करना वास्तव में बुरा है लेकिन क्या लोगों को गलत धारणा मिलेगी।

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

क्या इनपुट नंबर पूर्णांक हैं?

— यादृच्छिक

Answer 1

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

haDQSE

परीक्षण सूट

STDIN पर निम्नलिखित फॉर्म में इनपुट:

num
array

स्पष्टीकरण:

haDQSE
          Implicit: Q = eval(input()) (num)
     E    Evaluate input (array)
    S     Sort (smaller values to the front)
 aDQ      Sort by absolute difference with Q.
h         Take the first element of the sorted list, the min.
          Print implicitly.

Answer 2

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

->n,a{a.sort.min_by{|x|(n-x).abs}}

a.sort       min_by tiebreaks by position in array, so put smaller numbers 1st
.min_by{|x|  select the element which returns the smallest val for predicate...
(n-x).abs}   (absolute) difference between input num and element

Comments

मुझे लगता है कि आपको #sort की आवश्यकता नहीं है, क्योंकि min_by पहले से ही इसे min से अधिकतम तक सॉर्ट करेगा। तो, यह और भी छोटा हो सकता है:->n,a{a.min_by{|x|(n-x).abs}}

— TiSer

Answer 3

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

Min@*Nearest

बिल्ट-इन FTW! बट्टनर की व्याख्या: "गणितज्ञ के पास इसके लिए एक अंतर्निहित है Nearest, लेकिन यह सभी बंधी हुई संख्याओं की एक सूची देता है। इसलिए, हमें Minटाई को तोड़ने के लिए इसके साथ रचना करने की आवश्यकता है ।"

Comments

यही मुझे एक स्पष्टीकरण लिखने के लिए मिलता है ...

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

क्या आप "इसे ऑनलाइन आज़मा सकते हैं"?

— 17

@ एलेक्स 82 मैथमेटिका (जो मालिकाना है) के लिए संभावना नहीं है।

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

@ Alex82 इसे यहाँ टेस्ट करें: lab.open.wolframcloud.com/app/view/newNotebook?ext=nb

— thedude

Answer 4

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

hS.mabQE

व्याख्या

         - autoassign Q = eval(input())
  .m   E -   min_values([V for b in eval(input())])
    abQ  -    abs(b-Q)
 S       -  sorted(^)
h        - ^[0]

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

Answer 5

जावास्क्रिप्ट ईएस 6, 64 56 54 बाइट्स

(i,a)=>a.sort((a,b)=>s(i-a)-s(i-b)||a-b,s=Math.abs)[0]

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

@ बयेल को दो बाइट बचाने के लिए धन्यवाद

टेस्ट स्निपेट:

f=(i,a)=>a.sort((a,b)=>s(i-a)-s(i-b)||a-b,s=Math.abs)[0];

[
  [5, [1, 2, 3]],
  [2, [3, 5, 1]],
  [2, [1, 3, 5]],
  [0, [-1, 2, 3]],
  [5, [1, 2, 3]]
].map(v=>O.textContent+=JSON.stringify(v)+": "+f.apply(null,v)+"\n")

<pre id=O></pre>

Comments

प्रकारों के संयोजन से 2 बाइट्स बचाएं:(i,a)=>a.sort((a,b)=>s(i-a)-s(i-b)||a-b,s=Math.abs)[0]

— नील

आप अपने कार्य को करीने से बाइट बचा सकते हैं : i=>a=>...फिर f(i)(a)आप इसे कैसे कॉल कर सकते हैं।

— पैट्रिक रॉबर्ट्स

@PatrickRoberts इस मामले में मैं नहीं कहूंगा, क्योंकि ओपी एक फ़ंक्शन (या सिमुलियर) के लिए पूछ रहा है जो मूल्यों पर ले जाता है: inputऔर एक सूची / सरणी / ... पूर्णांक के रूप में

— -lrc

Answer 6

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

ạżṛỤḢị

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

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

ạżṛỤḢị Main link. Left input: n (number). Right input: A (list)

ạ      Take the asbolute difference of n and the items of A.
  ṛ    Yield the right argument, A.
 ż     Zip the left result with the right one.
       This pairing causes ties in absolute value to be broken by initial value.
   Ụ   Grade up; sort the indices of the resulting list by their associated values.
    Ḣ  Retrieve the first index, which corresponds to the smallest value.
     ị Retrieve the item of A at that index.

Answer 7

MATL , 10 बाइट्स

Sti-|4#X<)

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

S       % implicitly input array, and sort. This ensures smaller numbers have priority
t       % duplicate
i       % input number
-|      % compute array of absolute differences
4#X<    % arg min. If there are several minimizers, the position of the first is returned
)       % index into original array. Implicitly display

Answer 8

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

a=input()
print sorted(input(),key=lambda x:abs(a-x))[0]

पहले लक्ष्य संख्या प्राप्त करता है a=input()- इसे एक चर में संग्रहीत किया जाना है।

यह lambda x:abs(a-x)लागू किए गए फ़ंक्शन के साथ इनपुट को सॉर्ट करता है (सोचो map(lambda x:abs(a-x), input()))

यह तब किसी भी डुप्लिकेट मान के मामले में न्यूनतम मूल्य लेता है

Answer 9

टीस्क्रिप्ट, 10 बाइट्स

T#(y-l)a)░

TeaScript कंसोल रन में सरणी इनपुट का समर्थन नहीं करता है: TeaScript("T#y-la)░", [[1, 2, 3], 1], {}, TEASCRIPT_PROPS) रनथिस के लिए।

व्याख्या

T#  // Sort input by...
  (y-l)a // absolute difference with input
)░  // First item in array

Answer 10

आर, 42 बाइट्स

x=sort(scan());x[which.min(abs(x-scan()))]

Answer 11

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

e#l=snd$minimum$(zip=<<map(abs.(e-)))l

प्रयोग उदाहरण: 2 # [1,5,3]-> 1।

इनपुट सूची में प्रत्येक तत्व lके लिए इनपुट संख्या eऔर तत्व के साथ तत्व के पूर्ण अंतर की एक जोड़ी बनाते हैं , उदाहरण के लिए e=2, l=[1,5,3]-> [(1,1),(3,5),(1,3)]। न्यूनतम खोजें और अंतर को छोड़ दें।

Answer 12

zsh, 75 73 71 70 67 बाइट्स

for n in ${@:2};{echo "$[$1-n]    $n"}|tr -d -|sort -n|head -1|cut -f2

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

ध्यान दें कि चार रिक्त स्थान echo वास्तव में एक टैब माना जाता है, लेकिन स्टैक एक्सचेंज सभी पोस्ट में टैब को रिक्त स्थान में परिवर्तित करता है।

for वाक्य - विन्यास के कारण बैश-संगत नहीं ।

for n in ${@:2};      for each argument except the first...
{echo "$[$1-n]\t$n"}  output the difference from the first argument
                        and then the original number
|tr -d -              poor man's abs()
|sort -n              sort by first num (difference), tiebreaking by second num
                        (original value)
|head -1              take the thing that sorted first
|cut -f2              print field 2 (aka discard the difference)

2 बाइट्स के लिए देव-नल के लिए धन्यवाद !

Answer 13

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

{@^b.sort.sort((*-$^a).abs)[0]}

उपयोग:

my &code = {@^b.sort.sort((*-$^a).abs)[0]}

say code 5, [1,2,3];   # 3
say code 0, [-1,3,5];  # -1
say code 2, [1, 5, 3]; # 1
say code 0, [5,-5];    # -5