किसी दिए गए सरणी में निकटतम संख्या ज्ञात करें

Question

यह मेरे द्वारा की गई वास्तविक विश्व समस्या से प्रेरित है। मैं यह देखने के लिए उत्सुक हूं कि क्या इस बारे में जाने का कोई चतुर तरीका है।

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

जीत की स्थिति

सबसे छोटा कोड जीतता है (हमेशा की तरह)।

Comments

निकटतम पूर्णांक के लिए गोल?

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h thata̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ मैंने पढ़ा कि "A के प्रत्येक तत्व को B के निकटतम तत्व के रूप में गोल करें"

— John Dvorak

@JDDvorak: खैर, मैं गोलाई दिशा के बारे में समझ रहा हूं, लेकिन समस्या यह नहीं बताती है कि कितने अंक हैं।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h nearesta̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ निकटतम फ्लोट के लिए गोल। उत्‍तर में

— उत्‍तरोत्‍तर

क्या ए और बी को क्रमबद्ध किया जाएगा?

— लेवल रिवर सेंट

Answer 1

एपीएल, १३ १ 17

(यूटीएफ -8 में 21 बाइट)

B[{↑⍋|⍵-B}¨A]

यदि आप सच्चा लंबोदर चाहते हैं (ए बाएं तर्क के रूप में और बी दाएं के रूप में):

{⍵[⍺{↑⍋|⍺-⍵}¨⊂⍵]}

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

{...}¨A{...}प्रत्येक ए मान के साथ लैंबडा फ़ंक्शन को आमंत्रित करता है (ए के रूप में ए के साथ आह्वान करने के बजाय), एक ही आकार के सरणी के लिए परिणाम इकट्ठा करता है

|⍵-B तर्क ⍵ और सभी के बीच अंतर के पूर्ण मूल्यों की गणना करता है B (- घटाव है; | अनुपस्थित है)।

↑⍋ कम से कम तत्व का सूचकांक लेता है (array प्रकार सरणी लौटने वाले सूचकांक, element पहले तत्व प्राप्त करें)

B[...] इंडेक्स (तों) के द्वारा बस एलिमेंटिंग एलीमेंट है।

यह समाधान काफी भयावह है, पूरी तरह से यह एपीएल के छँटाई फ़ंक्शन रिटर्न परमुटेशन वेक्टर (मूल तत्व में सॉर्ट किए गए तत्व के सूचक) के बजाय छांटे गए सरणी की अद्भुत विशेषता का उपयोग करता है।

Comments

यह कैसे काम करता है?

— जॉन ड्वोरक

उत्तर में समझाया गया

— वॉनियम

पृथ्वी पर आप इसे कैसे लिखना जानते हैं?

— मार्टिज़न

यह चीनी लिखने जैसा है। मेरे लिए, विदेशी शब्दों या विदेशी चरित्रों को लिखने में कोई बहुत बड़ा अंतर नहीं है ...

— वोवनी

Answer 2

गणितज्ञ - १ 17

#&@@@Nearest@A/@B

यह कैसे काम करता है? हां, मैं मानता हूं कि यहां थोड़ा धोखा है क्योंकि मैथेमेटिका में निकटतम कार्यक्षमता है। शेष सीधा है और 1 डी सरणी में परिणाम की व्यवस्था करने से चिंतित है। यह केवल इसे कम करने के अतिरिक्त प्रयास के कारण बदसूरत दिखता है।

Comments

हा! स्वागत हे! :)

— डॉ। बेलिसरियस

Answer 3

C # - 103 97 87 बाइट्स

मुझे पूरा यकीन नहीं है कि अगर मैं इस सवाल को सही ढंग से समझ पाऊं, लेकिन यहां मेरा समाधान है। मैंने सरणियों के बजाय सूचियों का उपयोग किया, क्योंकि यह मुझे छोटे कोड लिखने की अनुमति देता है।

पूर्णांक सरणी पूर्णांक सूची से छोटी है।

इनपुट:

t(new int[] { 0, 25, 10, 38 }, new int[] { 3, 22, 15, 49, 2 });

तरीका:

void t(int[]a,int[]b){var e=a.Select(c=>b.OrderBy(i=>Math.Abs(c-i)).First()).ToArray();

आउटपुट:

2, 22, 15, 49

यदि मेरा उत्तर सही नहीं है, तो कृपया नीचे एक टिप्पणी छोड़ दें।

EDIT: AS @grax ने बताया, सवाल अब तैरने का है। इसलिए मैं उसका जवाब भी शामिल करना चाहूंगा।

95 बाइट्स (ग्रेक्स का जवाब)

float[]t(float[]a,float[]b){return a.Select(d=>b.OrderBy(e=>Math.Abs(e-d)).First()).ToArray();}

Comments

लिस्ट भी ठीक है।

— ओरम

नाम बदलें itemकरने के लिए i), और आप सुरक्षित 6 अतिरिक्त वर्ण होगा

— Aschratt

@Aschratt आपका बहुत-बहुत धन्यवाद!

— tasavinho

1. फ़ंक्शन विशेष रूप से नए मूल्य को वापस करने के लिए नहीं कहता है, लेकिन मुझे लगता है कि आपको चाहिए। 2. चूंकि प्रश्न फ्लोट के लिए कहा जाता है, मुझे लगता है कि आपको फ्लोट का उपयोग करना चाहिएfloat[] t(float[] a, float[] b) {return a.Select(d=>b.OrderBy(e=>Math.Abs(e-d)).First()).ToArray();}

— Grax32

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

— tsavinho

Answer 4

आर, 41 वर्ण

B[apply(abs(outer(A,B,`-`)),1,which.min)]

स्पष्टीकरण:

outer(A,B,`-`)A अंतर के प्रत्येक तत्व x के लिए गणना करता है x-Bऔर परिणाम को एक मैट्रिक्स (आयाम लंबाई (ए) x लंबाई (बी)) के रूप में आउटपुट करता है।
which.minन्यूनतम संख्या के सूचकांक को चुनता है। मैट्रिक्स की प्रत्येक पंक्ति
apply(x, 1, f)पर फ़ंक्शन लागू करता है । इसलिएfx
apply(abs(outer(A,B,`-`)),1,which.min) ए के प्रत्येक तत्व और वेक्टर बी के तत्वों के बीच न्यूनतम पूर्ण अंतर के सूचकांकों को लौटाता है।

उपयोग:

> A <- runif(10,0,50)
> B <- runif(10,0,50)
> A
[1] 10.0394987 23.4564467 19.6667152 36.7101256 47.4567670 49.8315028  2.1321263 19.2866901  0.7668489 22.5539178
> B
[1] 44.010174 32.743469  1.908891 48.222695 16.966245 23.092239 24.762485 30.793543 48.703640  6.935354
> B[apply(abs(outer(A,B,`-`)),1,which.min)]
[1]  6.935354 23.092239 16.966245 32.743469 48.222695 48.703640  1.908891 16.966245  1.908891 23.092239

Answer 5

CJam - 14

q~
f{{1$-z}$0=\;}
p

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

इसे http://cjam.aditsu.net/ पर आज़माएं

स्पष्टीकरण:

q~पढ़ता है और मूल्यांकन करता है इनपुट
f{...}पहली सरणी के प्रत्येक तत्व और अगले ऑब्जेक्ट के लिए ब्लॉक (जो दूसरी सारणी है), एक सरणी में परिणाम का संग्रह कार्यान्वित
{...}$प्रत्येक आइटम के लिए एक महत्वपूर्ण गणना करने के लिए ब्लॉक का उपयोग दूसरी सरणी सॉर्ट करता
1$प्रतियां वर्तमान पहले सरणी से आइटम
-zघटता है फिर निरपेक्ष मूल्य
0=लेता है सॉर्ट किए गए सरणी का पहला मूल्य लेता है (न्यूनतम कुंजी के साथ)
\;पहले सरणी से आइटम को अलग करता है
p करता है परिणाम का स्ट्रिंग प्रतिनिधित्व प्रिंट करता है

उदाहरण (अन्य उत्तरों से प्रेरित):

इनपुट: [10.1 11.2 12.3 13.4 9.5] [10 12 14]
आउटपुट:[10 12 12 14 10]

इनपुट: [0 25 10 38] [3 22 15 49 2]
आउटपुट:[2 22 15 49]

Answer 6

जावास्क्रिप्ट (E6) 54 56 59

दूरी कम से कम करें। एब्स के बजाय स्क्वायर का उपयोग करना बस इतना चार्ज बचाएं। बीजगणित
संपादित करें ...
संपादन कार्य को ठीक करें (परीक्षण w / o फ़ंक्शन की शेष परिभाषा)

F=(A,B)=>A.map(a=>B.sort((x,y)=>x*x-y*y+2*a*(y-x))[0])

था F=(A,B)=>D=A.map(a=>B.sort((x,y)=>((x-=a,y-=a,x*x-y*y))[0])

परीक्षा

F([10.1, 11.2, 12.3, 13.4, 9.5],[10, 12, 14])

परिणाम: [10, 12, 12, 14, 10]

Comments

D=जरूरत नहीं है, के रूप में mapएक नया सरणी देता है। वैकल्पिक (एक ही लंबाई) सॉर्ट फ़ंक्शन:(x,y)=>(x-=a)*x-(y-=a)*y

— अंडरस्कोर

Answer 7

पायथन 3.x - 55 वर्ण

f=lambda a,b:[min((abs(x-n),x)for x in b)[1]for n in a]

aऔर bइनपुट सरणियाँ हैं, और वांछित सरणी अभिव्यक्ति का परिणाम है।

Comments

मैंने इसे एक फ़ंक्शन बनाने के लिए उत्तर दिया क्योंकि प्रश्न के लिए फ़ंक्शन की आवश्यकता होती है।

— user80551

Answer 8

हास्केल, 55

c a b=[[y|y<-b,(y-x)^2==minimum[(z-x)^2|z<-b]]!!0|x<-a]

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

Answer 9

पॉवरशेल - 44

$a|%{$n=$_;($b|sort{[math]::abs($n-$_)})[0]}

उदाहरण

के साथ $aऔर $bसेट करने के लिए:

$a = @(36.3, 9, 50, 12, 18.7, 30)
$b = @(30, 10, 40.5, 20)

आउटपुट है

40.5, 10, 40.5, 10, 20, 30

Comments

आप इसे स्पष्ट यह संभालती बनाने के लिए भी उदाहरण में तैरता इस्तेमाल कर सकते हैं झांकियां

— Bebe

@bebe - धन्यवाद, स्पष्ट करने के लिए अपडेट किया गया।

— रिनेंट

-3 बाइट्स:$a|%{$n=$_;($b|sort{($n-$_)*($n-$_)})[0]}

— माज़ी

Answer 10

रूबी, ४०

f=->a,b{a.map{|x|b.min_by{|y|(x-y)**2}}}

पाइथन के उत्तर के रूप में भी, लेकिन स्क्वेरिंग किसी भी तरह से थोड़ा थकाऊ है, जो मैं निरपेक्ष मूल्य लेने के बारे में सोच सकता था।

Answer 11

पायथ - 12 11 बाइट्स

नोट: अजगर इस चुनौती से बहुत छोटा है, इसलिए यह जवाब जीतने के योग्य नहीं है।

सरल विधि, oन्यूनतम दूरी पाने के लिए ऑर्डर फ़ंक्शन का उपयोग करती है और mइसे सूची में शामिल करती है a।

mho.a-dNQvz

m    vz    Map over evaled first input and implicitly print
 ho Q      Minimal mapped over evaled second input
  .a-      Absolute difference
   d       Lambda param 1
   b       Lambda param 2

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

Comments

@ जकूबे ओह हां, सॉरी।

— माल्टीसेन

Answer 12

TI-BASIC, 24

∟A+seq(min(∟B+i²∟A(N)),N,1,dim(∟A

एपीएल के करीब नहीं आता है, लेकिन कम शक्तिशाली कार्यों का उपयोग करता है - यह कोई "द्वारा क्रमबद्ध" या "कम से कम सूचकांक" फ़ंक्शन का उपयोग करता है। यहां TI-BASIC का नुकसान उन कार्यों और बहुआयामी सरणियों की कमी है।

Ungolfed:

seq(       ,N,1,dim(∟A           #Sequence depending on the Nth element of list A
    ∟A(N)+min(   +0i)            #Number with minimum absolute value, add to ∟A(N)
              ∟B-∟A(N)           #Subtracts Nth element of ∟A from all elements of B

मिनट (फ़ंक्शन के दो व्यवहार हैं: जब वास्तविक संख्याओं या सूचियों के साथ उपयोग किया जाता है, तो यह सबसे छोटा मान देता है; हालांकि, जब जटिल संख्याओं या सूचियों के साथ उपयोग किया जाता है, तो यह सबसे छोटे निरपेक्ष मान के साथ मूल्य देता है। दुभाषिए को जोड़ने 0iया गुणा i^2करने का कारण बनता है। दूसरे व्यवहार का उपयोग करें, इसलिए min(1,-2)रिटर्न-2 जबकि min(1+0i,-2+0i)रिटर्न 1।

Answer 13

फोरट्रान 90: 88

function f();integer::f(size(a));f(:)=[(b(minloc(abs(a(i)-b))),i=1,size(a))];endfunction

इसके लिए होना जरूरी है contain एक पूर्ण कार्यक्रम के भीतर संपादित :

program main
   real :: a(5), b(3)
   integer :: i(size(a))
   a = [10.1, 11.2, 12.3, 13.4, 9.5]
   b = [10, 12, 14]
   i = f()
   print*,i
 contains
   function f()
     integer :: f(size(a))
     f(:)=[(b(minloc(abs(a(i)-b))),i=1,size(a))]
   end function
end program main

वर्ग ब्रेसिज़ (...,i=)एक doलूप घोषित करता है जबकि एक निहित लूप का प्रतिनिधित्व करता है ; फिर मैं उस मूल्य को वापस करता हूं bजिसके लिए तत्व a(i)-bको कम से कम किया जाता है।

Answer 14

मतलाब: 48

f=@(a)B(abs(B-a)==min(abs(B-a)));C=arrayfun(f,A)

मान लेता है कि A और Bकार्यक्षेत्र में 1D हैं, अंतिम परिणाम Cकार्यक्षेत्र में है। यह संभवतः ऑक्टेव में भी काम करेगा। सशर्त अनुक्रमण इसे काफी तुच्छ बनाता है।

Answer 15

C 144 163

#define f float
f T, *C, m;
f *q(f *A, f *B, int S, f s)
{
    if(m) 
        return abs(T - *A) - abs(T - *B);
    for ( 
        C = malloc(S * 4);
        m = S--;
        C[S] = *B
    ) 
        T = A[S], 
        qsort(B, s, 4, q);
    return C;
}

ठीक है ... मुझे लगता है कि इस छोटे से कोड को स्पष्टीकरण की आवश्यकता है।

सबसे पहले मैंने दो अंतर के साथ काम करने की कोशिश की, जिसमें न्यूनतम अंतर पाया गया और बी के मूल्य के न्यूनतम मूल्य को निर्धारित किया। यह बहुत बुनियादी है।

उसी चीज के साथ पहुंचा जा सकता है qort के और एक तुलनित्र फ़ंक्शन के है। मैं इसे B के तत्वों के बजाय अंतर के अनुसार B बनाता हूं। इस तरह के एक छोटे एल्गोरिथ्म के लिए बहुत सारे कार्य। तो फ़ंक्शन q अब दो उद्देश्यों को पूरा करता है। सबसे पहले, यह एल्गोरिथ्म ही है, दूसरा (जब qsort इसे कहता है) एक तुलनित्र। दोनों राज्यों के बीच संचार के लिए, मुझे ग्लोबल्स घोषित करना पड़ा।

मीटर का अर्थ है कि यह तुलनित्र स्थिति में है या मुख्य है एक है।

उदाहरण:

float A[] = {1.5, 5.6, 8.9, -33.1};
float B[] = {-20.1, 2.2, 10.3};
float *C;

C = q(A, B, sizeof(A)/sizeof(*A), sizeof(B)/sizeof(*B));
// C holds 2.2,2.2,10.3,-20.1

Comments

166/163 व्हॉट्सएप की गिनती करता है या नहीं?

— काइल कानोस

बिलकूल नही। समझने में आसानी के लिए स्पेस और न्यूलाइन्स हैं।

— bebe

Answer 16

गोल्फस्क्रिप्ट, 49 बाइट्स

नोट: यह एक आंशिक समाधान है। मैं इसे संपूर्ण समाधान बनाने पर काम कर रहा हूं

{{\.@\.[.,,\]zip@{[\~@-abs]}+%{~\;}$0=0==}%\;}:f;

हाँ। GolfScript फ्लोटिंग पॉइंट का समर्थन करता है। इसे यहाँ आज़माएँ । उदाहरण:

# B is [-20.1 2.2 10.3]
[-201 10 -1?*
22 10 -1?*
103 10 -1?*]

# A. No floating point numbers allowed here.
# This is because 1.5{}+ (where the 1.5 is a
# single floating point number, not 1.5,
# which would be 1 1 5) results in the block
# {1.5 }, which leads to 1 1 5 when executed
[1 5 9 -30]

आउटपुट:

[2.2 2.2 10.3 -20.1]

Answer 17

सी # 262

कार्यक्रम न्यूनतम अंतर पाता है और ऐरे बी से निकटतम मूल्य बचाता है। मैं जल्द ही गोल्फिंग पर काम करूंगा।

List<float> F(List<float> a, List<float> b)
{
List<float> c = new List<float>();
float diff,min;
int k;
for(int i=0; i<a.Count;i++)
{
diff=0;
min=1e6F;
k = 0;
for(int j=0; j<b.Count;j++)
{
diff = Math.Abs(a[i] - b[j]);
if (diff < min)
{
min = diff;
k = j;
}
}
c.Add(b[k]);
}
return c;
}

परीक्षण कोड के साथ पूरा कार्यक्रम

using System;
using System.Collections.Generic;
public class JGolf
{
    static List<float> NearestValues(List<float> a, List<float> b)
    {
        List<float> c = new List<float>();
        float diff,min;
        int k;
        for(int i=0; i<a.Count;i++)
        {
            diff=0;
            min=1e6F;
            k = 0;
            for(int j=0; j<b.Count;j++)
            {
                diff = Math.Abs(a[i] - b[j]);
                if (diff < min)
                {
                    min = diff;
                    k = j;
                }
            }
            c.Add(b[k]);
        }
        return c;
    }

    public static void Main(string[] args)
    {
        List<float> A = RandF(8413);
        Console.WriteLine("A");
        Print(A);
        List<float> B = RandF(9448);
        Console.WriteLine("B");
        Print(B);

        List<float> d = JGolf.NearestValues(A, B);
        Console.WriteLine("d");
        Print(d);
        Console.ReadLine();
    }

    private static List<float> RandF(int seed)
    {
        Random r = new Random(seed);
        int n = r.Next(9) + 1;
        List<float> c = new List<float>();
        while (n-- > 0)
        {
            c.Add((float)r.NextDouble() * 100);
        }
        return c;
    }

    private static void Print(List<float> d)
    {
        foreach(float f in d)
        {
            Console.Write(f.ToString()+", ");
        }
    }
}

Answer 18

C #: 120

Linq कमाल है:

float[] t(float[] A, float[] B){return A.Select(a => B.First(b => Math.Abs(b-a) == B.Min(c=>Math.Abs(c-a)))).ToArray();}