सभी चुनौतियाँ
मध्यम 0 हल किए गए 0% स्वीकृति

K-नियरेस्ट नेबर्स क्लासिफ़ायर

k सबसे नज़दीकी ट्रेनिंग पॉइंट के बहुमत वोट से लेबल का अनुमान लगाएँ।

आप क्या सीखेंगे

  • सबसे पास के ट्रेनिंग बिंदु ढूँढना
  • बहुमत वोट से अनुमान लगाना
  • बराबरी को तय तरीके से सुलझाना

समस्या

K-नियरेस्ट नेबर्स (KNN) किसी नए पॉइंट को उसके सबसे नज़दीकी k ट्रेनिंग पॉइंट देखकर और सबसे आम लेबल चुनकर वर्गीकृत करता है।

  1. query से हर पॉइंट तक की यूक्लिडियन दूरी निकालें।
  2. पॉइंटों को दूरी के अनुसार क्रम में लगाएँ; अगर दो दूरियाँ बराबर हों, तो छोटे इंडेक्स वाला पॉइंट पहले आता है।
  3. पहले k पॉइंट लें और उनके लेबल गिनें।
  4. सबसे ज़्यादा वोट वाला लेबल लौटाएँ। बराबरी होने पर वह लेबल लौटाएँ जिसका सबसे नज़दीकी पॉइंट क्रम में पहले आता है।

knn_predict(points, labels, query, k) लागू करें।

इनपुट

points: ट्रेनिंग पॉइंट, हर एक निर्देशांकों की सूची।

labels: हर पॉइंट का लेबल।

query: वह पॉइंट जिसे वर्गीकृत करना है।

k: कितने पड़ोसी वोट करते हैं।

आउटपुट

अनुमानित लेबल लौटाएँ।

सीमाएँ

1 ≤ k ≤ पॉइंटों की संख्या ≤ 1,000

1 ≤ आयाम ≤ 20

-1,000 ≤ हर निर्देशांक ≤ 1,000

उदाहरण

उदाहरण 1
इनपुट:
k = 3
query = [3.0, 3.0]
labels = ["A", "A", "B", "B"]
points = [
    [1.0, 1.0],
    [2.0, 2.0],
    [8.0, 8.0],
    [9.0, 9.0]
]

अपेक्षित आउटपुट:
expected = "A"
इनपुट:
long long k = 3;
std::vector<double> query = {3.0, 3.0};
std::vector<std::string> labels = {"A", "A", "B", "B"};
std::vector<std::vector<double>> points = {
    {1.0, 1.0},
    {2.0, 2.0},
    {8.0, 8.0},
    {9.0, 9.0}
};

अपेक्षित आउटपुट:
std::string expected = "A";
इनपुट:
long k = 3;
double[] query = new double[] {3.0, 3.0};
string[] labels = new string[] {"A", "A", "B", "B"};
double[][] points = new double[][] {
    new double[] {1.0, 1.0},
    new double[] {2.0, 2.0},
    new double[] {8.0, 8.0},
    new double[] {9.0, 9.0}
};

अपेक्षित आउटपुट:
string expected = "A";

व्याख्या

(3, 3) से दूरियाँ: (2, 2) ≈ 1.41, (1, 1) ≈ 2.83, (8, 8) ≈ 7.07। 3 सबसे नज़दीकी लेबल A, A और B हैं, इसलिए उत्तर A है।

उदाहरण 2
इनपुट:
k = 2
query = [1.0, 1.0]
labels = ["red", "blue", "blue", "red"]
points = [
    [0.0, 0.0],
    [4.0, 0.0],
    [0.0, 4.0],
    [4.0, 4.0]
]

अपेक्षित आउटपुट:
expected = "red"
इनपुट:
long long k = 2;
std::vector<double> query = {1.0, 1.0};
std::vector<std::string> labels = {"red", "blue", "blue", "red"};
std::vector<std::vector<double>> points = {
    {0.0, 0.0},
    {4.0, 0.0},
    {0.0, 4.0},
    {4.0, 4.0}
};

अपेक्षित आउटपुट:
std::string expected = "red";
इनपुट:
long k = 2;
double[] query = new double[] {1.0, 1.0};
string[] labels = new string[] {"red", "blue", "blue", "red"};
double[][] points = new double[][] {
    new double[] {0.0, 0.0},
    new double[] {4.0, 0.0},
    new double[] {0.0, 4.0},
    new double[] {4.0, 4.0}
};

अपेक्षित आउटपुट:
string expected = "red";

व्याख्या

सबसे नज़दीकी पॉइंट (0, 0) (red) है; अगले दो, (4, 0) और (0, 4), बराबर दूरी पर हैं, इसलिए छोटा इंडेक्स (4, 0) (blue) चुना जाता है। red और blue को एक-एक वोट मिला, और red का पॉइंट पहले आया, इसलिए उत्तर red है।

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।