स्कूल के बाहर (दिन 1)

21

मेरे विश्वविद्यालय कोड चैलेंज प्रतियोगिता से अनुमति के साथ चुनौती ली गई

अब कुछ वर्षों से, मेरे विद्यालय में छात्रों की संख्या लगातार बढ़ रही है। पहले छात्रों की संख्या कक्षा द्वारा बढ़ाई गई थी, लेकिन फिर कुछ समूहों के लिए कुछ स्थान बदलने के लिए यह आवश्यक था कि वहां जिम खड़ा हो या, यह आखिरी कोर्स हो, झाड़ू कक्ष तक।

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

चुनौती

वर्तमान समूहों और नए कक्षाओं (क्षमता) के छात्रों की मात्रा को देखते हुए, एक सत्य मान का उत्पादन करें यदि वर्तमान समूहों में से प्रत्येक के लिए पर्याप्त क्षमता के साथ, अलग-अलग कक्षा को आवंटित करना संभव है, या अन्यथा।

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

Input: groups of students => [10, 20, 30], classrooms capacity => [31, 12, 20]
Output: True

Input: groups of students => [10, 20, 30], classrooms capacity => [100, 200]
Output: False

Input: groups of students => [20, 10, 30], classrooms capacity => [20, 20, 50, 40]
Output: True

Input: groups => [30, 10, 30, 5, 100, 99], classrooms => [40, 20, 50, 40, 99, 99]
Output: False

Input: groups => [], classrooms => [10, 10, 10]
Output: True

Input: groups => [10, 10, 10], classrooms => []
Output: False

Input: groups => [], classrooms => []
Output: True

Input: groups => [10, 1], classrooms => [100]
Output: False

Input: groups => [10], classrooms => [100, 100]
Output: True

Input: groups => [1,2,3], classrooms => [1,1,2,3]
Output: True

टिप्पणियाँ

  • आप किसी भी उचित प्रारूप में इनपुट ले सकते हैं
  • आप कर सकते हैं उत्पादन किसी भी Truthy / Falsey मूल्य ( 1/0, True/False, आदि ...)
  • कोड गोल्फ
code-golf  decision-problem 
— लुइस फेलिप डी जीसस मुनोज
स्रोत
5
सुझाए गए g=[1,2,3], c=[1,1,2,3]
— टेस्टकेस
क्या आपको इसे यहां पोस्ट करने की अनुमति है?
— 15
2
@ Adám हां। मैंने अपने शिक्षक (प्रतियोगिता के प्रभारी कौन हैं) से पूछा और उन्होंने कहा कि कोई समस्या नहीं है। केवल एक चीज यह है कि यह प्रत्येक दिन एक चुनौती है
— लुइस फेलिप डी जीसस मुनोज़
है 0समूहों या कक्षाओं के लिए मान्य मान?
— nimi
1
@ किसी भी फाल्सी / सत्य मूल्य
— लुइस फेलिप डी

जवाबों:

14

ब्रेकीलॉग , 4 बाइट्स

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

p≤ᵐ⊆

व्याख्या

कोड के 3 भाग हैं जिनमें से वास्तव में आदेश मायने नहीं रखता है

≤ᵐ --> projects each value to a value bigger/equal then input
⊆  --> input is a ordered subsequence of output
p  --> permutes the list so it becomes a unordered subsequence

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

— Kroppeb
स्रोत
4

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

.AgM.t_DMQ0

सूचियों की सूची के रूप में इनपुट लेता है, कक्षा आकार पहले, समूह आकार दूसरा। इसे यहाँ ऑनलाइन आज़माएँ , या यहाँ पर सभी परीक्षण मामलों को सत्यापित करें ।

.AgM.t_DMQ0   Implicit: Q=eval(input())
      _DMQ    Sort each element of Q in reverse
    .t    0   Transpose, padding the shorter with zeroes
  gM          Element wise test if first number >= second number
.A            Are all elements truthy? Implicit print
— सोक
स्रोत
4

जेली , 9 बाइट्स

कक्षाओं को पहले तर्क के रूप में और समूहों को दूसरे तर्क के रूप में लेता है।

Œ!~+Ṡ‘ḌẠ¬

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

टिप्पणी की गई

NB: यह Ṡ‘ḌẠ¬बहुत लंबा है। लेकिन मुझे संदेह है कि यह वैसे भी सही तरीका नहीं है।

Œ!~+Ṡ‘ḌẠ¬  - main link taking the classrooms and the groups e.g. [1,1,2,3], [1,2,3]
Œ!         - computes all permutations of the classrooms    -->  [..., [1,2,3,1], ...]
  ~        - bitwise NOT                                    -->  [..., [-2,-3,-4,-2], ...]
   +       - add the groups to each list; the groups fits   -->  [..., [-1,-1,-1,-2], ...]
             in a given permutation if all resulting values
             are negative
    Ṡ      - take the signs                                 -->  [..., [-1,-1,-1,-1], ...]
     ‘     - increment                                      -->  [..., [0,0,0,0], ...]
      Ḍ    - convert from decimal to integer                -->  [..., 0, ...]
       Ạ   - all truthy?                                    -->  0
        ¬  - logical NOT                                    -->  1
— Arnauld
स्रोत
4

जाप , 9 बाइट्स

ñÍí§Vñn)e

इसे आज़माएं या TIO पर सभी परीक्षण मामलों को चलाएं

ñÍí§Vñn)e     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  í           :Interleave with
    Vñn       :  V sorted by negating each integer
   §          :  Reduce each pair by checking if the first is <= the second
       )      :End interleaving
        e     :All true?

ñÍeȧVn o

इसे आज़माएं या TIO पर सभी परीक्षण मामलों को चलाएं

ñÍeȧVn o     :Implicit input of arrays U=students, V=classrooms
ñ             :Sort U by
 Í            :  Subtracting each integer from 2
  e           :Does every element return true
   È          :When passed through the following function
    §         :  Less than or equal to
     Vn       :  Sort V
        o     :  Pop the last element
— झबरा
स्रोत
जिज्ञासा से बाहर, एक ही बाइट के लिए निर्मित क्यों है 2 - nजाप में? 1-बाइट निर्मित होने का औचित्य साबित करने के लिए किस तरह के उपयोग-मामलों का उपयोग करना पड़ता है?
— केविन क्रूज़सेन
1
अच्छा सवाल है, @ केविनक्रूजसेन। Íके लिए एक शॉर्टकट है n2<space>और इसे स्ट्रिंग्स के साथ उपयोग करने के लिए बनाया गया था, जो उन्हें आधार -2 से बेस -10 नंबर (काफी सामान्य आवश्यकता) में परिवर्तित कर रहा है। हालाँकि, nविधि, जब किसी संख्या पर लागू होती है, तो उस संख्या को विधि के तर्क (डिफ़ॉल्ट = 0) से घटा देती है । तो यहाँ, हालांकि, से घटाना 0विपरीत क्रम में सरणी को सॉर्ट करने के लिए पर्याप्त होगा, शॉर्टकट का उपयोग करके मुझे एक बाइट बचाता है ñn<space>। छँटाई करते समय मैं इसका उपयोग भी कर सकता था, Vलेकिन )इस íविधि को बंद करने के लिए , इसके बजाय मुझे अभी भी एक स्थान की आवश्यकता नहीं है, क्योंकि यह अभी भी एक स्थान की आवश्यकता होगी ।
— झबरा
3

MATL , 10 बाइट्स

yn&Y@>~!Aa

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

आदानों पर विचार करें [20, 10, 30], [20, 20, 50, 40]एक उदाहरण के रूप। स्टैक को नीचे से ऊपर तक दिखाया गया है।

y     % Implicit inputs. Duplicate from below
      % STACK: [20 10 30]
               [20 20 50 40]
               [20 10 30]
n     % Number of elements
      % STACK: [20 10 30]
               [20 20 50 40]
               3
&Y@   % Variations. Gives a matrix, each row is a variation
      % STACK: [20 10 30]
               [20 10 30
                20 20 40
                20 20 40
                ···
                50 40 20]
>~    % Less than? Element-wise with broadcast
      % STACK: [1 1 1
                1 1 1
                1 1 1
                ···
                1 1 0]
!     % Transpose
      % STACK: [1 1 1 ··· 0
                1 1 1 ··· 1
                1 1 1 ··· 1]
A     % All. True for columns that only contain nonzeros
      % STACK: [1 1 1 ··· 0]
a     % Any. True if the row vector contains at least a nonzero. Implicit display
      % STACK: 1
— लुइस मेंडो
स्रोत
3

05AB1E , 14 12 8 बाइट्स

€{í0ζÆdP

पोर्ट @ @ पॉक का जवाब है , इसलिए उसे भी उभारना सुनिश्चित करें!

इनपुट को सूचियों की सूची के रूप में लेता है, कक्षा-सूची को पहले आइटम के रूप में और दूसरे आइटम के रूप में समूह-सूची को।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

€{         # Sort each inner list
  í        # Reverse each inner list
   0ζ      # Zip/transpose; swapping rows/columns, with 0 as filler
     Æ     # For each pair: subtract the group from the classroom
      d    # Check if its non-negative (1 if truthy; 0 if falsey)
       P   # Check if all are truthy by taking the product
           # (and output implicitly)

पुराना 12-बाइट उत्तर:

æε{I{0ζÆdP}à

पहले कक्षा-सूची लेता है, और फिर समूह-सूची।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

æ             # Take the powerset of the (implicit) classroom-list,
              # resulting in a list of all possible sublists of the classrooms
 ε            # Map each classroom sublist to:
  {           #  Sort the sublist
   I{         #  Take the group-list input, and sort it as well
     0ζ       #  Transpose/zip; swapping rows/columns, with 0 as filler
       Æ      #  For each pair: subtract the group from the classroom
        d     #  Check for everything if it's non-negative (1 if truthy; 0 if falsey)
         P    #  Check if all are truthy by taking the product
          }à  # After the map: check if any are truthy by getting the maximum
              # (and output the result implicitly)
— केविन क्रूज़सेन
स्रोत
1
हेह मुझे सुखद आश्चर्य हुआ कि पाइथ ने 05AB1E को एक बदलाव के लिए पीटा था, लेकिन यह पता चला कि यह एल्गोरिथम था: ओ.पी.
— सोक
1
@Sok आपको निराश करने के लिए क्षमा करें। ; पी -4 बाइट्स के लिए धन्यवाद। : डी
— केविन क्रूज़सेन
3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 77 74 बाइट्स

a=>b=>a.Count==a.OrderBy(x=>-x).Zip(b.OrderBy(x=>-x),(x,y)=>x>y?0:1).Sum()

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

टिप्पणी कोड:

// a: student group counts
// b: classroom capacities
a=>b=>
  // compare the number of student
  // groups to...
  a.Count==
  // sort student groups descending
  a.OrderBy(x=>-x)
     // combine with classroom
     // capacities sorted descending
     .Zip(
        b.OrderBy(x=>-x),
        // the result selector 1 when
        // the classroom has enough
        // capacity, 0 when it doesn't
        (x,y)=>x<y?0:1
     )
     // add up the 1's to get the number
     // of student groups who can fit
     // in a classroom
     .Sum()
— दाना
स्रोत
1
मैं इसके लिए एक उचित एक-लाइनर खोजने में सक्षम नहीं था। अच्छी नौकरी!
— अज्ञानता का प्रतीक
2

बैश + जीएनयू उपकरण, 68 बाइट्स

(sort -nr<<<$2|paste -d- - <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

69 बाइट्स

(paste -d- <(sort -nr<<<$2) <(sort -nr<<<$1)|bc|grep -- -)&>/dev/null

TIO

पहली और दूसरी दलील के रूप में छात्र कमरे लेता है जैसे कि स्ट्रिंग संख्याओं को सीमांकित किया जाता है, जो कि वास्तविक या गलत के लिए 0 से बाहर निकलने की स्थिति 1 से बाहर निकलता है

— नहुएल फौलीउल
स्रोत
2

पर्ल 5 -pal , 67 62 बाइट्स

@NahuelFouilleul ने पुनर्व्यवस्था और grep के साथ 5 बाइट्स बचाए

$_=!grep$_>0,map$_-(sort{$b-$a}@F)[$x++],sort{$b-$a}<>=~/\d+/g

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

67 बाइट्स संस्करण

पहली पंक्ति पर वर्ग आकार की अंतरिक्ष अलग सूची बनाता है और अगले पर कमरे के आकार की अंतरिक्ष अलग सूची।

— Xcali
स्रोत
— नहुएल फौलीउल
2

आम लिस्प, 74 बाइट्स

(defun c(s r)(or(not(sort s'>))(and(sort r'>)(<=(pop s)(pop r))(c s r))))

गैर न्यूनतम किया गया

(defun can-students-relocate (students rooms)
  (or (not (sort students #'>))
      (and (sort rooms #'>)
           (<= (pop students)
               (pop rooms))
           (can-students-relocate students rooms))))

झसे आज़माओ

ध्यान दें कि सॉर्ट स्थायी रूप से सूची को बदल देता है, और पॉप अगले तत्व के लिए चर को रिबंड करता है।

इसके प्रभाव में, यह सिर्फ इतना बताता है कि सबसे बड़ा छात्र समूह सबसे बड़े कमरे में फिट हो सकता है। 3 आधार-मामले हैं:

  1. कोई छात्र नहीं - टी वापस
  2. छात्र, लेकिन कोई कमरा नहीं - रिटर्न एनआईएल
  3. छात्र और कमरे, लेकिन सबसे बड़ा छात्र समूह सबसे बड़े कमरे से बड़ा है - रिटर्न एनआईएल
— Charlim
स्रोत
1

रेटिना 0.8.2 , 50 बाइट्स

\d+
$*
%O^`1+
%`$
,
^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण सूट शामिल है। समूहों और कमरों की दो सूची लेता है ( ;सूची विभाजक के रूप में परीक्षण सूट का उपयोग करता है )। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

%O^`1+

प्रत्येक सूची को अलग से क्रमबद्ध करें।

%`$
,

प्रत्येक सूची में एक अल्पविराम जोड़ें।

^((1*,)(?=.*¶((?>\3?)1*\2)))*¶

जांचें कि पहली सूची के प्रत्येक नंबर को दूसरी सूची में उपयुक्त संख्या से मिलान किया जा सकता है। हर बार \3पहले से मिलान किए गए कमरे और अगले समूह शामिल होते हैं \2इसलिए अगले कमरे में फिट होने में सक्षम होना चाहिए। (?>\3?)हैंडल पहले कमरे के मामले जब वहाँ कोई पिछले कमरे अभी तक कर रहे हैं।

— नील
स्रोत
1

चारकोल , 28 बाइट्स

Ｗ∧⌊講⌈§θ¹⌈§θ⁰ＵＭθΦκ⁻ν⌕κ⌈κ¬⊟θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। -यदि कमरे समूहों को समायोजित कर सकते हैं, तो कमरे और समूहों और आउटपुट की सूची की एक सूची लेता है । स्पष्टीकरण:

Ｗ∧⌊講⌈§θ¹⌈§θ⁰

दोहराएं जबकि एक समूह को एक कमरे में सौंपा जा सकता है।

ＵＭθΦκ⁻ν⌕κ⌈κ

उनकी सूची से सबसे बड़ा कमरा और समूह निकालें।

¬⊟θ

जाँच लें कि कोई असंबद्ध समूह शेष नहीं हैं।

— नील
स्रोत
1

जावास्क्रिप्ट, 56 बाइट्स

s=>c=>s.sort(g=(x,y)=>y-x).every((x,y)=>c.sort(g)[y]>=x)

कोशिश करो

— झबरा
स्रोत
के समूहों के लिए विफल रहता है 7और 9की कक्षाओं में 8और 10।
— नील
यह इंगित करने के लिए धन्यवाद, @ नील। मैं सोचता था कि क्या नग्न गधा मुझे गधे में काटने के लिए वापस नहीं आएगा! जब तक मुझे फिर से कोशिश करने का समय नहीं मिल जाता, तब तक मुझे अपने मूल समाधान में वापस आना होगा।
— झबरा
1

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

{none [Z>] $_>>.sort(-*)>>[^.[0]]}

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

इनपुट को दो सूचियों, समूहों और कक्षाओं की सूची के रूप में लेता है, और कोई भी जंक्शन नहीं देता है जिसे सही / गलत माना जा सकता है।

स्पष्टीकरण:

{                                }   # Anonymous code block
           $_>>.sort(-*)             # Sort both lists from largest to smallest
                        >>[^.[0]]    # Pad both lists to the length of the first list
 none                                # Are none of
      [Z>]                           # The groups larger than the assigned classroom
— मजाक कर रहा है
स्रोत
1

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

->c,r{r.permutation.any?{|p|c.zip(p).all?{|a,b|b&&a<=b}}}

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

कमरों के लिए c, कक्षाओं के लिए ले जाता है r। सॉर्ट का उपयोग करने के बजाय कमरों के सभी क्रमपरिवर्तन की जांच करता है, क्योंकि रिवर्स सॉर्टिंग में कई बाइट्स खर्च होते हैं। हालांकि अभी भी लंबे समय लग रहा है ...

— किरिल एल।
स्रोत
1

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 105 93 91 82 81 79 77 76 74 बाइट्स

अब डाना के स्कोर से मेल खाता है!

n=>m=>{n.Sort();m.Sort();int i=m.Count-n.Count;i/=n.Any(b=>m[i++]<b)?0:1;}

असत्य को फेंकता है यदि असत्य, सत्य नहीं तो कुछ नहीं।

-12 बाइट्स @Destrogio को धन्यवाद!

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

व्याख्या

//Function taking in a list, and returning another function
//that takes in a list and doesn't return
n=>m=>{
  //Sort the student groups from smallest to largest
  n.Sort();
  //Sort the classrooms fom smallest capacity to largest
  m.Sort();
  //Initialize a variable that will function as a sort of index
  int i=m.Count-n.Count;
  //And divide that by...
  i/=
    //0 if any of the student groups...
    n.Any(b=>
      //Don't fit into the corresponding classroom and incrementing i in the process
      /*(In the case that a the amount of classrooms are less than the amount of
      student groups, an IndexOutOfRangeException is thrown)*/
      m[i++]<b)?0
    //Else divide by 1
    :1;
}
— अज्ञान का अवतार
स्रोत
— डेस्ट्रोइगो
1
@Destrogio धन्यवाद!
— को अज्ञानता
0

जावा (ओपनजेडके 8) , 183 बाइट्स

a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return false;}for(int i=0;i<b;i++){if(a[0][i]>a[1][i]){return false;}}return true;}

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

केविन क्रूज़सेन से थोड़ी मददगार सलाह और अपने कोड पर बस एक और नज़र के साथ, मैं केवल तीन अंग्रेजी शब्दों को बदलकर अपने स्कोर को पूरे ९% तक कम कर सकता हूँ!

जावा (ओपनजेडके 8) , 166 बाइट्स

a->{int b=a[0].length;Arrays.sort(a[0]);Arrays.sort(a[1]);if(b>a[1].length){return 0;}for(int i=0;i<b;){if(a[0][i]>a[1][i++]){return 0;}}return 1;}

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

— X1M4L
स्रोत
आपको import java.util.*;अपनी बाइट-गिनती में शामिल करना होगा । हालाँकि आप इसे जावा 8 में 144 बाइट्स के साथ गोल्फिंग कर सकते हैं या जावा 10 में 140 के booleanसाथ बदल सकते हैं var।
— केविन क्रूज़सेन
पुनश्च: आप की जरूरत है, तो true/ falseअपने कोड में, 1>0/ 0>1कम विकल्प हैं । :)
— केविन क्रूज़सेन
वास्तव में, मुझे अपनी गिनती में अतिरिक्त 24 बाइट्स को शामिल करना याद था! (मेरा मानना ​​है कि यह आपको सूचित किया गया था कि मुझे उस नियम के महीने पहले XD), लेकिन टिप के लिए धन्यवाद! बीमार इसे एक शॉट दे दो!
— X1M4L
3
यह अंतिम परीक्षण मामले में विफल रहता है।
— झबरा
अपने 166-बाइट संस्करण के बारे में: यद्यपि आप जिस राज्य में वापस लौट सकते हैं 1/0और मुझे लगता है कि इस मामले में यह ठीक है, कृपया ध्यान दें कि जावा में पाइथन, जावास्क्रिप्ट, सी आदि के विपरीत, 1/0आमतौर पर वैध सत्य / गलत आउटपुट के रूप में नहीं माना जाता है । और अपनी पहली टिप्पणी में मैंने 144-बाइट्स संस्करण का उल्लेख किया । :) हालांकि, यह अब भी अमान्य है क्योंकि यह अंतिम परीक्षण मामले के लिए काम नहीं करता है, जैसा कि @Saggy द्वारा उल्लेख किया गया है ।
— केविन क्रूज़सेन
0

पॉवरशेल , 80 बाइट्स

param($s,$c)!($s|sort -d|?{$_-gt($r=$c|?{$_-notin$o}|sort|select -l 1);$o+=,$r})

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

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

param($students,$classrooms)
$x=$students|sort -Descending|where{          
    $freeRoomWithMaxCapacity = $classrooms|where{$_ -notin $occupied}|sort|select -Last 1
    $occupied += ,$freeRoomWithMaxCapacity    # append to the array
    $_ -gt $freeRoomWithMaxCapacity           # -gt means 'greater than'. It's a predicate for the 'where'
}                                             # $x contains student groups not assigned to a relevant classroom
!$x                                           # this function returns a true if $x is empty

}

@(
    ,(@(10, 20, 30), @(31, 12, 20), $true)
    ,(@(10, 20, 30), @(100, 200), $False)
    ,(@(20, 10, 30), @(20, 20, 50, 40), $True)
    ,(@(30, 10, 30, 5, 100, 99), @(40, 20, 50, 40, 99, 99), $False)
    ,(@(), @(10, 10, 10), $True)
    ,(@(10, 10, 10), @(), $False)
    ,(@(), @(), $True)
    ,(@(10, 1), @(100), $False)
    ,(@(10), @(100, 100), $True)
    ,(@(1,2,3), @(1,1,2,3), $True)
) | % {
    $students, $classrooms, $expected = $_
    $result = &$f $students $classrooms
    "$($result-eq$expected): $result"
}
— Mazzy
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.