नेव बेयस क्लासिफ़ायर

नेव बेयस मानता है कि क्लास पता होने पर फ़ीचर एक-दूसरे से स्वतंत्र हैं, और सबसे ऊँचे स्कोर वाली क्लास चुनता है:

score(c) = P(c) × P(x₁ | c) × P(x₂ | c) × … × P(xₙ | c)

फ़ीचर पूर्णांकों के रूप में एन्कोड की गई श्रेणियाँ हैं। ट्रेनिंग डेटा से प्रायिकताओं का अनुमान लगाएँ:

P(c) = (क्लास c के सैंपल की संख्या) / (कुल सैंपल)
P(xⱼ = v | c) = (क्लास c के उन सैंपल की संख्या जिनका फ़ीचर j, v के बराबर है + 1) / (क्लास c के सैंपल की संख्या + Kⱼ)

जहाँ Kⱼ ट्रेनिंग सैंपल और क्वेरी में फ़ीचर j के अलग-अलग मानों की संख्या है। +1 (लाप्लास स्मूदिंग) किसी अनदेखे मान को स्कोर शून्य करने से रोकता है।

सबसे ऊँचे स्कोर वाली क्लास लौटाएँ; बराबरी होने पर छोटी क्लास लौटाएँ। कई छोटी प्रायिकताओं को गुणा करने से अंडरफ़्लो हो सकता है, इसलिए गुणा के बजाय लघुगणक जोड़ें।

naive_bayes_predict(features, labels, query) लागू करें।

इनपुट

features: हर ट्रेनिंग सैंपल के लिए n कैटेगोरिकल फ़ीचर की एक पंक्ति।

labels: हर ट्रेनिंग सैंपल की क्लास।

query: वर्गीकृत किए जाने वाले सैंपल के n फ़ीचर।

आउटपुट

अनुमानित क्लास लौटाएँ।

सीमाएँ

1 ≤ सैंपल ≤ 1,000, 1 ≤ n ≤ 20

0 ≤ हर फ़ीचर मान और लेबल ≤ 100

उदाहरण

उदाहरण 1

इनपुट:
features = [
    [0, 1],
    [0, 0],
    [1, 1],
    [1, 0],
    [0, 1]
]
labels = [1, 1, 0, 0, 1]
query = [0, 1]

अपेक्षित आउटपुट:
1

व्याख्या

क्लास 1 में 3 सैंपल हैं और क्लास 0 में 2। फ़ीचर 1 के मान {0, 1} हैं (K = 2), फ़ीचर 2 के {0, 1} (K = 2)। score(1) = 3/5 × (3+1)/(3+2) × (2+1)/(3+2) = 0.6 × 0.8 × 0.6 = 0.288। score(0) = 2/5 × (0+1)/(2+2) × (1+1)/(2+2) = 0.4 × 0.25 × 0.5 = 0.05। क्लास 1 जीतती है।

उदाहरण 2

इनपुट:
features = [
    [0],
    [0],
    [1]
]
labels = [0, 0, 1]
query = [2]

अपेक्षित आउटपुट:
0

व्याख्या

मान 2 कभी नहीं आता, इसलिए K = 3 (मान 0, 1 और 2)। score(0) = 2/3 × (0+1)/(2+3) ≈ 0.133 और score(1) = 1/3 × (0+1)/(1+3) ≈ 0.083। स्मूदिंग की वजह से कोई भी 0 नहीं है, और ज़्यादा आम क्लास 0 जीतती है।

संदर्भ

कोड सबमिट किए बिना जांचने के लिए सैंपल टेस्ट चलाएँ।

उदाहरण 1 नहीं चलाया गया
इनपुट:
```
features = [
    [0, 1],
    [0, 0],
    [1, 1],
    [1, 0],
    [0, 1]
]
labels = [1, 1, 0, 0, 1]
query = [0, 1]
```
अपेक्षित आउटपुट:
```
1
```
आपका आउटपुट
उदाहरण 2 नहीं चलाया गया
इनपुट:
```
features = [
    [0],
    [0],
    [1]
]
labels = [0, 0, 1]
query = [2]
```
अपेक्षित आउटपुट:
```
0
```
आपका आउटपुट

सबमिट करने पर 4 छुपे हुए टेस्ट भी चलेंगे। अगर आपका कोड किसी में फेल होता है, तो आप वह टेस्ट देखेंगे। सभी देखने के लिए चैलेंज हल करें।

Online Go Compiler

Write, compile, run, and debug Go code online in a full-featured browser IDE. Work with multiple files, save your workspace, and collaborate in real time - no setup required.

संस्करण

पहले से इंस्टॉल लाइब्रेरी

🚀 206,970 कुल निष्पादन (799 इस महीने)

Count pairs of positions whose values add up to a target.

आप सीखेंगे इंडेक्स के जोड़ेदोहरी गिनती से बचना

ArraysBeginnerLearning-pathNested-loops

3 समाधान देखें

🐹 इस Go ऑनलाइन एग्जीक्यूटर के बारे में

CodeUtility Go एग्जीक्यूटर आपको अपने ब्राउज़र में सीधे Go कोड लिखने और चलाने देता है - किसी इंस्टॉलेशन, सेटअप या लोकल एनवायरनमेंट की ज़रूरत नहीं। यह एक सुरक्षित सैंडबॉक्स द्वारा संचालित है जो असली Go कंपाइलर वर्ज़न 1.19, 1.20, और 1.21 को सपोर्ट करता है।

यह टूल क्लाउड में असली Go प्रोग्राम्स को कंपाइल और रन करता है, ताकि आपको एक असली Go एनवायरनमेंट मिले। आप छोटे स्निपेट्स टेस्ट कर सकते हैं, पैकेजेज़ के साथ प्रयोग कर सकते हैं, और goroutines व channels का उपयोग करके Go की शक्तिशाली concurrency फीचर्स को एक्सप्लोर कर सकते हैं।

यह वेरिएबल्स, फंक्शन्स, स्ट्रक्ट्स, slices, maps, interfaces और एरर हैंडलिंग जैसे Go के मुख्य कॉन्सेप्ट्स सीखने व अभ्यास करने के लिए बेहतरीन है - वह भी बिना कोई टूल लोकली इंस्टॉल किए।

चाहे आप पहली बार Go सीख रहे हों, बैकएंड लॉजिक टेस्ट कर रहे हों, या concurrency कैसे काम करती है यह समझ रहे हों - CodeUtility Go एग्जीक्यूटर आपको ब्राउज़र में तुरंत Go कोड चलाने का एक साफ़-सुथरा और तेज़ तरीका देता है।

सिर्फ़ एक कोड रनर से कहीं अधिक

एक ही एक्ज़ीक्यूटर में मल्टी-फ़ाइल एडिटर, अलग-थलग निष्पादन टर्मिनल, रनटाइम-विशिष्ट लाइब्रेरी, स्थायी वर्कस्पेस, साझाकरण और रीयल-टाइम सहयोग का उपयोग करें।

इस एक्ज़ीक्यूटर का उपयोग कैसे करें?

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

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

कोडिंग प्रारंभ करें

संस्करणचलाने से पहले एक रनटाइम चुनें.स्थापित लाइब्रेरी चयनित भाषा संस्करण से संबंधित हैं।
खुली फ़ाइलें, न खुली पाठ फ़ाइलें सूचीबद्ध करती हैं।इसे उपलब्ध संपादक टैब में खोलने के लिए किसी एक का चयन करें।
रन सक्रिय फ़ाइल को प्रोग्राम के लिए उपलब्ध कार्यक्षेत्र के साथ निष्पादित करता है।
स्टॉप वर्तमान निष्पादन को उसकी समय सीमा से पहले समाप्त कर देता है।
उन्नत मोड एक फ़ाइल एक्सप्लोरर और चल, आकार बदलने योग्य टर्मिनल के साथ आईडीई लेआउट को खोलता है।

कार्यक्षेत्र और पुस्तकालय

नई फ़ाइल चयनित मूल निर्देशिका में एक फ़ाइल बनाती है और उसे संपादक में खोलती है।
नया फ़ोल्डर समर्थित नेस्टिंग गहराई तक एक निर्देशिका बनाता है।
फ़ाइलें अपलोड करें एक निर्देशिका में एक या अधिक सुरक्षित फ़ाइलें जोड़ता है।
डाउनलोड आपके डिवाइस पर एक फ़ाइल या ज़िपित निर्देशिका को सहेजता है।
किसी कार्यस्थान फ़ाइल या निर्देशिका की डुप्लिकेट प्रतिलिपि बनाएँ।
नाम बदलें फ़ाइल का नाम बदलता है और उसके खुले टैब और इतिहास को अपडेट करता है।
मूव किसी आइटम को स्थानांतरित करता है;फ़ाइलें और निर्देशिकाएँ भी खींची जा सकती हैं।
पुष्टिकरण के बाद डिलीट किसी आइटम को हटा देता है और उसके खुले संपादक टैब को बंद कर देता है।
पहले से स्थापित Libs इस रनटाइम में पहले से शामिल पैकेज दिखाता है।
Add Lib आपके खाते और चयनित रनटाइम के लिए एक निजी पैकेज स्थापित करता है।

टर्मिनल और सहायता

रन इतिहास पिछले और अगले सहेजे गए आउटपुट को खोलता है।
कॉपी आउटपुट वर्तमान टर्मिनल टेक्स्ट की प्रतिलिपि बनाता है।
क्लियर आउटपुट पुष्टि के बाद सभी सहेजे गए रन आउटपुट को हटा देता है।
सक्रिय कोड का सारांश समझाएँ।
हाल ही में हालिया स्पष्टीकरण और परिणाम खुलते हैं।
सेटिंग्स फ़ॉन्ट, थीम और दृश्यमान टूलबार बटन बदलती हैं।

साझा करना और सहयोग करना

शेयर वर्तमान फ़ाइल, एक निर्देशिका, या संपूर्ण कार्यस्थान को स्नैपशॉट या लाइव कार्यस्थान के रूप में प्रकाशित करता है।आप लिंक एक्सेस को नियंत्रित करते हैं और परिवर्तनों को कौन सहेज सकता है।
लॉग किसी साझा कार्यक्षेत्र में सहेजे गए सहयोगी कार्यों को रिकॉर्ड करता है।
शेयर चैट से साइन-इन प्रतिभागियों को संदेश भेजने, लोगों का उल्लेख करने, कोड ब्लॉक साझा करने और ऑनलाइन या टाइपिंग सदस्यों को देखने की सुविधा मिलती है।
लाइव सहयोग सहयोगी कर्सर और सहेजे गए फ़ाइल अपडेट दिखाता है।केवल-दृश्य उपयोगकर्ता नवीनतम संस्करण लोड कर सकते हैं या अस्थायी संपादन रख सकते हैं।

कोटा और सीमाएँ

निष्पादन समय प्रति सर्वर रन 20 सेकंड तक सीमित है।जब आप इसे जल्दी समाप्त करना चाहते हैं तो स्टॉप का उपयोग करें।
वर्कस्पेस स्टोरेज प्रत्येक साइन-इन उपयोगकर्ता वर्कस्पेस और भाषा के लिए 100 फ़ाइलों, 100 निर्देशिकाओं और कुल 10 MiB की अनुमति देता है।
फ़ाइलें और फ़ोल्डर्स 1 MiB प्रति फ़ाइल और 5 नेस्टेड निर्देशिका स्तरों तक सीमित हैं।आपके कोड द्वारा जेनरेट की गई फ़ाइलें समान कोटा का पालन करती हैं।
निजी लाइब्रेरी प्रत्येक खाते और रनटाइम के लिए 10 स्थापित पैकेजों तक सीमित हैं।
शेयर स्नैपशॉट में अधिकतम 100 फ़ाइलें, प्रति फ़ाइल 1 MiB और कुल 2 MiB हो सकते हैं।
शेयर आमंत्रण प्रति शेयर 25 लोगों तक का समर्थन करते हैं, पहुंच और बचत अनुमतियाँ अलग से प्रबंधित की जाती हैं।
शेयर चैट प्रति संदेश 2,000 अक्षर और प्रति शेयर 10,000 संदेश की अनुमति देता है।
कोड चलने के दौरान कोटा प्रवर्तन भी लागू होता है।फ़ाइल संख्या, आकार, भंडारण, या नेस्टिंग सीमा से अधिक का लेखन सुरक्षित रूप से अस्वीकार कर दिया जाता है।

जानकर अच्छा लगा केवल कोड चलाएं और वही पैकेज इंस्टॉल करें जिन पर आपको भरोसा है।निष्पादन पृथक और सीमित है, लेकिन आपका प्रोग्राम अभी भी अपने लागू कोटा तक लिखने योग्य कार्यक्षेत्र के अंदर फ़ाइलों को संशोधित कर सकता है।

💡 Go की मूल बातें और उदाहरण जिन्हें आप ऊपर आज़मा सकते हैं

1. वेरिएबल्स और कॉन्स्टेंट्स की घोषणा

var या := से वेरिएबल्स घोषित करें। const कॉन्स्टेंट्स के लिए उपयोग करें।

package main

var x int = 10
const Pi = 3.14

func main() {
    name := "Alice"
    isActive := true
    println(x, Pi, name, isActive)
}

2. शर्तें (if / switch)

Go साफ़ सिंटैक्स के साथ if-else और switch स्टेटमेंट सपोर्ट करता है।

x := 2
if x == 1 {
    println("एक")
} else if x == 2 {
    println("दो")
} else {
    println("अन्य")
}

switch x {
case 1:
    println("एक")
case 2:
    println("दो")
default:
    println("अन्य")
}

3. लूप्स

Go में सिर्फ for लूप होता है, लेकिन यह while जैसा भी काम कर सकता है।

for i := 0; i < 3; i++ {
    println(i)
}

n := 3
for n > 0 {
    println(n)
    n--
}

4. एरेज़

Arrays का आकार फिक्स्ड होता है। डायनेमिक लिस्ट्स के लिए slices का उपयोग करें।

var nums = [3]int{10, 20, 30}
println(nums[1])

5. स्लाइस मैनिपुलेशन

slices और बिल्ट-इन append, len, copy, और slicing सिंटैक्स का उपयोग करें।

fruits := []string{"सेब", "केला"}
fruits = append(fruits, "चेरी")
fruits = fruits[1:]  // स्लाइस
println(len(fruits))

for _, fruit := range fruits {
    println(fruit)
}

6. कंसोल इनपुट/आउटपुट

fmt.Print, fmt.Scan, और fmt.Println का उपयोग करें।

import "fmt"

var name string
fmt.Print("अपना नाम दर्ज करें: ")
fmt.Scan(&name)
fmt.Println("नमस्ते", name)

7. फंक्शन्स

फंक्शन्स को func से घोषित करते हैं और ये कई वैल्यूज़ रिटर्न कर सकते हैं।

func greet(name string) string {
    return "नमस्ते, " + name
}

message := greet("Alice")
println(message)

8. मैप्स

मैप्स key-value स्टोर्स होते हैं। make() से डिक्लेयर करें।

ages := map[string]int{"Alice": 30}
ages["Bob"] = 25
println(ages["Alice"])

9. एरर हैंडलिंग

एक्सेप्शन्स की जगह Go एरर्स के लिए मल्टीपल रिटर्न वैल्यूज़ का उपयोग करता है।

import "errors"

func fail() error {
    return errors.New("कुछ गड़बड़ हो गई")
}

err := fail()
if err != nil {
    println(err.Error())
}

10. फाइल I/O

फाइल पढ़ने/लिखने के लिए os और io/ioutil पैकेज का उपयोग करें।

import (
  "fmt"
  "os"
  "io/ioutil"
)

ioutil.WriteFile("file.txt", []byte("हैलो फाइल"), 0644)

data, _ := ioutil.ReadFile("file.txt")
fmt.Println(string(data))

11. स्ट्रिंग मैनिपुलेशन

स्ट्रिंग ऑपरेशंस के लिए strings पैकेज का उपयोग करें।

import "strings"

text := "  नमस्ते दुनिया  "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "नमस्ते", "हाय"))

words := strings.Split(text, " ")
fmt.Println(words)

12. स्ट्रक्ट्स और ऑब्जेक्ट्स

मेथड्स के साथ कस्टम टाइप्स परिभाषित करने के लिए structs का उपयोग करें।

type Person struct {
  Name string
}

func (p Person) Greet() string {
  return "हाय, मैं " + p.Name
}

p := Person{Name: "Alice"}
println(p.Greet())

13. रेफरेंसेज़ (पॉइंटर्स)

Go में * और & का उपयोग करके पॉइंटर्स सपोर्टेड हैं।

x := 10
ptr := &x
*ptr = 20
println(x) // 20