task_id large_stringlengths 11 13 | prompt large_stringlengths 115 1.36k | canonical_solution large_stringlengths 16 864 | test large_stringlengths 117 1.8k | entry_point large_stringlengths 1 30 | prompt_Assamese_translation large_stringlengths 119 1.39k | prompt_Bengali_translation large_stringlengths 120 1.52k | prompt_Gujarati_translation large_stringlengths 124 1.37k | prompt_Hindi_translation large_stringlengths 120 1.38k | prompt_Kannada_translation large_stringlengths 128 1.5k | prompt_Malayalam_translation large_stringlengths 124 1.58k | prompt_Marathi_translation large_stringlengths 126 1.43k | prompt_Nepali_translation large_stringlengths 122 1.47k | prompt_Odia_translation large_stringlengths 126 1.49k | prompt_Punjabi_translation large_stringlengths 120 1.35k | prompt_Sanskrit_translation large_stringlengths 130 1.47k | prompt_Tamil_translation large_stringlengths 134 1.65k | prompt_Telugu_translation large_stringlengths 126 1.43k | prompt_Urdu_translation large_stringlengths 120 1.43k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
HumanEval/0 | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" Check if in given list of numbers, are any two numbers closer to each other than
given threshold.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5.0, ... | for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
distance = abs(elem - elem2)
if distance < threshold:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.3) == True
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2], 0.05) == False
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0], 0.95) == True
assert candidate([1.0, 2.0, 5.9, 4.0,... | has_close_elements | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" প্ৰদত্ত সংখ্যাৰ তালিকাত, কোনো দুটা সংখ্যা প্ৰদত্ত threshold-তকৈ পৰস্পৰৰ
অধিক ওচৰত আছেনে নাই পৰীক্ষা কৰক।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" প্রদত্ত সংখ্যার তালিকায় এমন কোনো দুটি সংখ্যা আছে কিনা পরীক্ষা করুন যা প্রদত্ত threshold-এর চেয়ে পরস্পরের বেশি কাছাকাছি।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, ... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" આપેલી સંખ્યાઓની યાદીમાં, શું કોઈપણ બે સંખ્યાઓ આપેલ threshold કરતાં એકબીજાની વધુ નજીક છે કે નહીં તે તપાસો.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, 4.0, 5... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" जाँच करें कि क्या दी गई संख्याओं की सूची में, कोई भी दो संख्याएँ दिए गए threshold की तुलना में
एक-दूसरे के अधिक करीब हैं।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" ಕೊಟ್ಟಿರುವ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯಲ್ಲಿ, ಯಾವುದೇ ಎರಡು ಸಂಖ್ಯೆಗಳು ಕೊಟ್ಟಿರುವ threshold ಗಿಂತ
ಪರಸ್ಪರ ಹತ್ತಿರದಲ್ಲಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" നൽകിയിട്ടുള്ള സംഖ്യകളുടെ ലിസ്റ്റിൽ, ഏതെങ്കിലും രണ്ട് സംഖ്യകൾ തമ്മിലുള്ള അകലം തന്നിരിക്കുന്ന
threshold-നേക്കാൾ കുറവാണോ എന്ന് പരിശോധിക്കുക.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_c... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" दिलेल्या संख्यांच्या सूचीमध्ये, कोणत्याही दोन संख्या दिलेल्या threshold पेक्षा
एकमेकांच्या अधिक जवळ आहेत का ते तपासा.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, ... | टाइपिङ इम्पोर्ट सूचीबाट लिइएको
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" दिइएको संख्याहरूको सूचीमा, कुनै दुई संख्याहरू दिइएको सीमा भन्दा नजिक
छन् कि छैनन् भनी जाँच गर्नुहोस्।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0, ... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" ଦିଆଯାଇଥିବା ସଂଖ୍ୟାଗୁଡ଼ିକର ତାଲିକାରେ, କୌଣସି ଦୁଇଟି ସଂଖ୍ୟା ପରସ୍ପର ସହିତ ପ୍ରଦତ୍ତ threshold
ଠାରୁ ଅଧିକ ନିକଟତର କି ନାହିଁ ତାହା ଯାଞ୍ଚ କରନ୍ତୁ।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elem... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦਿੱਤੀ ਗਈ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ, ਕੋਈ ਵੀ ਦੋ ਸੰਖਿਆਵਾਂ ਦਿੱਤੇ ਗਏ threshold ਨਾਲੋਂ
ਇੱਕ ਦੂਜੇ ਦੇ ਜ਼ਿਆਦਾ ਨੇੜੇ ਹਨ।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0,... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" दत्तायां संख्यानां सूच्यां किमपि संख्याद्वयं दत्तमर्यादायाः (threshold) अपेक्षया परस्परम्
अधिकसमीपे वर्तते वा इति परीक्षताम्।
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_element... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" கொடுக்கப்பட்ட எண்களின் பட்டியலில், ஏதேனும் இரண்டு எண்கள் கொடுக்கப்பட்ட threshold-ஐ
விட ஒன்றுக்கொன்று நெருக்கமாக உள்ளனவா என்பதைச் சரிபார்க்கவும்.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" ఇచ్చిన సంఖ్యల జాబితాలో, ఏవైనా రెండు సంఖ్యలు ఇచ్చిన threshold కంటే ఒకదానికొకటి దగ్గరగా
ఉన్నాయో లేదో తనిఖీ చేయండి.
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, ... | from typing import List
def has_close_elements(numbers: List[float], threshold: float) -> bool:
""" چیک کریں کہ آیا دی گئی اعداد کی فہرست میں کوئی سے دو اعداد دیے گئے
threshold سے زیادہ ایک دوسرے کے قریب ہیں۔
>>> has_close_elements([1.0, 2.0, 3.0], 0.5)
False
>>> has_close_elements([1.0, 2.8, 3.0,... |
HumanEval/1 | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" Input to this function is a string containing multiple groups of nested parentheses. Your goal is to
separate those group into separate strings and return the list of those.
Separate groups are balanced (each open brace... | result = []
current_string = []
current_depth = 0
for c in paren_string:
if c == '(':
current_depth += 1
current_string.append(c)
elif c == ')':
current_depth -= 1
current_string.append(c)
if current_depth == 0:
... |
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [
'(()())', '((()))', '()', '((())()())'
]
assert candidate('() (()) ((())) (((())))') == [
'()', '(())', '((()))', '(((())))'
]
assert candidate('(()... | separate_paren_groups | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" এই ফাংশনলৈ ইনপুট হৈছে নেষ্টেড বন্ধনীৰ একাধিক গোট থকা এটা ষ্ট্ৰিং। আপোনাৰ লক্ষ্য হৈছে
সেই গোটবোৰক পৃথক ষ্ট্ৰিঙলৈ পৃথক কৰা আৰু সেইবোৰৰ তালিকাখন ওভতাই দিয়া।
পৃথক গোটবোৰ সন্তুলিত (প্ৰতিটো খোলা বন্ধনী সঠিকভাৱে বন্ধ কৰা হৈছে... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" এই ফাংশনের ইনপুট হলো নেস্টেড বন্ধনীর একাধিক গ্রুপ ধারণকারী একটি স্ট্রিং। আপনার লক্ষ্য হলো
সেই গ্রুপগুলোকে পৃথক স্ট্রিংয়ে আলাদা করা এবং সেগুলির তালিকা রিটার্ন করা।
পৃথক গ্রুপগুলো ব্যালান্সড (প্রতিটি ওপেন বন্ধনী সঠিকভাবে... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" આ ફંક્શનનું ઇનપુટ નેસ્ટેડ કૌંસના બહુવિધ જૂથો ધરાવતી એક સ્ટ્રિંગ છે. તમારો ધ્યેય
તે જૂથોને અલગ સ્ટ્રિંગ્સમાં વિભાજિત કરવાનો અને તેની લિસ્ટ પરત કરવાનો છે.
અલગ જૂથો સંતુલિત (દરેક ખુલ્લો કૌંસ યોગ્ય રીતે બંધ થયેલ છે) હોય છે ... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" इस फ़ंक्शन का इनपुट नेस्टेड कोष्ठकों (nested parentheses) के कई समूहों से युक्त एक स्ट्रिंग है। आपका लक्ष्य
उन समूहों को अलग-अलग स्ट्रिंग्स में अलग करना और उनकी सूची वापस करना है।
अलग समूह संतुलित (प्रत्येक खुला कोष्ठक ... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" ಈ ಫಂಕ್ಷನ್ಗೆ ನೀಡಲಾಗುವ ಇನ್ಪುಟ್ ನೆಸ್ಟೆಡ್ ಆವರಣಗಳ (nested parentheses) ಅನೇಕ ಗುಂಪುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ. ನಿಮ್ಮ ಗುರಿಯು
ಆ ಗುಂಪುಗಳನ್ನು ಪ್ರತ್ಯೇಕ ಸ್ಟ್ರಿಂಗ್ಗಳಾಗಿ ಬೇರ್ಪಡಿಸುವುದು ಮತ್ತು ಅವುಗಳ ಲಿಸ್ಟ್ ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡುವು... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" ഈ ഫംഗ്ഷനിലേക്കുള്ള ഇൻപുട്ട് നെസ്റ്റഡ് പാരന്തീസിസുകളുടെ ഒന്നിലധികം ഗ്രൂപ്പുകൾ അടങ്ങിയ ഒരു സ്ട്രിംഗ് ആണ്. ആ
ഗ്രൂപ്പുകളെ പ്രത്യേക സ്ട്രിംഗുകളായി വേർതിരിച്ച് അവയുടെ ഒരു ലിസ്റ്റ് നൽകുക എന്നതാണ് നിങ്ങളുടെ ലക്ഷ്യം.
ഓരോ പ്രത്യേ... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" या फंक्शनचे इनपुट नेस्टेड पॅरेंथेसिसचे अनेक गट असलेली एक स्ट्रिंग आहे. आपले ध्येय ते
गट वेगवेगळ्या स्ट्रिंग्समध्ये वेगळे करणे आणि त्यांची लिस्ट परत करणे हे आहे.
स्वतंत्र गट हे संतुलित (प्रत्येक उघडलेला कंस योग्यरित्या ब... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" यस प्रकार्यको इनपुट नेस्टेड कोष्ठकहरू (nested parentheses) का धेरै समूहहरू भएको एउटा स्ट्रिङ हो। तपाईंको लक्ष्य
ती समूहहरूलाई छुट्टाछुट्टै स्ट्रिङहरूमा अलग गर्नु र तिनीहरूको सूची फिर्ता गर्नु हो।
अलग गरिएका समूहहरू सन्त... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" ଏହି ଫଙ୍କସନ୍ର ଇନପୁଟ୍ ହେଉଛି ଏକ string ଯେଉଁଥିରେ nested parentheses ର ଏକାଧିକ ଗ୍ରୁପ୍ ରହିଛି। ଆପଣଙ୍କର ଲକ୍ଷ୍ୟ ହେଉଛି
ସେହି ଗ୍ରୁପ୍ଗୁଡ଼ିକୁ ପୃଥକ string ରେ ବିଭାଜନ କରିବା ଏବଂ ସେଗୁଡ଼ିକର list ଫେରାଇବା।
ପୃଥକ ଗ୍ରୁପ୍ଗୁଡ଼ିକ ସନ୍ତୁଳିତ (ପ୍ରତ୍... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਇਨਪੁਟ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਜਿਸ ਵਿੱਚ ਨੇਸਟਡ ਬਰੈਕਟਾਂ (nested parentheses) ਦੇ ਕਈ ਗਰੁੱਪ ਹਨ। ਤੁਹਾਡਾ ਟੀਚਾ
ਉਹਨਾਂ ਗਰੁੱਪਾਂ ਨੂੰ ਵੱਖਰੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਵਿੱਚ ਵੱਖ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰਨਾ ਹੈ।
ਵੱਖਰੇ ਗਰੁੱਪ ਸੰਤੁਲਿਤ ਹਨ (ਹਰੇਕ ਖੁ... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" अस्य फलनस्य निवेशः एका पङ्क्तिः (string) अस्ति यस्यां संनिहित-कोष्ठकानां (nested parentheses) बहवः समूहाः सन्ति। भवतः लक्ष्यं
तान् समूहान् पृथक् पङ्क्तिषु विभज्य तेषां सूचीं (list) प्रतिदातुम् अस्ति।
पृथक् समूहाः सन्तुल... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" இந்தச் சார்பிற்கான உள்ளீடு பல குழுக்களாக உள்ளமைக்கப்பட்ட அடைப்புக்குறிகளைக் (nested parentheses) கொண்ட ஒரு சரம் (string) ஆகும். அக்குழுக்களைத் தனித்தனிச் சரங்களாகப் பிரித்து, அவற்றின் பட்டியலைத் தருவதே உங்கள் இலக்காகும்.
தன... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" ఈ ఫంక్షన్కు ఇన్పుట్ బహుళ సమూహాల నెస్టెడ్ బ్రాకెట్లను (parentheses) కలిగి ఉన్న ఒక స్ట్రింగ్. ఆ సమూహాలను
వేర్వేరు స్ట్రింగ్లుగా వేరు చేసి, వాటి లిస్ట్ను రిటర్న్ చేయడం మీ లక్ష్యం.
ప్రత్యేక సమూహాలు బ్యాలెన్స్డ్గా ఉంట... | from typing import List
def separate_paren_groups(paren_string: str) -> List[str]:
""" اس فنکشن کا ان پٹ ایک سٹرنگ ہے جس میں نیسٹڈ بریکٹس (nested parentheses) کے متعدد گروپس شامل ہیں۔ آپ کا مقصد
ان گروپس کو الگ الگ سٹرنگز میں تقسیم کرنا اور ان کی لسٹ واپس کرنا ہے۔
علیحدہ گروپس متوازن ہیں (ہر کھلنے والی بر... |
HumanEval/2 |
def truncate_number(number: float) -> float:
""" Given a positive floating point number, it can be decomposed into
and integer part (largest integer smaller than given number) and decimals
(leftover part always smaller than 1).
Return the decimal part of the number.
>>> truncate_number(3.5)
0... | return number % 1.0
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3.5) == 0.5
assert abs(candidate(1.33) - 0.33) < 1e-6
assert abs(candidate(123.456) - 0.456) < 1e-6
| truncate_number |
def truncate_number(number: float) -> float:
""" এটা ধনাত্মক ফ্লটিং পইণ্ট সংখ্যা দিয়া থাকিলে, ইয়াক এটা অখণ্ড অংশ
(প্ৰদত্ত সংখ্যাটোতকৈ সৰু সৰ্ববৃহৎ অখণ্ড সংখ্যা) আৰু দশমিক অংশত
(বাকী থকা অংশ যি সদায় 1 তকৈ সৰু) ভাগ কৰিব পাৰি।
সংখ্যাটোৰ দশমিক অংশটো ওভতাই দিয়ক।
>>> truncate_number(3.5)
0.5
... |
def truncate_number(number: float) -> float:
""" একটি ধনাত্মক floating point সংখ্যা দেওয়া থাকলে, সেটিকে একটি পূর্ণসংখ্যা
অংশে (প্রদত্ত সংখ্যার চেয়ে ছোট বৃহত্তম পূর্ণসংখ্যা) এবং দশমিক অংশে
(অবশিষ্টাংশ যা সর্বদা 1-এর চেয়ে ছোট) বিভক্ত করা যেতে পারে।
সংখ্যাটির দশমিক অংশটি রিটার্ন করুন।
>>> truncate_n... |
def truncate_number(number: float) -> float:
""" આપેલ ધન ફ્લોટિંગ પોઈન્ટ સંખ્યાને પૂર્ણાંક ભાગ (આપેલી સંખ્યા કરતાં નાનો સૌથી મોટો પૂર્ણાંક) અને દશાંશ ભાગ (બાકી રહેલો ભાગ જે હંમેશા 1 કરતાં નાનો હોય) માં વિભાજિત કરી શકાય છે.
સંખ્યાનો દશાંશ ભાગ પરત કરો.
>>> truncate_number(3.5)
0.5
"""
|
def truncate_number(number: float) -> float:
""" एक धनात्मक floating point संख्या दिए जाने पर, इसे एक पूर्णांक भाग (दी गई संख्या से छोटा सबसे बड़ा पूर्णांक) और दशमलव भाग (शेष भाग जो हमेशा 1 से छोटा होता है) में विघटित किया जा सकता है।
संख्या का दशमलव भाग लौटाएं।
>>> truncate_number(3.5)
0.5
"""
|
def truncate_number(number: float) -> float:
""" ಒಂದು ಧನಾತ್ಮಕ floating point ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿದಾಗ, ಅದನ್ನು
ಪೂರ್ಣಾಂಕ ಭಾಗ (ನೀಡಿರುವ ಸಂಖ್ಯೆಗಿಂತ ಚಿಕ್ಕದಾದ ಅತಿ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕ) ಮತ್ತು ದಶಮಾಂಶಗಳಾಗಿ
(ಯಾವಾಗಲೂ 1 ಕ್ಕಿಂತ ಚಿಕ್ಕದಾದ ಉಳಿದ ಭಾಗ) ವಿಭಜಿಸಬಹುದು.
ಸಂಖ್ಯೆಯ ದಶಮಾಂಶ ಭಾಗವನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ.
>>> truncate_number(3.5)... |
def truncate_number(number: float) -> float:
""" ഒരു പോസിറ്റീവ് floating point സംഖ്യ നൽകിയാൽ, അതിനെ ഒരു
പൂർണ്ണസംഖ്യാ ഭാഗമായും (തന്നിരിക്കുന്ന സംഖ്യയേക്കാൾ ചെറുതായ ഏറ്റവും വലിയ പൂർണ്ണസംഖ്യ) ദശാംശ ഭാഗമായും
(എപ്പോഴും 1-ൽ ചെറുതായ ബാക്കി ഭാഗം) വിഭജിക്കാൻ കഴിയും.
സംഖ്യയുടെ ദശാംശ ഭാഗം തിരികെ നൽകുക.
>>> ... |
def truncate_number(number: float) -> float:
""" एक धन फ्लोटिंग पॉइंट संख्या दिली असता, तिचे पूर्णांक भाग
(दिलेल्या संख्येपेक्षा लहान असलेला सर्वात मोठा पूर्णांक) आणि दशांश भाग
(उरलेला भाग जो नेहमी 1 पेक्षा लहान असतो) यात विघटन केले जाऊ शकते.
संख्येचा दशांश भाग परत करा.
>>> truncate_number(3.5)
... |
def truncate_number(number: float) -> float:
""" दिइएको धनात्मक floating point सङ्ख्यालाई पूर्णाङ्क भाग (दिइएको सङ्ख्याभन्दा सानो सबैभन्दा ठूलो पूर्णाङ्क) र दशमलव भाग (सधैं 1 भन्दा सानो हुने बाँकी भाग) मा विभाजन गर्न सकिन्छ।
सङ्ख्याको दशमलव भाग फिर्ता गर्नुहोस्।
>>> truncate_number(3.5)
0.5
"""
|
def truncate_number(number: float) -> float:
""" ଗୋଟିଏ ଧନାତ୍ମକ floating point ସଂଖ୍ୟା ଦିଆଗଲେ, ଏହାକୁ ଏକ ପୂର୍ଣ୍ଣସଂଖ୍ୟା ଅଂଶ (ଦିଆଯାଇଥିବା ସଂଖ୍ୟାଠାରୁ ଛୋଟ ବୃହତ୍ତମ ପୂର୍ଣ୍ଣସଂଖ୍ୟା) ଏବଂ ଦଶମିକ ଅଂଶ (ଅବଶିଷ୍ଟ ଅଂଶ ଯାହା ସର୍ବଦା 1 ଠାରୁ ଛୋଟ) ରେ ବିଭକ୍ତ କରାଯାଇପାରିବ।
ସଂଖ୍ୟାଟିର ଦଶମିକ ଅଂଶ ଫେରାନ୍ତୁ।
>>> truncate_number(3.5)
0.... |
def truncate_number(number: float) -> float:
""" ਦਿੱਤੇ ਗਏ ਇੱਕ ਧਨਾਤਮਕ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰ ਨੂੰ ਇੱਕ ਪੂਰਨ ਅੰਕ ਭਾਗ (ਦਿੱਤੇ ਗਏ ਨੰਬਰ ਤੋਂ ਛੋਟਾ ਸਭ ਤੋਂ ਵੱਡਾ ਪੂਰਨ ਅੰਕ) ਅਤੇ ਦਸ਼ਮਲਵ ਭਾਗ (ਬਚਿਆ ਹੋਇਆ ਹਿੱਸਾ ਜੋ ਹਮੇਸ਼ਾ 1 ਤੋਂ ਛੋਟਾ ਹੁੰਦਾ ਹੈ) ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਨੰਬਰ ਦਾ ਦਸ਼ਮਲਵ ਭਾਗ ਵਾਪਸ ਕਰੋ।
>>> truncate_number(3.5)
0.5
... |
def truncate_number(number: float) -> float:
""" दत्तं धन-चलबिन्दुसङ्ख्याम् (positive floating point number) एकांशतः पूर्णाङ्कभागे (दत्तसङ्ख्यातः लघुतरः महत्तमः पूर्णाङ्कः) तथा दशांशभागे (1 तः सर्वदा न्यूनः अवशिष्टः भागः) विभक्तुं शक्यते।
सङ्ख्यायाः दशांशभागं प्रत्यायच्छतु।
>>> truncate_number(3.5)
0... |
def truncate_number(number: float) -> float:
""" கொடுக்கப்பட்ட ஒரு நேர்மறை floating point எண்ணை, முழு எண் பகுதியாகவும் (கொடுக்கப்பட்ட எண்ணை விடச் சிறிய மிகப்பெரிய முழு எண்) மற்றும் தசமப் பகுதியாகவும் (எப்போதும் 1-ஐ விடச் சிறிய மீதமுள்ள பகுதி) பிரிக்க முடியும்.
அந்த எண்ணின் தசமப் பகுதியைத் திருப்பியளிக்கவும்.... |
def truncate_number(number: float) -> float:
""" ఒక ధనాత్మక ఫ్లోటింగ్ పాయింట్ సంఖ్య ఇవ్వబడినప్పుడు, దానిని
పూర్ణాంక భాగం (ఇచ్చిన సంఖ్య కంటే చిన్నదైన అతిపెద్ద పూర్ణాంకం) మరియు దశాంశాలుగా
(ఎల్లప్పుడూ 1 కంటే చిన్నదిగా ఉండే మిగిలిన భాగం) విభజించవచ్చు.
సంఖ్య యొక్క దశాంశ భాగాన్ని రిటర్న్ చేయండి.
>>> tr... |
def truncate_number(number: float) -> float:
""" ایک مثبت floating point نمبر دیا گیا ہے، اسے ایک صحیح عددی حصے (دیے گئے نمبر سے چھوٹا سب سے بڑا integer) اور اعشاری حصے (باقی ماندہ حصہ جو ہمیشہ 1 سے چھوٹا ہوتا ہے) میں تقسیم کیا جا سکتا ہے۔
نمبر کا اعشاری (decimal) حصہ واپس کریں۔
>>> truncate_number(3.5)
... |
HumanEval/3 | from typing import List
def below_zero(operations: List[int]) -> bool:
""" You're given a list of deposit and withdrawal operations on a bank account that starts with
zero balance. Your task is to detect if at any point the balance of account fallls below zero, and
at that point function should return Tru... | balance = 0
for op in operations:
balance += op
if balance < 0:
return True
return False
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == False
assert candidate([1, 2, -3, 1, 2, -3]) == False
assert candidate([1, 2, -4, 5, 6]) == True
assert candidate([1, -1, 2, -2, 5, -5, 4, -4]) == False
assert candidate([1, -1, 2, -2, 5, -5, 4... | below_zero | from typing import List
def below_zero(operations: List[int]) -> bool:
""" আপোনাক এটা বেংক একাউন্টৰ জমা আৰু উলিওৱাৰ কাৰ্যকলাপৰ এখন তালিকা দিয়া হৈছে যিটো
শূন্য বেলেঞ্চৰ পৰা আৰম্ভ হয়। আপোনাৰ কাম হৈছে কোনো এটা মুহূৰ্ততো একাউন্টৰ বেলেঞ্চ শূন্যৰ তললৈ নামি যায় নেকি সেয়া চিনাক্ত কৰা, আৰু
সেই মুহূৰ্তত ফলনটোৱে... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" আপনাকে একটি ব্যাংক অ্যাকাউন্টে জমা এবং উত্তোলনের অপারেশনের একটি তালিকা দেওয়া হয়েছে যা শূন্য
ব্যালেন্স দিয়ে শুরু হয়। আপনার কাজ হলো কোনো এক মুহূর্তে অ্যাকাউন্টের ব্যালেন্স শূন্যের নিচে নেমে যায় কিনা তা শনাক্ত করা, এবং
সেই মুহূর্তে ফা... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" તમને શૂન્ય બેલેન્સ સાથે શરૂ થતા એક બેંક ખાતા પર ડિપોઝિટ અને ઉપાડના operations ની એક સૂચિ આપવામાં આવેલ છે. તમારું કાર્ય એ શોધવાનું છે કે શું કોઈપણ સમયે ખાતાનું બેલેન્સ શૂન્યથી નીચે જાય છે, અને તે સમયે ફંક્શને True રિટર્ન કરવું જોઈએ. અન્યથા ... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" आपको एक बैंक खाते पर जमा और निकासी संचालनों (deposit and withdrawal operations) की एक सूची दी गई है जो
शून्य बैलेंस से शुरू होता है। आपका कार्य यह पता लगाना है कि क्या किसी भी बिंदु पर खाते का बैलेंस शून्य से नीचे जाता है, और
उस बि... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" ಶೂನ್ಯ ಬ್ಯಾಲೆನ್ಸ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಬ್ಯಾಂಕ್ ಖಾತೆಯ ಠೇವಣಿ ಮತ್ತು ಹಿಂಪಡೆಯುವಿಕೆಯ ಕಾರ್ಯಾಚರಣೆಗಳ ಪಟ್ಟಿಯನ್ನು ನಿಮಗೆ ನೀಡಲಾಗಿದೆ. ಯಾವುದೇ ಹಂತದಲ್ಲಾದರೂ ಖಾತೆಯ ಬ್ಯಾಲೆನ್ಸ್ ಶೂನ್ಯಕ್ಕಿಂತ ಕೆಳಗೆ ಇಳಿಯುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ, ಮತ್ತು ಆ ಹ... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" പൂജ്യം ബാലൻസോടെ ആരംഭിക്കുന്ന ഒരു ബാങ്ക് അക്കൗണ്ടിലെ ഡെപ്പോസിറ്റ്, വിത്ത്ഡ്രോവൽ ഇടപാടുകളുടെ ഒരു ലിസ്റ്റ് നിങ്ങൾക്ക് നൽകിയിരിക്കുന്നു. ഏതെങ്കിലും ഘട്ടത്തിൽ അക്കൗണ്ട് ബാലൻസ് പൂജ്യത്തിന് താഴെയാകുന്നുണ്ടോ എന്ന് കണ്ടെത്തുകയാണ് നിങ്ങളുടെ ദൗത്യം, ... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" तुम्हाला शून्य शिलकीने (zero balance) सुरू होणाऱ्या बँक खात्यावरील डिपॉझिट आणि विथड्रॉव्हल ऑपरेशन्सची एक लिस्ट दिली आहे. तुमचे काम कोणत्याही क्षणी खात्यातील शिल्लक शून्यापेक्षा कमी होते का हे ओळखणे आहे, आणि त्या क्षणी फंक्शनने True रिटर्न ... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" तपाईंलाई शून्य ब्यालेन्सबाट सुरु हुने बैंक खातामा रकम जम्मा (deposit) र निकाल्ने (withdrawal) अपरेसनहरूको एउटा सूची दिइएको छ। तपाईंको कार्य कुनै पनि विन्दुमा खाताको ब्यालेन्स शून्यभन्दा तल झर्छ कि झर्दैन पत्ता लगाउनु हो, र त्यो विन्दुमा प्... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" ଆପଣଙ୍କୁ ଏକ ବ୍ୟାଙ୍କ ଖାତାରେ ଜମା ଏବଂ ଉଠାଣ କାର୍ଯ୍ୟର ଏକ ତାଲିକା ଦିଆଯାଇଛି ଯାହା ଶୂନ
ବାଲାନ୍ସରୁ ଆରମ୍ଭ ହୁଏ। ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି କୌଣସି ମୁହୂର୍ତ୍ତରେ ଖାତାର ବାଲାନ୍ସ ଶୂନରୁ କମ୍ ହେଉଛି କି ନାହିଁ ତାହା ଜାଣିବା, ଏବଂ
ସେହି ସମୟରେ ଫଙ୍କସନ୍ True ଫେରାଇବା ଉଚିତ। ଅ... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" ਤੁਹਾਨੂੰ ਇੱਕ ਬੈਂਕ ਖਾਤੇ 'ਤੇ ਜਮ੍ਹਾਂ ਅਤੇ ਨਿਕਾਸੀ ਦੇ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦਿੱਤੀ ਗਈ ਹੈ ਜੋ
ਜ਼ੀਰੋ ਬੈਲੇਂਸ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਤੁਹਾਡਾ ਕੰਮ ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਹੈ ਕਿ ਕੀ ਕਿਸੇ ਵੀ ਸਮੇਂ ਖਾਤੇ ਦਾ ਬੈਲੇਂਸ ਜ਼ੀਰੋ ਤੋਂ ਹੇਠਾਂ ਜਾਂਦਾ ਹੈ, ਅਤੇ
ਉਸ ਸਮੇਂ ਫੰਕਸ਼ਨ ਨੂੰ Tru... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" भवते शून्यशेषेण सह आरभ्यमाणस्य कस्यचित् अधिकोषलेखायाः निक्षेप-आहरण-क्रियाणां
सूची दत्ता वर्तते। भवतः कार्यं वर्तते यत् कस्मिंश्चिदपि क्षणे लेखायाः शेषः शून्यात् न्यूनः भवति वा इति अन्वेषणम्,
तस्मिन् क्षणे च फलेन True इति प्रतिदेयम्... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" பூஜ்ஜிய இருப்புடன் தொடங்கும் ஒரு வங்கிக் கணக்கின் வைப்பு மற்றும் திரும்பப் பெறுதல் பரிவர்த்தனைகளின் பட்டியல் உங்களுக்கு வழங்கப்படுகிறது. ஏதேனும் ஒரு கட்டத்தில் கணக்கின் இருப்புத்தொகை பூஜ்ஜியத்திற்குக் கீழே குறைகிறதா என்பதைக் கண்டறிவதே உங்க... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" సున్నా బ్యాలెన్స్తో ప్రారంభమయ్యే బ్యాంక్ ఖాతాపై డిపాజిట్ మరియు విత్డ్రాయల్ లావాదేవీల (operations) జాబితా మీకు ఇవ్వబడింది. ఏదైనా సమయంలో ఖాతా బ్యాలెన్స్ సున్నా కంటే తక్కువకు పడిపోతుందేమో గుర్తించడం మీ పని, మరియు ఆ సమయంలో ఫంక్షన్ True ను రి... | from typing import List
def below_zero(operations: List[int]) -> bool:
""" آپ کو ایک بینک اکاؤنٹ پر جمع کروانے اور نکالنے کے operations کی ایک فہرست دی گئی ہے جو
صفر بیلنس کے ساتھ شروع ہوتا ہے۔ آپ کا کام یہ معلوم کرنا ہے کہ کیا کسی بھی موڑ پر اکاؤنٹ کا بیلنس صفر سے نیچے گرتا ہے، اور
اس موڑ پر فنکشن کو Tru... |
HumanEval/4 | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" For a given list of input numbers, calculate Mean Absolute Deviation
around the mean of this dataset.
Mean Absolute Deviation is the average absolute difference between each
element and a centerpoint (mean in this ... | mean = sum(numbers) / len(numbers)
return sum(abs(x - mean) for x in numbers) / len(numbers)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert abs(candidate([1.0, 2.0, 3.0]) - 2.0/3.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0]) - 1.0) < 1e-6
assert abs(candidate([1.0, 2.0, 3.0, 4.0, 5.0]) - 6.0/5.0) < 1e-6
| mean_absolute_deviation | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" এটা প্ৰদত্ত ইনপুট সংখ্যাৰ তালিকাৰ বাবে, এই ডাটাছেটৰ গড়ৰ সাপেক্ষে Mean Absolute Deviation
গণনা কৰক।
Mean Absolute Deviation হৈছে প্ৰতিটো উপাদান আৰু এটা কেন্দ্ৰবিন্দুৰ (এই ক্ষেত্ৰত গড়) মাজৰ
গড় পৰম পাৰ্থক্য:
MA... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" ইনপুট সংখ্যার একটি প্রদত্ত তালিকার জন্য, এই ডেটাসেটের গড়ের সাপেক্ষে
Mean Absolute Deviation গণনা করুন।
Mean Absolute Deviation হলো প্রতিটি উপাদান এবং একটি কেন্দ্রবিন্দুর
(এক্ষেত্রে গড়) মধ্যকার পরম পার্থক্যের গড়:
... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" આપેલ ઇનપુટ સંખ્યાઓની યાદી માટે, આ ડેટાસેટના મધ્યક (mean) ની આસપાસ Mean Absolute Deviation ની ગણતરી કરો.
Mean Absolute Deviation એ દરેક ઘટક અને કેન્દ્રબિંદુ (આ કિસ્સામાં mean) વચ્ચેનો સરેરાશ નિરપેક્ષ તફાવત છે:
MAD = ave... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" इनपुट संख्याओं की दी गई सूची के लिए, इस डेटासेट के माध्य (mean) के
चारों ओर Mean Absolute Deviation की गणना करें।
Mean Absolute Deviation प्रत्येक तत्व और एक केंद्र बिंदु (इस मामले में माध्य) के
बीच का औसत निरपेक्ष... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" ಕೊಟ್ಟಿರುವ ಇನ್ಪುಟ್ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಗೆ, ಈ ಡೇಟಾಸೆಟ್ನ ಸರಾಸರಿಯ ಸುತ್ತಲಿನ Mean Absolute Deviation ಅನ್ನು ಲೆಕ್ಕಹಾಕಿ.
Mean Absolute Deviation ಎನ್ನುವುದು ಪ್ರತಿಯೊಂದು ಅಂಶ ಮತ್ತು ಕೇಂದ್ರಬಿಂದುವಿನ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸರಾಸರಿ) ನಡುವಿನ ಸರಾಸರಿ ಸಂಪೂರ್ಣ... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" നൽകിയിട്ടുള്ള ഇൻപുട്ട് സംഖ്യകളുടെ ഒരു ലിസ്റ്റിനായി, ഈ ഡാറ്റാസെറ്റിന്റെ mean-നെ
ആധാരമാക്കിയുള്ള Mean Absolute Deviation കണക്കാക്കുക.
Mean Absolute Deviation എന്നത് ഓരോ എലമെന്റും ഒരു കേന്ദ്രബിന്ദുവും
(ഈ സാഹചര്യത്തിൽ ... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" दिलेल्या इनपुट संख्यांच्या सूचीसाठी, या डेटासेटच्या सरासरीभोवती (mean) Mean Absolute Deviation
ची गणना करा.
Mean Absolute Deviation म्हणजे प्रत्येक घटक आणि केंद्रबिंदू (या बाबतीत सरासरी) यामधील
सरासरी निरपेक्ष फरक ... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" दिइएको इनपुट संख्याहरूको सूचीको लागि, यस डेटासेटको औसत (mean) वरपर Mean Absolute Deviation
गणना गर्नुहोस्।
Mean Absolute Deviation भनेको प्रत्येक तत्व र केन्द्रबिन्दु (यस अवस्थामा mean) बीचको
औसत निरपेक्ष भिन्नता (... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" ପ୍ରଦତ୍ତ ଇନପୁଟ୍ ସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ତାଲିକା ପାଇଁ, ଏହି ଡାଟାସେଟ୍ର ମାଧ୍ୟମାନ (mean) ଚାରିପାଖରେ Mean Absolute Deviation
ଗଣନା କରନ୍ତୁ।
Mean Absolute Deviation ହେଉଛି ପ୍ରତ୍ୟେକ ଉପାଦାନ ଏବଂ ଏକ କେନ୍ଦ୍ରବିନ୍ଦୁ (ଏହି କ୍ଷେତ୍ରରେ ମାଧ୍ୟମାନ) ମଧ୍... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" ਦਿੱਤੀ ਗਈ ਇਨਪੁੱਟ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ ਲਈ, ਇਸ ਡਾਟਾਸੈੱਟ ਦੇ mean ਦੇ ਆਲੇ-ਦੁਆਲੇ Mean Absolute Deviation
ਦਾ ਹਿਸਾਬ ਲਗਾਓ।
Mean Absolute Deviation ਹਰੇਕ ਐਲੀਮੈਂਟ ਅਤੇ ਇੱਕ ਕੇਂਦਰ ਬਿੰਦੂ (ਇਸ ਮਾਮਲੇ ਵਿੱਚ mean) ਵਿਚਕਾਰ
ਔਸਤ ਪੂਰਨ ਅੰਤਰ (avera... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" दत्तानाम् आगतसंख्यानाम् आवल्याः कृते, अस्य दत्तसमूहस्य मध्यमानम् (mean) परितः
माध्य-निरपेक्ष-विचलनं (Mean Absolute Deviation) गणयतु।
माध्य-निरपेक्ष-विचलनं नाम प्रत्येकस्य तत्त्वस्य केन्द्रबिन्दोः च (अस्मिन् सन्दर्भे मध... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" கொடுக்கப்பட்ட உள்ளீட்டு எண்களின் பட்டியலுக்கு, இந்தத் தரவுத்தொகுப்பின்
சராசரியைச் (mean) சுற்றியுள்ள Mean Absolute Deviation-ஐக் கணக்கிடவும்.
Mean Absolute Deviation என்பது ஒவ்வொரு உறுப்புக்கும் மையப்புள்ளிக்கும் (இங்க... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" ఇచ్చిన ఇన్పుట్ సంఖ్యల లిస్ట్ కోసం, ఈ డేటాసెట్ యొక్క సగటు చుట్టూ ఉండే Mean Absolute Deviation
ను లెక్కించండి.
Mean Absolute Deviation అనేది ప్రతి ఎలిమెంట్ మరియు ఒక కేంద్ర బిందువు (ఈ సందర్భంలో సగటు) మధ్య ఉండే
సగటు స... | from typing import List
def mean_absolute_deviation(numbers: List[float]) -> float:
""" دی گئی ان پٹ اعداد کی فہرست کے لیے، اس ڈیٹا سیٹ کے mean کے گرد Mean Absolute Deviation
کا حساب لگائیں۔
Mean Absolute Deviation ہر عنصر اور ایک مرکزی نقطے (اس صورت میں mean) کے درمیان
اوسط مطلق فرق ہے:
MAD = ave... |
HumanEval/5 | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" Insert a number 'delimeter' between every two consecutive elements of input list `numbers'
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| if not numbers:
return []
result = []
for n in numbers[:-1]:
result.append(n)
result.append(delimeter)
result.append(numbers[-1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 7) == []
assert candidate([5, 6, 3, 2], 8) == [5, 8, 6, 8, 3, 8, 2]
assert candidate([2, 2, 2], 2) == [2, 2, 2, 2, 2]
| intersperse | from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ইনপুট তালিকা `numbers`ৰ প্ৰতিটো দুটা ক্ৰমিক উপাদানৰ মাজত এটা সংখ্যা 'delimeter' সুমুৱাওক
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ইনপুট লিস্ট `numbers`-এর প্রতি দুটি পরপর উপাদানের মাঝে একটি সংখ্যা 'delimeter' সন্নিবেশ করুন
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ઇનપુટ લિસ્ટ `numbers` ના દર બે ક્રમિક ઘટકો વચ્ચે એક સંખ્યા 'delimeter' દાખલ કરો
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" इनपुट सूची `numbers' के प्रत्येक दो लगातार तत्वों के बीच एक संख्या 'delimeter' डालें
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ಇನ್ಪುಟ್ ಲಿಸ್ಟ್ `numbers' ನ ಪ್ರತಿಯೆರಡು ಅನುಕ್ರಮ ಎಲಿಮೆಂಟ್ಗಳ ನಡುವೆ 'delimeter' ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸಿ
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ഇൻപുട്ട് ലിസ്റ്റായ `numbers`-ലെ അടുത്തടുത്തുള്ള ഓരോ രണ്ട് എലമെന്റുകൾക്കിടയിലും 'delimeter' എന്ന സംഖ്യ ചേർക്കുക
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" इनपुट सूची `numbers' मधील प्रत्येक दोन सलग घटकांमध्ये 'delimeter' ही संख्या प्रविष्ट करा
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" इनपुट सूची `numbers` का प्रत्येक दुई क्रमिक तत्वहरूको बीचमा एउटा संख्या 'delimeter' घुसाउनुहोस्
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ଇନପୁଟ୍ ତାଲିକା `numbers' ର ପ୍ରତ୍ୟେକ ଦୁଇଟି କ୍ରମାଗତ ଉପାଦାନ ମଧ୍ୟରେ ଏକ ସଂଖ୍ୟା 'delimeter' ସନ୍ନିବେଶ କରନ୍ତୁ
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ਇਨਪੁੱਟ ਲਿਸਟ `numbers' ਦੇ ਹਰ ਦੋ ਲਗਾਤਾਰ ਐਲੀਮੈਂਟਾਂ ਵਿਚਕਾਰ ਇੱਕ ਨੰਬਰ 'delimeter' ਦਾਖਲ ਕਰੋ
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" आगतसूच्याः `numbers` प्रत्येकयोः द्वयोः क्रमागततत्त्वयोः मध्ये 'delimeter' इति संख्यां सन्निवेशयतु
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" உள்ளீட்டுப் பட்டியல் `numbers`-ன் ஒவ்வொரு இரண்டு தொடர்ச்சியான உறுப்புகளுக்கும் இடையே 'delimeter' என்ற எண்ணைச் செருகவும்
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ఇన్పుట్ లిస్ట్ `numbers' లోని ప్రతి రెండు వరుస ఎలిమెంట్ల మధ్య 'delimeter' సంఖ్యను ఇన్సర్ట్ చేయండి
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
| from typing import List
def intersperse(numbers: List[int], delimeter: int) -> List[int]:
""" ان پٹ لسٹ `numbers' کے ہر دو متواتر عناصر کے درمیان ایک عدد 'delimeter' درج کریں۔
>>> intersperse([], 4)
[]
>>> intersperse([1, 2, 3], 4)
[1, 4, 2, 4, 3]
"""
|
HumanEval/6 | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" Input to this function is a string represented multiple groups for nested parentheses separated by spaces.
For each of the group, output the deepest level of nesting of parentheses.
E.g. (()()) has maximum two levels of n... | def parse_paren_group(s):
depth = 0
max_depth = 0
for c in s:
if c == '(':
depth += 1
max_depth = max(depth, max_depth)
else:
depth -= 1
return max_depth
return [parse_paren_group(x) for x in paren_string.s... |
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('(()()) ((())) () ((())()())') == [2, 3, 1, 3]
assert candidate('() (()) ((())) (((())))') == [1, 2, 3, 4]
assert candidate('(()(())((())))') == [4]
| parse_nested_parens | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" এই ফাংচনটোৰ ইনপুট হৈছে স্পেচৰ দ্বাৰা পৃথক কৰা নেষ্টেড বন্ধনীৰ একাধিক গোটক প্ৰতিনিধিত্ব কৰা এটা ষ্ট্ৰিং।
প্ৰতিটো গোটৰ বাবে, বন্ধনীৰ আটাইতকৈ গভীৰ স্তৰৰ নেষ্টিং (deepest level of nesting) আউটপুট দিয়ক।
যেনে, (()())-ত সৰ্বাধি... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" এই ফাংশনের ইনপুট হলো স্পেস দ্বারা পৃথক করা নেস্টেড বন্ধনীর একাধিক গ্রুপ নির্দেশকারী একটি স্ট্রিং।
প্রতিটি গ্রুপের জন্য, বন্ধনীর নেস্টিংয়ের গভীরতম স্তরটি আউটপুট দিন।
যেমন (()())-এ সর্বাধিক দুটি নেস্টিং স্তর রয়েছে যেখানে ... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" આ ફંક્શનનું ઇનપુટ સ્પેસ દ્વારા અલગ કરેલા નેસ્ટેડ કૌંસના બહુવિધ જૂથો દર્શાવતી એક સ્ટ્રિંગ છે.
દરેક જૂથ માટે, કૌંસના નેસ્ટિંગનું સૌથી ઊંડું સ્તર આઉટપુટ કરો.
દા.ત. (()()) માં નેસ્ટિંગના મહત્તમ બે સ્તર છે જ્યારે ((())) માં ત્... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" इस फ़ंक्शन का इनपुट स्पेस द्वारा अलग किए गए नेस्टेड कोष्ठकों (nested parentheses) के कई समूहों को दर्शाने वाली एक स्ट्रिंग है।
प्रत्येक समूह के लिए, कोष्ठकों की नेस्टिंग का सबसे गहरा स्तर (deepest level) आउटपुट करें।
उदा.... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" ಈ ಫಂಕ್ಷನ್ಗೆ ಇನ್ಪುಟ್ ಎಂದರೆ ಸ್ಪೇಸ್ಗಳಿಂದ ಬೇರ್ಪಡಿಸಲಾದ ನೆಸ್ಟೆಡ್ ಆವರಣಗಳ (nested parentheses) ಅನೇಕ ಗುಂಪುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.
ಪ್ರತಿಯೊಂದು ಗುಂಪಿಗೆ, ಆವರಣಗಳ ಅತ್ಯಂತ ಆಳವಾದ ನೆಸ್ಟಿಂಗ್ ಮಟ್ಟವನ್ನು ಔಟ್ಪುಟ್ ಮಾಡಿ.
ಉದಾಹರಣೆಗೆ... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" ഈ ഫംഗ്ഷനിലേക്കുള്ള ഇൻപുട്ട് സ്പേസുകളാൽ വേർതിരിച്ച നെസ്റ്റഡ് പരാൻതീസിസുകളുടെ ഒന്നിലധികം ഗ്രൂപ്പുകളെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് ആണ്.
ഓരോ ഗ്രൂപ്പിലെയും പരാൻതീസിസുകളുടെ ഏറ്റവും ആഴത്തിലുള്ള നെസ്റ്റിംഗ് ലെവൽ ഔട്ട്പുട്ട് ചെയ്... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" या फंक्शनचे इनपुट ही स्पेसने विभक्त केलेल्या नेस्टेड कंसांच्या अनेक गटांचे प्रतिनिधित्व करणारी एक स्ट्रिंग आहे.
प्रत्येक गटासाठी, कंसांच्या नेस्टिंगची सर्वात खोल पातळी (deepest level) आउटपुट द्या.
उदा. (()()) मध्ये नेस्टि... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" यस प्रकार्यको इनपुट स्पेसहरूद्वारा छुट्याइएका नेस्टेड कोष्ठकहरू (nested parentheses) का धेरै समूहहरू प्रतिनिधित्व गर्ने एउटा स्ट्रिङ हो।
प्रत्येक समूहको लागि, कोष्ठकहरूको सबैभन्दा गहिरो नेस्टिङ स्तर (deepest level of nesting)... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" ଏହି ଫଙ୍କସନର ଇନପୁଟ୍ ହେଉଛି ସ୍ପେସ୍ ଦ୍ୱାରା ପୃଥକ ହୋଇଥିବା ନେଷ୍ଟେଡ୍ ବନ୍ଧନୀ (nested parentheses) ର ଏକାଧିକ ଗ୍ରୁପ୍ ଥିବା ଏକ ଷ୍ଟ୍ରିଙ୍ଗ।
ପ୍ରତ୍ୟେକ ଗ୍ରୁପ୍ ପାଇଁ, ବନ୍ଧନୀଗୁଡ଼ିକର ସବୁଠାରୁ ଗଭୀର ନେଷ୍ଟିଂ ସ୍ତର (deepest level of nesting) ଆଉଟପୁଟ୍ କରନ୍... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਇਨਪੁਟ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ ਜੋ ਸਪੇਸਾਂ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਗਏ ਨੇਸਟਿਡ ਪੈਰੇਨਥੀਸਿਸ ਦੇ ਕਈ ਸਮੂਹਾਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ।
ਹਰੇਕ ਸਮੂਹ ਲਈ, ਪੈਰੇਨਥੀਸਿਸ ਦੀ ਨੇਸਟਿੰਗ ਦਾ ਸਭ ਤੋਂ ਡੂੰਘਾ ਪੱਧਰ ਆਊਟਪੁੱਟ ਕਰੋ।
ਉਦਾਹਰਨ ਵਜੋਂ, (()()) ਵਿੱਚ ਨੇਸਟਿੰਗ ਦੇ ਵੱਧ ਤ... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" अस्य फलनस्य निवेशः रिक्तस्थानैः पृथक्कृतानां सङ्गुम्फित-कोष्ठकानां (nested parentheses) बहुसमूहान् दर्शयन् एकः string अस्ति।
प्रत्येकसमूहाय, कोष्ठकानां गहनतमं सङ्गुम्फन-स्तरं (deepest level of nesting) निर्गमयतु।
यथा (()(... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" இந்தச் சார்புக்கான உள்ளீடு, இடைவெளிகளால் பிரிக்கப்பட்ட உள்ளமைந்த அடைப்புக் குறிகளின் (nested parentheses) பல குழுக்களைக் கொண்ட ஒரு string ஆகும்.
ஒவ்வொரு குழுவிற்கும், அடைப்புக் குறிகளின் அதிகபட்ச உள்ளமைவு அளவை (deepest level ... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" ఈ ఫంక్షన్కు ఇన్పుట్ అనేది స్పేస్ల ద్వారా వేరుచేయబడిన నెస్టెడ్ కుండలీకరణాల (parentheses) బహుళ సమూహాలను సూచించే ఒక స్ట్రింగ్.
ప్రతి సమూహం కోసం, కుండలీకరణాల అత్యంత లోతైన నెస్టెడ్ స్థాయిని అవుట్పుట్ చేయండి.
ఉదా. (()()) గర... | from typing import List
def parse_nested_parens(paren_string: str) -> List[int]:
""" اس فنکشن کا ان پٹ ایک سٹرنگ ہے جو اسپیسز (spaces) سے الگ کیے گئے nested قوسین (parentheses) کے متعدد گروپس پر مشتمل ہے۔
ہر گروپ کے لیے، قوسین کی nesting کی گہری ترین سطح آؤٹ پٹ کریں۔
مثال کے طور پر، (()()) میں nesting کی ... |
HumanEval/7 | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" Filter an input list of strings only for ones that contain given substring
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'array'... | return [x for x in strings if substring in x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
assert candidate(['xxx', 'asd', 'aaaxxy', 'john doe', 'xxxAAA', 'xxx'], 'xx') == ['xxx... | filter_by_substring | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" ষ্ট্ৰিংসমূহৰ এটা ইনপুট তালিকাৰ পৰা কেৱল প্ৰদত্ত substring থকাবোৰ ফিল্টাৰ কৰক
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'bacd', 'arra... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" একটি ইনপুট স্ট্রিংয়ের তালিকা থেকে কেবল সেই স্ট্রিংগুলোকে ফিল্টার করুন যেগুলোর মধ্যে প্রদত্ত সাবস্ট্রিংটি রয়েছে
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" સ્ટ્રિંગ્સની ઇનપુટ લિસ્ટમાંથી ફક્ત તે જ સ્ટ્રિંગ્સ ફિલ્ટર કરો જેમાં આપેલ substring શામેલ હોય
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" स्ट्रिंग्स की एक इनपुट लिस्ट को केवल उन्हीं के लिए फ़िल्टर करें जिनमें दिया गया substring शामिल है
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" ಕೊಟ್ಟಿರುವ substring ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಮಾತ್ರ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ಗಳ ಪಟ್ಟಿಯಿಂದ ಫಿಲ್ಟರ್ ಮಾಡಿ
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" നൽകിയിട്ടുള്ള substring അടങ്ങിയിട്ടുള്ള സ്ട്രിംഗുകൾ മാത്രമായി ഇൻപുട്ട് ലിസ്റ്റ് ഫിൽട്ടർ ചെയ്യുക
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" स्ट्रिंग्सच्या इनपुट सूचीमधून फक्त दिलेल्या सबस्ट्रिंगचा समावेश असलेल्या स्ट्रिंग्स फिल्टर करा
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['a... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" स्ट्रिङहरूको इनपुट सूचीबाट दिइएको substring समावेश भएका स्ट्रिङहरूलाई मात्र फिल्टर गर्नुहोस्
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" ଏକ ଇନପୁଟ୍ strings ର ତାଲିକାକୁ କେବଳ ପ୍ରଦତ୍ତ substring ଧାରଣ କରିଥିବା ଷ୍ଟ୍ରିଙ୍ଗଗୁଡ଼ିକ ପାଇଁ ଫିଲ୍ଟର୍ କରନ୍ତୁ
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" ਸਤਰਾਂ ਦੀ ਇੱਕ ਇਨਪੁਟ ਸੂਚੀ ਨੂੰ ਸਿਰਫ਼ ਉਹਨਾਂ ਲਈ ਫਿਲਟਰ ਕਰੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਦਿੱਤੀ ਗਈ substring ਸ਼ਾਮਲ ਹੋਵੇ
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" प्रदत्तायाः सूत्राणां सूच्याः केवलं तानि सूत्राणि शोधयन्तु येषु प्रदत्तम् उपसूत्रं विद्यते
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc',... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" கொடுக்கப்பட்ட துணைச்சரத்தைக் கொண்டுள்ள சரங்களுக்கு மட்டுமே உள்ளீட்டுச் சரப் பட்டியலை வடிகட்டவும்
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
[... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" ఇచ్చిన substring ను కలిగి ఉన్న స్ట్రింగ్ల కోసం మాత్రమే ఇన్పుట్ లిస్ట్ను ఫిల్టర్ చేయండి
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', ... | from typing import List
def filter_by_substring(strings: List[str], substring: str) -> List[str]:
""" سٹرنگز کی ان پٹ لسٹ کو صرف ان سٹرنگز کے لیے فلٹر کریں جن میں دیا گیا substring شامل ہو
>>> filter_by_substring([], 'a')
[]
>>> filter_by_substring(['abc', 'bacd', 'cde', 'array'], 'a')
['abc', 'ba... |
HumanEval/8 | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" For a given list of integers, return a tuple consisting of a sum and a product of all the integers in a list.
Empty sum should be equal to 0 and empty product should be equal to 1.
>>> sum_product([])
(0, 1)
... | sum_value = 0
prod_value = 1
for n in numbers:
sum_value += n
prod_value *= n
return sum_value, prod_value
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == (0, 1)
assert candidate([1, 1, 1]) == (3, 1)
assert candidate([100, 0]) == (100, 0)
assert candidate([3, 5, 7]) == (3 + 5 + 7, 3 * 5 * 7)
assert candidate([10]) == (10, 10)
| sum_product | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" এটা প্ৰদত্ত পূৰ্ণসংখ্যাৰ তালিকাৰ বাবে, তালিকাখনত থকা সকলো পূৰ্ণসংখ্যাৰ যোগফল আৰু গুণফলৰে গঠিত এটা tuple ঘূৰাই দিয়ক।
খালী যোগফল 0-ৰ সমান আৰু খালী গুণফল 1-ৰ সমান হ'ব লাগে।
>>> sum_product([])
(0, 1)
>>> sum_p... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" পূর্ণসংখ্যার একটি প্রদত্ত তালিকার জন্য, তালিকার সমস্ত পূর্ণসংখ্যার যোগফল এবং গুণফল নিয়ে গঠিত একটি tuple রিটার্ন করুন।
খালি যোগফল 0 এর সমান এবং খালি গুণফল 1 এর সমান হওয়া উচিত।
>>> sum_product([])
(0, 1)
>>>... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" આપેલ પૂર્ણાંકોની list માટે, list માંના તમામ પૂર્ણાંકોના સરવાળા અને ગુણાકાર ધરાવતી tuple પરત કરો.
ખાલી સરવાળો 0 ની બરાબર અને ખાલી ગુણાકાર 1 ની બરાબર હોવો જોઈએ.
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" पूर्णांकों की दी गई सूची के लिए, सूची के सभी पूर्णांकों के योग और गुणनफल से युक्त एक tuple लौटाएं।
खाली योग 0 के बराबर और खाली गुणनफल 1 के बराबर होना चाहिए।
>>> sum_product([])
(0, 1)
>>> sum_product([1, 2, ... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" ನೀಡಲಾದ ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಗಾಗಿ, ಪಟ್ಟಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಪೂರ್ಣಾಂಕಗಳ ಮೊತ್ತ ಮತ್ತು ಗುಣಲಬ್ಧವನ್ನು ಹೊಂದಿರುವ ಒಂದು tuple ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
ಖಾಲಿ ಮೊತ್ತವು 0 ಗೆ ಸಮನಾಗಿರಬೇಕು ಮತ್ತು ಖಾಲಿ ಗುಣಲಬ್ಧವು 1 ಕ್ಕೆ ಸಮನಾಗಿರಬೇಕು.
>>> sum_product([])
... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" നൽകിയിട്ടുള്ള പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റിന്, ലിസ്റ്റിലെ എല്ലാ പൂർണ്ണസംഖ്യകളുടെയും തുകയും ഗുണനഫലവും അടങ്ങിയ ഒരു tuple നൽകുക.
ശൂന്യമായ തുക 0-ന് തുല്യമായിരിക്കണം, ശൂന്യമായ ഗുണനഫലം 1-ന് തുല്യമായിരിക്കണം.
>>> sum_produ... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" दिलेल्या पूर्णांकांच्या सूचीसाठी, सूचीतील सर्व पूर्णांकांची बेरीज आणि गुणाकार असलेला एक tuple परत करा.
रिकामी बेरीज 0 च्या समान असावी आणि रिकामा गुणाकार 1 च्या समान असावा.
>>> sum_product([])
(0, 1)
>>> sum_... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" दिइएको पूर्णाङ्कहरूको सूचीका लागि, सूचीमा भएका सबै पूर्णाङ्कहरूको योगफल र गुणनफल समावेश भएको एउटा tuple फिर्ता गर्नुहोस्।
खाली योगफल 0 बराबर र खाली गुणनफल 1 बराबर हुनुपर्छ।
>>> sum_product([])
(0, 1)
>>> sum... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" ପ୍ରଦତ୍ତ ଏକ integers ର ତାଲିକା ପାଇଁ, ତାଲିକାରେ ଥିବା ସମସ୍ତ integers ର ଯୋଗଫଳ ଏବଂ ଗୁଣନଫଳକୁ ନେଇ ଗଠିତ ଏକ tuple ଫେରାନ୍ତୁ।
ଖାଲି ଯୋଗଫଳ 0 ସହିତ ସମାନ ହେବା ଉଚିତ ଏବଂ ଖାଲି ଗୁଣନଫଳ 1 ସହିତ ସମାନ ହେବା ଉଚିତ।
>>> sum_product([])
(0, 1)... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" ਦਿੱਤੀ ਗਈ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਸੂਚੀ ਲਈ, ਸੂਚੀ ਵਿਚਲੇ ਸਾਰੇ ਪੂਰਨ ਅੰਕਾਂ ਦੇ ਜੋੜ ਅਤੇ ਗੁਣਨਫਲ ਵਾਲਾ ਇੱਕ tuple ਵਾਪਸ ਕਰੋ।
ਖਾਲੀ ਜੋੜ 0 ਦੇ ਬਰਾਬਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਖਾਲੀ ਗੁਣਨਫਲ 1 ਦੇ ਬਰਾਬਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
>>> sum_product([])
(0, 1)
... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" पूर्णाङ्कानां दत्तसूच्याः कृते, सूचौ स्थितानां सर्वेषां पूर्णाङ्कानां योगेन गुणनफलेन च युक्तं tuple प्रत्यर्पयतु।
रिक्तयोगः 0 इत्यनेन समः भवेत् तथा च रिक्तगुणनफलं 1 इत्यनेन समं भवेत्।
>>> sum_product([])
(0, 1)
... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" கொடுக்கப்பட்ட முழுஎண்களின் பட்டியலுக்கு, பட்டியலில் உள்ள அனைத்து முழுஎண்களின் கூடுதல் மற்றும் பெருக்கற்பலனைக் கொண்ட ஒரு tuple-ஐத் திருப்பியளிக்கவும்.
வெற்று கூட்டுத்தொகை 0-க்கு சமமாகவும், வெற்று பெருக்கற்பலன் 1-க்கு சமம... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" ఇచ్చిన పూర్ణాంకాల జాబితా కోసం, జాబితాలోని అన్ని పూర్ణాంకాల మొత్తం మరియు లబ్ధంతో కూడిన ఒక tuple ను రిటర్న్ చేయండి.
ఖాళీ మొత్తం 0 కి సమానంగా ఉండాలి మరియు ఖాళీ లబ్ధం 1 కి సమానంగా ఉండాలి.
>>> sum_product([])
(0, 1)
... | from typing import List, Tuple
def sum_product(numbers: List[int]) -> Tuple[int, int]:
""" دی گئی انٹیجرز کی فہرست کے لیے، ایک ایسا tuple واپس کریں جو فہرست کے تمام انٹیجرز کے مجموعے (sum) اور حاصل ضرب (product) پر مشتمل ہو۔
خالی مجموعہ 0 کے برابر اور خالی حاصل ضرب 1 کے برابر ہونا چاہیے۔
>>> sum_product([... |
HumanEval/9 | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" From a given list of integers, generate a list of rolling maximum element found until given moment
in the sequence.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| running_max = None
result = []
for n in numbers:
if running_max is None:
running_max = n
else:
running_max = max(running_max, n)
result.append(running_max)
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
assert candidate([4, 3, 2, 1]) == [4, 4, 4, 4]
assert candidate([3, 2, 3, 100, 3]) == [3, 3, 3, 100, 100]
| rolling_max | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" এটা প্ৰদত্ত পূৰ্ণসংখ্যাৰ তালিকাৰ পৰা, অনুক্ৰমটোত নিৰ্দিষ্ট মুহূৰ্তলৈকে পোৱা ৰোলিং সৰ্বোচ্চ উপাদানসমূহৰ
এখন তালিকা প্ৰস্তুত কৰক।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" পূর্ণসংখ্যার একটি প্রদত্ত তালিকা থেকে, সিকোয়েন্সের নির্দিষ্ট মুহূর্ত পর্যন্ত পাওয়া রোলিং সর্বোচ্চ (rolling maximum) উপাদানের একটি তালিকা তৈরি করুন।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" આપેલી પૂર્ણાંકોની list માંથી, સિક્વન્સમાં આપેલ ક્ષણ સુધી મળેલા રોલિંગ મહત્તમ ઘટકોની list બનાવો.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" पूर्णांकों की दी गई सूची से, अनुक्रम में दिए गए क्षण तक मिले रोलिंग अधिकतम (rolling maximum) तत्व की एक सूची उत्पन्न करें।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" ನೀಡಲಾದ ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯಿಂದ, ಅನುಕ್ರಮದಲ್ಲಿ ಆಯಾ ಕ್ಷಣದವರೆಗೆ ಕಂಡುಬಂದ ರೋಲಿಂಗ್ ಗರಿಷ್ಠ ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಿ.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" നൽകിയിട്ടുള്ള പൂർണ്ണസംഖ്യാ ലിസ്റ്റിൽ നിന്നും, ശ്രേണിയിലെ ഓരോ ഘട്ടം വരെയും കണ്ടെത്തിയ റോളിംഗ് മാക്സിമം എലമെന്റുകളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടാക്കുക.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" दिलेल्या integers च्या सूचीमधून, अनुक्रमात दिलेल्या क्षणापर्यंत आढळलेल्या rolling maximum घटकांची
एक सूची तयार करा.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" दिइएको पूर्णाङ्कहरूको सूचीबाट, अनुक्रममा दिइएको क्षणसम्म फेला परेको रोलिङ अधिकतम तत्वहरूको सूची उत्पन्न
गर्नुहोस्।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" ପ୍ରଦତ୍ତ ଏକ integers ର list ରୁ, କ୍ରମରେ ପ୍ରଦତ୍ତ ମୁହୂର୍ତ୍ତ ପର୍ଯ୍ୟନ୍ତ ମିଳିଥିବା rolling maximum ଉପାଦାନଗୁଡ଼ିକର ଏକ list ପ୍ରସ୍ତୁତ କରନ୍ତୁ।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਦਿੱਤੀ ਗਈ ਇੱਕ ਸੂਚੀ ਵਿੱਚੋਂ, ਕ੍ਰਮ ਵਿੱਚ ਦਿੱਤੇ ਗਏ ਪਲ ਤੱਕ ਮਿਲੇ ਰੋਲਿੰਗ ਅਧਿਕਤਮ ਐਲੀਮੈਂਟ ਦੀ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰੋ।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" दत्तात् पूर्णाङ्कानां सूच्याः, अनुक्रमे तत्तत्क्षणपर्यन्तं प्राप्तस्य महत्तमघटकस्य चल-सूचीं (rolling maximum elements) जनयन्तु।
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" கொடுக்கப்பட்ட முழு எண்களின் பட்டியலிலிருந்து, வரிசையில் கொடுக்கப்பட்ட தருணம் வரை காணப்படும்
தொடர் பெரும உறுப்புகளின் (rolling maximum element) பட்டியலை உருவாக்கவும்.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3,... | from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" ఇచ్చిన పూర్ణాంకాల జాబితా నుండి, ఆ క్రమంలో ఇచ్చిన సమయం వరకు కనిపించిన రోలింగ్ గరిష్ట మూలకాల జాబితాను
రూపొందించండి.
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
| from typing import List, Tuple
def rolling_max(numbers: List[int]) -> List[int]:
""" دیے گئے صحیح اعداد کی فہرست سے، تسلسل میں دیے گئے لمحے تک پائے جانے والے رولنگ زیادہ سے زیادہ عنصر (rolling maximum element) کی ایک فہرست تیار کریں۔
>>> rolling_max([1, 2, 3, 2, 3, 4, 2])
[1, 2, 3, 3, 3, 4, 4]
"""
|
HumanEval/10 |
def is_palindrome(string: str) -> bool:
""" Test if given string is a palindrome """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" Find the shortest palindrome that begins with a supplied string.
Algorithm idea is simple:
- Find the longest postfix of supplied string... | if not string:
return ''
beginning_of_suffix = 0
while not is_palindrome(string[beginning_of_suffix:]):
beginning_of_suffix += 1
return string + string[:beginning_of_suffix][::-1]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('x') == 'x'
assert candidate('xyz') == 'xyzyx'
assert candidate('xyx') == 'xyx'
assert candidate('jerry') == 'jerryrrej'
| make_palindrome |
def is_palindrome(string: str) -> bool:
""" দিয়া ষ্ট্ৰিংটো এটা palindrome হয় নে নহয় পৰীক্ষা কৰক """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" দিয়া ষ্ট্ৰিংটোৰে আৰম্ভ হোৱা আটাইতকৈ চুটি palindrome-টো বিচাৰি উলিয়াওক।
এলগৰিথমৰ ধাৰণাটো সহজ:
- দিয়া ষ্ট্ৰিংটোৰ আটাই... |
def is_palindrome(string: str) -> bool:
""" প্রদত্ত string-টি একটি palindrome কিনা তা পরীক্ষা করুন """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" প্রদত্ত string দিয়ে শুরু হওয়া সবচেয়ে ছোট palindrome খুঁজুন।
অ্যালগরিদমের মূল ধারণাটি সহজ:
- প্রদত্ত string-এর সবচেয়ে দ... |
def is_palindrome(string: str) -> bool:
""" આપેલી string પેલિન્ડ્રોમ છે કે નહીં તે ચકાસો """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" આપેલી string થી શરૂ થતો સૌથી ટૂંકો પેલિન્ડ્રોમ શોધો.
અલ્ગોરિધમનો વિચાર સરળ છે:
- આપેલી string નો સૌથી લાંબો postfix શોધો જે પેલિ... |
def is_palindrome(string: str) -> bool:
""" जाँचें कि क्या दी गई string एक palindrome है """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" दी गई string से शुरू होने वाला सबसे छोटा palindrome खोजें।
एल्गोरिदम का विचार सरल है:
- दी गई string का सबसे लंबा postfix खोजें ... | def is_palindrome(string: str) -> bool:
""" ಕೊಟ್ಟಿರುವ ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಪ್ಯಾಲಿಂಡ್ರೋಮ್ ಆಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಿ """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" ಕೊಟ್ಟಿರುವ ಸ್ಟ್ರಿಂಗ್ ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಅತಿ ಚಿಕ್ಕ ಪ್ಯಾಲಿಂಡ್ರೋಮ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ.
ಅಲ್ಗಾರಿದಮ್ ಕಲ್ಪನೆ ಸರಳವಾಗಿದೆ:
- ... |
def is_palindrome(string: str) -> bool:
""" നൽകിയിട്ടുള്ള string ഒരു palindrome ആണോ എന്ന് പരിശോധിക്കുക """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" നൽകിയിട്ടുള്ള string-ൽ ആരംഭിക്കുന്ന ഏറ്റവും ചെറിയ palindrome കണ്ടെത്തുക.
അൽഗോരിതത്തിന്റെ ആശയം ലളിതമാണ്:
- നൽകിയിട്... |
def is_palindrome(string: str) -> bool:
""" दिलेली स्ट्रिंग पॅलिन्ड्रोम आहे का ते तपासा """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" दिलेल्या स्ट्रिंगने सुरू होणारा सर्वात लहान पॅलिन्ड्रोम शोधा.
अल्गोरिदमची कल्पना सोपी आहे:
- दिलेल्या स्ट्रिंगचा सर्वात लांब पोस्... |
def is_palindrome(string: str) -> bool:
""" दिइएको string palindrome हो कि होइन परीक्षण गर्नुहोस् """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" दिइएको string बाट सुरु हुने सबैभन्दा छोटो palindrome पत्ता लगाउनुहोस्।
एल्गोरिदमको विचार सरल छ:
- दिइएको string को pali... |
def is_palindrome(string: str) -> bool:
""" ପ୍ରଦତ୍ତ string ଟି ଏକ palindrome କି ନାହିଁ ପରୀକ୍ଷା କରନ୍ତୁ """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" ପ୍ରଦତ୍ତ string ସହିତ ଆରମ୍ଭ ହେଉଥିବା ସବୁଠାରୁ କ୍ଷୁଦ୍ରତମ palindrome ଖୋଜନ୍ତୁ।
Algorithm ର ଧାରଣାଟି ସରଳ:
- ପ୍ରଦତ୍ତ string ର ସ... |
def is_palindrome(string: str) -> bool:
""" ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦਿੱਤੀ ਗਈ string ਇੱਕ palindrome ਹੈ """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" ਦਿੱਤੀ ਗਈ string ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲਾ ਸਭ ਤੋਂ ਛੋਟਾ palindrome ਲੱਭੋ।
ਐਲਗੋਰਿਦਮ ਦਾ ਵਿਚਾਰ ਸਰਲ ਹੈ:
- ਦਿੱਤੀ ਗਈ string ਦਾ ਸਭ ਤੋਂ ਲੰਬਾ p... |
def is_palindrome(string: str) -> bool:
""" दत्तं स्ट्रिंग् विलोमपदम् (palindrome) अस्ति वा इति परीक्षताम् """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" दत्तेन स्ट्रिंग्-इत्यनेन आरभ्यमाणं लघुतमं विलोमपदं (palindrome) प्राप्नुवन्तु।
कलनविधेः विचारः सरलः अस्ति:
- द... | def is_palindrome(string: str) -> bool:
""" கொடுக்கப்பட்ட சரம் ஒரு பாலிண்ட்ரோமா என்பதைச் சோதிக்கவும் """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" கொடுக்கப்பட்ட சரத்தைக் கொண்டு தொடங்கும் மிகக் குறுகிய பாலிண்ட்ரோமைக் கண்டறியவும்.
அல்காரிதத்தின் யோசனை எளிதானது:
- கொட... |
def is_palindrome(string: str) -> bool:
""" ఇచ్చిన string ఒక palindrome అవునో కాదో పరీక్షించండి """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" ఇచ్చిన string తో ప్రారంభమయ్యే అతి తక్కువ పొడవు గల palindrome ను కనుగొనండి.
Algorithm ఆలోచన సరళమైనది:
- ఇచ్చిన string లో p... |
def is_palindrome(string: str) -> bool:
""" جانچیں کہ آیا دی گئی سٹرنگ ایک palindrome ہے """
return string == string[::-1]
def make_palindrome(string: str) -> str:
""" وہ مختصر ترین palindrome تلاش کریں جو دی گئی سٹرنگ سے شروع ہوتا ہو۔
الگورتھم کا خیال سادہ ہے:
- دی گئی سٹرنگ کا وہ طویل ترین pos... |
HumanEval/11 | from typing import List
def string_xor(a: str, b: str) -> str:
""" Input are two strings a and b consisting only of 1s and 0s.
Perform binary XOR on these inputs and return result also as a string.
>>> string_xor('010', '110')
'100'
"""
| def xor(i, j):
if i == j:
return '0'
else:
return '1'
return ''.join(xor(x, y) for x, y in zip(a, b))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('111000', '101010') == '010010'
assert candidate('1', '1') == '0'
assert candidate('0101', '0000') == '0101'
| string_xor | from typing import List
def string_xor(a: str, b: str) -> str:
""" ইনপুট হ'ল কেৱল 1 আৰু 0 ৰে গঠিত দুটা ষ্ট্ৰিং a আৰু b।
এই ইনপুটবোৰত বাইনাৰী XOR সম্পন্ন কৰক আৰু ফলাফলটোও এটা ষ্ট্ৰিং হিচাপে প্ৰদান কৰক।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ইনপুট হলো কেবল 1 এবং 0 নিয়ে গঠিত দুটি স্ট্রিং a এবং b।
এই ইনপুটগুলোর ওপর বাইনারি XOR সম্পাদন করুন এবং ফলাফলটিও একটি স্ট্রিং হিসেবে রিটার্ন করুন।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ઇનપુટ ફક્ત 1s અને 0s ધરાવતી બે સ્ટ્રિંગ્સ a અને b છે.
આ ઇનપુટ્સ પર બાઈનરી XOR કરો અને પરિણામ પણ સ્ટ્રિંગ તરીકે પરત કરો.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" इनपुट दो स्ट्रिंग्स a और b हैं जिनमें केवल 1s और 0s हैं।
इन इनपुट्स पर बाइनरी XOR करें और परिणाम को भी एक स्ट्रिंग के रूप में लौटाएं।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ಇನ್ಪುಟ್ಗಳು ಕೇವಲ 1ಗಳು ಮತ್ತು 0ಗಳನ್ನು ಮಾತ್ರ ಹೊಂದಿರುವ ಎರಡು ಸ್ಟ್ರಿಂಗ್ಗಳಾದ a ಮತ್ತು b ಆಗಿವೆ.
ಈ ಇನ್ಪುಟ್ಗಳ ಮೇಲೆ ಬೈನರಿ XOR ಅನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಸಹ ಸ್ಟ್ರಿಂಗ್ ರೂಪದಲ್ಲಿ ಹಿಂತಿರುಗಿಸಿ.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ഇൻപുട്ടുകൾ 1-കളും 0-കളും മാത്രം അടങ്ങിയ a, b എന്നീ രണ്ട് സ്ട്രിംഗുകളാണ്.
ഈ ഇൻപുട്ടുകളിൽ ബൈനറി XOR ചെയ്യുക, ലഭിക്കുന്ന ഫലം ഒരു സ്ട്രിംഗ് ആയി തിരികെ നൽകുക.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" इनपुट म्हणून केवळ 1s आणि 0s असलेल्या a आणि b या दोन स्ट्रिंग्स आहेत.
या इनपुट्सवर बायनरी XOR करा आणि निकाल देखील स्ट्रिंग स्वरूपात परत करा.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" इनपुट केवल 1s र 0s मात्र भएका दुई स्ट्रिङहरू a र b हुन्।
यी इनपुटहरूमा binary XOR गर्नुहोस् र परिणाम पनि स्ट्रिङको रूपमा फिर्ता गर्नुहोस्।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ଇନପୁଟ୍ ହେଉଛି କେବଳ 1 ଏବଂ 0 ଧାରଣ କରିଥିବା ଦୁଇଟି string a ଏବଂ b ।
ଏହି ଇନପୁଟ୍ଗୁଡ଼ିକ ଉପରେ binary XOR କରନ୍ତୁ ଏବଂ ଫଳାଫଳକୁ ମଧ୍ୟ ଏକ string ଭାବରେ ଫେରାନ୍ତୁ ।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ਇਨਪੁਟ ਦੋ ਸਟ੍ਰਿੰਗਾਂ a ਅਤੇ b ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਸਿਰਫ਼ 1s ਅਤੇ 0s ਸ਼ਾਮਲ ਹਨ।
ਇਹਨਾਂ ਇਨਪੁਟਾਂ 'ਤੇ ਬਾਇਨਰੀ XOR ਕਰੋ ਅਤੇ ਨਤੀਜਾ ਵੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਜੋਂ ਵਾਪਸ ਕਰੋ।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" आदाने केवलं 1s तथा 0s युक्तौ द्वे strings a तथा b स्तः।
अनयोः आदानयोः उपरि binary XOR प्रक्रियां कृत्वा परिणामम् अपि string रूपेण प्रतिददातु।
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" உள்ளீடுகள் 1-கள் மற்றும் 0-களை மட்டுமே கொண்ட a மற்றும் b ஆகிய இரண்டு strings ஆகும்.
இந்த உள்ளீடுகளின் மீது binary XOR செய்து, முடிவையும் ஒரு string ஆகத் திருப்பியளிக்கவும்.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ఇన్పుట్ అనేది కేవలం 1లు మరియు 0లను మాత్రమే కలిగి ఉన్న రెండు స్ట్రింగ్లు a మరియు b.
ఈ ఇన్పుట్లపై బైనరీ XOR నిర్వహించి, ఫలితాన్ని కూడా ఒక స్ట్రింగ్గా రిటర్న్ చేయండి.
>>> string_xor('010', '110')
'100'
"""
| from typing import List
def string_xor(a: str, b: str) -> str:
""" ان پٹ دو سٹرنگز a اور b ہیں جو صرف 1s اور 0s پر مشتمل ہیں۔
ان ان پٹس پر بائنری XOR انجام دیں اور نتیجہ بھی ایک سٹرنگ کے طور پر واپس کریں۔
>>> string_xor('010', '110')
'100'
"""
|
HumanEval/12 | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" Out of list of strings, return the longest one. Return the first one in case of multiple
strings of the same length. Return None in case the input list is empty.
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a... | if not strings:
return None
maxlen = max(len(x) for x in strings)
for s in strings:
if len(s) == maxlen:
return s
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == None
assert candidate(['x', 'y', 'z']) == 'x'
assert candidate(['x', 'yyy', 'zzzz', 'www', 'kkkk', 'abc']) == 'zzzz'
| longest | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" ষ্ট্ৰিংসমূহৰ তালিকাখনৰ পৰা আটাইতকৈ দীঘলটো ৰিটাৰ্ন কৰক। একে দৈৰ্ঘ্যৰ একাধিক
ষ্ট্ৰিং থকাৰ ক্ষেত্ৰত প্ৰথমটো ৰিটাৰ্ন কৰক। ইনপুট তালিকাখন খালী হ'লে None ৰিটাৰ্ন কৰক।
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a'... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" স্ট্রিংয়ের তালিকা থেকে সবচেয়ে দীর্ঘ স্ট্রিংটি রিটার্ন করুন। একই দৈর্ঘ্যের একাধিক
স্ট্রিং থাকলে প্রথমটি রিটার্ন করুন। ইনপুট তালিকাটি খালি হলে None রিটার্ন করুন।
>>> longest([])
>>> longest(['a', 'b', 'c'])
'a... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" સ્ટ્રિંગ્સની યાદીમાંથી, સૌથી લાંબી સ્ટ્રિંગ પરત કરો. સમાન લંબાઈની એક કરતાં વધુ
સ્ટ્રિંગ્સ હોય તેવા કિસ્સામાં પહેલી સ્ટ્રિંગ પરત કરો. જો ઇનપુટ યાદી ખાલી હોય તો None પરત કરો.
>>> longest([])
>>> longest(['a', 'b', '... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" स्ट्रिंग्स की सूची में से सबसे लंबी स्ट्रिंग लौटाएं। समान लंबाई की एक
से अधिक स्ट्रिंग्स होने की स्थिति में पहली वाली लौटाएं। यदि इनपुट सूची खाली है तो None लौटाएं।
>>> longest([])
>>> longest(['a', 'b', 'c'])
... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" ಸ್ಟ್ರಿಂಗ್ಗಳ ಪಟ್ಟಿಯಿಂದ, ಅತ್ಯಂತ ಉದ್ದವಾದದ್ದನ್ನು ಹಿಂತಿರುಗಿಸಿ. ಸಮಾನ ಉದ್ದದ ಬಹು
ಸ್ಟ್ರಿಂಗ್ಗಳಿದ್ದಲ್ಲಿ ಮೊದಲನೆಯದನ್ನು ಹಿಂತಿರುಗಿಸಿ. ಇನ್ಪುಟ್ ಪಟ್ಟಿಯು ಖಾಲಿಯಾಗಿದ್ದಲ್ಲಿ None ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> longest([])
>>> longest(['a', '... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" സ്ട്രിംഗുകളുടെ ഒരു ലിസ്റ്റിൽ നിന്ന് ഏറ്റവും നീളമുള്ളത് നൽകുക. ഒരേ നീളമുള്ള ഒന്നിലധികം
സ്ട്രിംഗുകൾ ഉണ്ടെങ്കിൽ, ആദ്യത്തേത് നൽകുക. ഇൻപുട്ട് ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ None നൽകുക.
>>> longest([])
>>> longest(['a', 'b', '... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" स्ट्रिंग्सच्या सूचीमधून सर्वात लांब असलेली स्ट्रिंग परत करा. समान लांबीच्या अनेक
स्ट्रिंग्स असल्यास पहिली स्ट्रिंग परत करा. जर इनपुट सूची रिकामी असेल तर None परत करा.
>>> longest([])
>>> longest(['a', 'b', 'c'])
... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" स्ट्रिङहरूको सूचीबाट, सबैभन्दा लामो स्ट्रिङ फिर्ता गर्नुहोस्। एउटै लम्बाइका धेरै
स्ट्रिङहरू भएमा पहिलो स्ट्रिङ फिर्ता गर्नुहोस्। इनपुट सूची खाली भएमा None फिर्ता गर्नुहोस्।
>>> longest([])
>>> longest(['a', 'b', '... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" ଷ୍ଟ୍ରିଙ୍ଗଗୁଡ଼ିକର ଏକ ତାଲିକାରୁ, ସବୁଠାରୁ ଲମ୍ବା ଷ୍ଟ୍ରିଙ୍ଗ୍ ଫେରାନ୍ତୁ। ସମାନ ଦୈର୍ଘ୍ୟ ବିଶିଷ୍ଟ ଏକାଧିକ
ଷ୍ଟ୍ରିଙ୍ଗ୍ ଥିବା କ୍ଷେତ୍ରରେ ପ୍ରଥମଟି ଫେରାନ୍ତୁ। ଇନପୁଟ୍ ତାଲିକା ଖାଲି ଥିବା କ୍ଷେତ୍ରରେ None ଫେରାନ୍ତୁ।
>>> longest([])
>>> longest... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਲਿਸਟ ਵਿੱਚੋਂ, ਸਭ ਤੋਂ ਲੰਬੀ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰੋ। ਇੱਕੋ ਜਿਹੀ ਲੰਬਾਈ ਦੀਆਂ ਕਈ
ਸਟ੍ਰਿੰਗਾਂ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਪਹਿਲੀ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰੋ। ਜੇਕਰ ਇਨਪੁੱਟ ਲਿਸਟ ਖਾਲੀ ਹੈ ਤਾਂ None ਵਾਪਸ ਕਰੋ।
>>> longest([])
>>> longest(['a', 'b'... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" स्ट्रिंग्-सूच्याः मध्ये दीर्घतमं स्ट्रिंग् प्रत्यर्पयतु। समानदैर्घ्ययुक्तानां बहूनां
स्ट्रिंग्-तत्त्वानां प्रसङ्गे प्रथमं प्रत्यर्पयतु। यदि निवेशसूची रिक्ता स्यात् तर्हि None प्रत्यर्पयतु।
>>> longest([])
>>> long... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" சரங்களின் பட்டியலில் இருந்து மிக நீளமானதைத் திருப்பியளிக்கவும். ஒரே நீளமுடைய பல
சரங்கள் இருந்தால், முதலாவதைத் திருப்பியளிக்கவும். உள்ளீட்டுப் பட்டியல் காலியாக இருந்தால் None-ஐத் திருப்பியளிக்கவும்.
>>> longest([])
... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" స్ట్రింగ్ల లిస్ట్ నుండి, అత్యంత పొడవైన దాన్ని రిటర్న్ చేయండి. ఒకే పొడవు కలిగిన బహుళ
స్ట్రింగ్లు ఉన్న సందర్భంలో మొదటిదాన్ని రిటర్న్ చేయండి. ఇన్పుట్ లిస్ట్ ఖాళీగా ఉన్న సందర్భంలో None రిటర్న్ చేయండి.
>>> longest([])
... | from typing import List, Optional
def longest(strings: List[str]) -> Optional[str]:
""" strings کی فہرست میں سے سب سے لمبی string واپس کریں۔ ایک ہی لمبائی کی متعدد
strings ہونے کی صورت میں، پہلی والی واپس کریں۔ اگر ان پٹ لسٹ خالی ہو تو None واپس کریں۔
>>> longest([])
>>> longest(['a', 'b', 'c'])
... |
HumanEval/13 |
def greatest_common_divisor(a: int, b: int) -> int:
""" Return a greatest common divisor of two integers a and b
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
| while b:
a, b = b, a % b
return a
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3, 7) == 1
assert candidate(10, 15) == 5
assert candidate(49, 14) == 7
assert candidate(144, 60) == 12
| greatest_common_divisor |
def greatest_common_divisor(a: int, b: int) -> int:
""" দুটা অখণ্ড সংখ্যা a আৰু b-ৰ গৰিষ্ঠ সাধাৰণ গুণনীয়ক ঘূৰাই দিয়ক
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" দুটি পূর্ণসংখ্যা a এবং b-এর গরিষ্ঠ সাধারণ গুণনীয়ক রিটার্ন করুন
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" બે પૂર્ણાંકો a અને b નો ગુરુત્તમ સામાન્ય વિભાજક પરત કરો
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" दो पूर्णांकों a और b का महत्तम समापवर्तक (greatest common divisor) लौटाएं
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" ಎರಡು ಪೂರ್ಣಾಂಕಗಳಾದ a ಮತ್ತು b ಗಳ ಮಹತ್ತಮ ಸಾಮಾನ್ಯ ಅಪವರ್ತನವನ್ನು ಹಿಂತಿರುಗಿಸಿ
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" a, b എന്നീ രണ്ട് പൂർണ്ണസംഖ്യകളുടെ greatest common divisor നൽകുക
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" a आणि b या दोन integers चा greatest common divisor परत करा
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" दुई पूर्णांकहरू a र b को महत्तम समापवर्तक (greatest common divisor) फिर्ता गर्नुहोस्
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" ଦୁଇଟି integer a ଏବଂ b ର greatest common divisor ଫେରାନ୍ତୁ
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" ਦੋ ਪੂਰਨ ਅੰਕਾਂ a ਅਤੇ b ਦਾ greatest common divisor ਵਾਪਸ ਕਰੋ
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" द्वयोः पूर्णाङ्कयोः a तथा b इत्यनयोः महत्तमं समापवर्तकं प्रत्यर्पयतु।
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" a மற்றும் b ஆகிய இரண்டு முழு எண்களின் மீப்பெரு பொது வகுத்தியைத் தருக
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" రెండు పూర్ణాంకాలు a మరియు b ల యొక్క గరిష్ట సామాన్య భాజకాన్ని రిటర్న్ చేయండి
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
def greatest_common_divisor(a: int, b: int) -> int:
""" دو صحیح اعداد a اور b کا عاد اعظم (greatest common divisor) واپس کریں
>>> greatest_common_divisor(3, 5)
1
>>> greatest_common_divisor(25, 15)
5
"""
|
HumanEval/14 | from typing import List
def all_prefixes(string: str) -> List[str]:
""" Return list of all prefixes from shortest to longest of the input string
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| result = []
for i in range(len(string)):
result.append(string[:i+1])
return result
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('asdfgh') == ['a', 'as', 'asd', 'asdf', 'asdfg', 'asdfgh']
assert candidate('WWW') == ['W', 'WW', 'WWW']
| all_prefixes | from typing import List
def all_prefixes(string: str) -> List[str]:
""" ইনপুট string-টোৰ আটাইতকৈ চুটিৰ পৰা আটাইতকৈ দীঘললৈ সকলো prefix-ৰ তালিকা ৰিটাৰ্ণ কৰক
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ইনপুট স্ট্রিংটির সবচেয়ে ছোট থেকে সবচেয়ে দীর্ঘ পর্যন্ত সমস্ত প্রিফিক্সের একটি তালিকা রিটার্ন করুন
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ઇનપુટ સ્ટ્રિંગના સૌથી ટૂંકાથી સૌથી લાંબા સુધીના તમામ prefixes ની લિસ્ટ રીટર્ન કરો
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" इनपुट स्ट्रिंग के सबसे छोटे से लेकर सबसे लंबे तक के सभी प्रीफिक्स (prefixes) की सूची लौटाएं
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ನ ಅತಿ ಚಿಕ್ಕದರಿಂದ ಅತಿ ಉದ್ದದವರೆಗಿನ ಎಲ್ಲಾ prefixes ಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಿ
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ഇൻപുട്ട് സ്ട്രിംഗിന്റെ ഏറ്റവും ചെറുത് മുതൽ ഏറ്റവും നീളമുള്ളത് വരെയുള്ള എല്ലാ പ്രിഫിക്സുകളുടെയും ഒരു ലിസ്റ്റ് തിരികെ നൽകുക
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" इनपुट स्ट्रिंगच्या सर्वात लहानापासून ते सर्वात मोठ्या अशा सर्व प्रीफिक्सची लिस्ट परत करा
>>> all_prefixes('abc')
['a', 'ab', 'abc']
""" | from typing import List
def all_prefixes(string: str) -> List[str]:
""" इनपुट string का सबै prefix हरूको सूची सबैभन्दा छोटो देखि सबैभन्दा लामो क्रममा फिर्ता गर्नुहोस्
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ଇନପୁଟ୍ string ର ସବୁଠାରୁ ଛୋଟରୁ ସବୁଠାରୁ ଲମ୍ବା କ୍ରମରେ ସମସ୍ତ prefix ଗୁଡ଼ିକର list ଫେରାନ୍ତୁ
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ਇਨਪੁਟ ਸਟ੍ਰਿੰਗ ਦੇ ਸਭ ਤੋਂ ਛੋਟੇ ਤੋਂ ਲੈ ਕੇ ਸਭ ਤੋਂ ਲੰਬੇ ਤੱਕ ਸਾਰੇ prefixes ਦੀ ਸੂਚੀ ਵਾਪਸ ਕਰੋ
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" input string इत्यस्य लघुतमात् दीर्घतमपर्यन्तं सर्वेषां prefixes सूचीं प्रयच्छतु
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" உள்ளீட்டு சரத்தின் அனைத்து முன்னொட்டுகளையும் மிகக் குறுகியதிலிருந்து மிக நீண்டது வரையிலான பட்டியலாகத் திருப்பியளிக்கவும்
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ఇన్పుట్ string యొక్క అన్ని ప్రిఫిక్స్ల (prefixes) జాబితాను అతిచిన్నది నుండి అతిపొడవైన క్రమంలో రిటర్న్ చేయండి
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
| from typing import List
def all_prefixes(string: str) -> List[str]:
""" ان پٹ سٹرنگ کے تمام prefixes کی فہرست مختصر ترین سے طویل ترین کی ترتیب میں واپس کریں۔
>>> all_prefixes('abc')
['a', 'ab', 'abc']
"""
|
HumanEval/15 |
def string_sequence(n: int) -> str:
""" Return a string containing space-delimited numbers starting from 0 upto n inclusive.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
| return ' '.join([str(x) for x in range(n + 1)])
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(0) == '0'
assert candidate(3) == '0 1 2 3'
assert candidate(10) == '0 1 2 3 4 5 6 7 8 9 10'
| string_sequence |
def string_sequence(n: int) -> str:
""" 0-ৰ পৰা আৰম্ভ কৰি n লৈকে (n অন্তৰ্ভুক্ত কৰি) স্পেচৰ দ্বাৰা পৃথক কৰা সংখ্যাসমূহ থকা এটা ষ্ট্ৰিং ঘূৰাই দিয়ক।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 থেকে শুরু করে n পর্যন্ত (n সহ) স্পেস দ্বারা পৃথক করা সংখ্যার একটি স্ট্রিং রিটার্ন করুন।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 થી શરૂ કરીને n સુધી (n સહિત) સ્પેસ-વિભાજિત સંખ્યાઓ ધરાવતી એક string પરત કરો.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 से लेकर n तक (n सहित) स्पेस से अलग की गई संख्याओं वाली एक स्ट्रिंग लौटाएं।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ n ವರೆಗಿನ (n ಸೇರಿದಂತೆ) ಸ್ಪೇಸ್ನಿಂದ ಬೇರ್ಪಡಿಸಲಾದ ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿರುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 മുതൽ n വരെ (n ഉൾപ്പെടെ) സ്പേസ് ഉപയോഗിച്ച് വേർതിരിച്ച സംഖ്യകൾ അടങ്ങിയ ഒരു സ്ട്രിംഗ് റിട്ടേൺ ചെയ്യുക.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 पासून सुरू होऊन n पर्यंत (समाविष्ट) स्पेसने विभक्त केलेल्या संख्या असलेली स्ट्रिंग परत करा.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 देखि सुरु गरेर n सम्म (n समेत) स्पेसले छुट्याइएका संख्याहरू समावेश भएको स्ट्रिङ फिर्ता गर्नुहोस्।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 ରୁ ଆରମ୍ଭ କରି n ପର୍ଯ୍ୟନ୍ତ (n କୁ ଅନ୍ତର୍ଭୁକ୍ତ କରି) ସ୍ପେସ୍ ଦ୍ୱାରା ପୃଥକ ହୋଇଥିବା ସଂଖ୍ୟାଗୁଡ଼ିକ ଧାରଣ କରିଥିବା ଏକ string ଫେରାନ୍ତୁ।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ n (ਸਮੇਤ) ਤੱਕ ਸਪੇਸ ਨਾਲ ਵੱਖ ਕੀਤੀਆਂ ਸੰਖਿਆਵਾਂ ਵਾਲੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰੋ।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 तः आरभ्य n पर्यन्तं (समावेश्य) रिक्ति-विभक्तानां सङ्ख्यानाम् एकं string प्रत्याददातु।
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 முதல் n வரை (n உட்பட) இடைவெளியால் பிரிக்கப்பட்ட எண்களைக் கொண்ட ஒரு string-ஐ திருப்பியளிக்கவும்.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" 0 నుండి n వరకు (n తో సహా) స్పేస్తో వేరు చేయబడిన సంఖ్యలను కలిగి ఉన్న ఒక స్ట్రింగ్ను రిటర్న్ చేయండి.
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
def string_sequence(n: int) -> str:
""" ایک ایسی string واپس کریں جس میں 0 سے لے کر n تک (بشمول n) space سے الگ کیے گئے اعداد شامل ہوں۔
>>> string_sequence(0)
'0'
>>> string_sequence(5)
'0 1 2 3 4 5'
"""
|
HumanEval/16 |
def count_distinct_characters(string: str) -> int:
""" Given a string, find out how many distinct characters (regardless of case) does it consist of
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
| return len(set(string.lower()))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('abcde') == 5
assert candidate('abcde' + 'cade' + 'CADE') == 5
assert candidate('aaaaAAAAaaaa') == 1
assert candidate('Jerry jERRY JeRRRY') == 5
| count_distinct_characters |
def count_distinct_characters(string: str) -> int:
""" এটা ষ্ট্ৰিং দিয়া থাকিলে, ইয়াত কিমানটা সুকীয়া বৰ্ণ (case নিৰ্বিশেষে) আছে সেয়া নিৰ্ণয় কৰক
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" একটি string দেওয়া হলে, এটি (case নির্বিশেষে) কতটি ভিন্ন ক্যারেক্টার নিয়ে গঠিত তা নির্ণয় করুন
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" આપેલી string માં (case ને ધ્યાનમાં લીધા વિના) કેટલા distinct characters આવેલા છે તે શોધો
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" एक स्ट्रिंग दिए जाने पर, पता लगाएं कि इसमें (केस की परवाह किए बिना) कितने अलग (distinct) वर्ण शामिल हैं
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" ಒಂದು string ನೀಡಿದಾಗ, ಅದು (case ಅನ್ನು ಲೆಕ್ಕಿಸದೆ) ಎಷ್ಟು ವಿಭಿನ್ನ ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" ഒരു സ്ട്രിംഗ് നൽകിയാൽ, അതിൽ (case പരിഗണിക്കാതെ) എത്ര വ്യത്യസ്ത അക്ഷരങ്ങൾ അടങ്ങിയിരിക്കുന്നു എന്ന് കണ്ടെത്തുക
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" दिलेल्या स्ट्रिंगमध्ये (केस विचारात न घेता) किती भिन्न अक्षरे आहेत ते शोधा
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" एउटा string दिइएको अवस्थामा, यसमा (case को बेवास्ता गर्दै) कतिवटा distinct characters छन् पत्ता लगाउनुहोस्
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" ଗୋଟିଏ string ଦିଆଗଲେ, ଏଥିରେ (case କୁ ବିଚାର ନକରି) କେତୋଟି ଭିନ୍ନ ଅକ୍ଷର ରହିଛି ତାହା ନିର୍ଣ୍ଣୟ କରନ୍ତୁ
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" ਇੱਕ string ਦਿੱਤੀ ਜਾਣ 'ਤੇ, ਪਤਾ ਲਗਾਓ ਕਿ ਇਹ (case ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ) ਕਿੰਨੇ ਵੱਖਰੇ ਅੱਖਰਾਂ ਤੋਂ ਬਣੀ ਹੈ
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" दत्तायां स्ट्रिंग् (string) मध्ये, केस (case) अनपेक्ष्य, कति विविधाः वर्णाः सन्ति इति निर्धारयन्तु
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" கொடுக்கப்பட்ட ஒரு string-ல், (case-ஐப் பொருட்படுத்தாமல்) எத்தனை தனித்துவமான எழுத்துக்கள் உள்ளன என்பதைக் கண்டறியவும்
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" ఒక స్ట్రింగ్ ఇవ్వబడినప్పుడు, అందులో ఎన్ని విభిన్న అక్షరాలు (case తో సంబంధం లేకుండా) ఉన్నాయో కనుగొనండి
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
def count_distinct_characters(string: str) -> int:
""" دی گئی ایک string کے لیے، معلوم کریں کہ یہ (case سے قطع نظر) کتنے منفرد حروف پر مشتمل ہے
>>> count_distinct_characters('xyzXYZ')
3
>>> count_distinct_characters('Jerry')
4
"""
|
HumanEval/17 | from typing import List
def parse_music(music_string: str) -> List[int]:
""" Input to this function is a string representing musical notes in a special ASCII format.
Your task is to parse this string and return list of integers corresponding to how many beats does each
not last.
Here is a legend:
... | note_map = {'o': 4, 'o|': 2, '.|': 1}
return [note_map[x] for x in music_string.split(' ') if x]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == []
assert candidate('o o o o') == [4, 4, 4, 4]
assert candidate('.| .| .| .|') == [1, 1, 1, 1]
assert candidate('o| o| .| .| o o o o') == [2, 2, 1, 1, 4, 4, 4, 4]
assert candidate('o| .| o| .| ... | parse_music | from typing import List
def parse_music(music_string: str) -> List[int]:
""" এই ফলনটোৰ ইনপুট হৈছে এটা বিশেষ ASCII ফৰ্মেটত সংগীতৰ সুৰ (musical notes) প্ৰতিনিধিত্ব কৰা এটা ষ্ট্ৰিং।
আপোনাৰ কাম হ'ল এই ষ্ট্ৰিংটো পাৰ্ছ কৰা আৰু প্ৰতিটো সুৰে কিমান বিট সময় লয় তাৰ সৈতে সংগতি ৰাখি পূৰ্ণসংখ্যাৰ এটা তালিকা ৰিটাৰ্ন কৰা।
... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" এই ফাংশনের ইনপুট হলো একটি বিশেষ ASCII ফরম্যাটে মিউজিক্যাল নোট উপস্থাপনকারী একটি স্ট্রিং।
আপনার কাজ হলো এই স্ট্রিংটি পার্স করা এবং প্রতিটি নোট কত বিট স্থায়ী হয় তার সাথে সম্পর্কিত
পূর্ণসংখ্যার একটি তালিকা রিটার্ন করা।
এখানে ... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" આ વિધેય (function) નો ઇનપુટ એક વિશિષ્ટ ASCII ફોર્મેટમાં સંગીતના નોટ્સ (musical notes) દર્શાવતી એક સ્ટ્રિંગ છે.
તમારું કાર્ય આ સ્ટ્રિંગને પાર્સ કરવાનું અને દરેક નોટ કેટલા બીટ્સ સુધી ચાલે છે તેને અનુરૂપ પૂર્ણાંકોની યાદી પરત કરવાનું છે.... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" इस फ़ंक्शन का इनपुट एक विशेष ASCII प्रारूप में संगीत के स्वरों (musical notes) को दर्शाने वाली एक स्ट्रिंग है।
आपका कार्य इस स्ट्रिंग को पार्स करना और प्रत्येक स्वर कितनी बीट तक रहता है, इसके संगत पूर्णांकों (integers) की एक सूची लौट... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" ಈ ಫಂಕ್ಷನ್ಗೆ ಇನ್ಪುಟ್ ಒಂದು ವಿಶೇಷ ASCII ಮಾದರಿಯಲ್ಲಿ ಸಂಗೀತದ ಸ್ವರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.
ಈ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು ಮತ್ತು ಪ್ರತಿ ಸ್ವರವು ಎಷ್ಟು ಬೀಟ್ಗಳವರೆಗೆ ಇರುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಅನುಗುಣವಾದ
ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗ... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" ഈ ഫംഗ്ഷനിലേക്കുള്ള ഇൻപുട്ട് ഒരു പ്രത്യേക ASCII ഫോർമാറ്റിലുള്ള മ്യൂസിക്കൽ നോട്ടുകളെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് ആണ്.
ഈ സ്ട്രിംഗ് പാഴ്സ് ചെയ്ത് ഓരോ നോട്ടും എത്ര ബീറ്റുകൾ നീണ്ടുനിൽക്കുന്നു എന്നതിനെ സൂചിപ്പിക്കുന്ന പൂർണ്ണസംഖ്യകളുട... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" या फंक्शनचे इनपुट एका विशेष ASCII फॉरमॅटमधील musical notes दर्शवणारी एक स्ट्रिंग आहे.
तुमचे कार्य या स्ट्रिंगचे विश्लेषण (parse) करणे आणि प्रत्येक नोट किती बीट्स टिकते
याच्याशी संबंधित पूर्णांकांची एक सूची (list of integers) परत ... | टाइपिङ इम्पोर्ट सूचीबाट लिइएको
def parse_music(music_string: str) -> List[int]:
""" यस प्रकार्यको इनपुट एक विशेष ASCII ढाँचामा सांगीतिक नोटहरू प्रतिनिधित्व गर्ने स्ट्रिङ हो।
तपाईंको कार्य यो स्ट्रिङ पार्स गर्नु र प्रत्येक नोट कति बीट लम्बिने गर्दछ त्यसैसँग सम्बन्धित इन्टिजरहरूको सूची
उपलब्ध गराउनु हो।
... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" ଏହି function କୁ ଇନପୁଟ୍ ହେଉଛି ଏକ ସ୍ୱତନ୍ତ୍ର ASCII format ରେ musical notes କୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ string।
ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି ଏହି string କୁ parse କରିବା ଏବଂ ପ୍ରତ୍ୟେକ note କେତୋଟି beats ପର୍ଯ୍ୟନ୍ତ ରହେ
ତାହା ସହିତ ସମ୍ପର୍କିତ integers ର... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਇਨਪੁਟ ਇੱਕ ਖਾਸ ASCII ਫਾਰਮੈਟ ਵਿੱਚ ਸੰਗੀਤਕ ਨੋਟਸ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ।
ਤੁਹਾਡਾ ਕੰਮ ਇਸ ਸਟ੍ਰਿੰਗ ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਅਤੇ ਹਰੇਕ ਨੋਟ ਕਿੰਨੀਆਂ ਬੀਟਾਂ ਤੱਕ ਰਹਿੰਦਾ ਹੈ, ਉਸ ਅਨੁਸਾਰ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਸੂਚੀ
ਵਾਪਸ ਕਰਨਾ ਹੈ।
ਇੱਥੇ ਇੱਕ ਸੰਕੇਤ-ਸੂ... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" अस्य फलनस्य कृते निवेशः कश्चन स्ट्रिंग् (string) अस्ति यः कस्मिश्चित् विशिष्टे ASCII प्रारूपे सङ्गीतस्वरान् निरूपयति।
भवतः कार्यम् अस्य स्ट्रिंग्-मूल्यस्य पार्सनं कृत्वा प्रत्येकः स्वरः कियत् तालान् (beats) यावत् प्रचलति तदनुसारं पूर... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" இந்தச் செயற்கூறுக்கான உள்ளீடு ஒரு சிறப்பு ASCII வடிவத்தில் இசைக் குறிப்புகளைக் குறிக்கும் ஒரு string ஆகும்.
இந்த string-ஐ parse செய்து, ஒவ்வொரு குறிப்பும் எத்தனை beats நீடிக்கிறது என்பதற்குரிய integers பட்டியலைத்
திருப்புவதே உங்க... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" ఈ ఫంక్షన్కు ఇన్పుట్ అనేది ఒక ప్రత్యేకమైన ASCII ఫార్మాట్లో సంగీత స్వరాలను (musical notes) సూచించే ఒక స్ట్రింగ్.
ఈ స్ట్రింగ్ను పార్స్ చేసి, ప్రతి నోట్ ఎన్ని బీట్ల పాటు కొనసాగుతుందో తెలిపే పూర్ణాంకాల జాబితాను (list of integers) తిరి... | from typing import List
def parse_music(music_string: str) -> List[int]:
""" اس فنکشن کا ان پٹ ایک سٹرنگ ہے جو ایک خاص ASCII فارمیٹ میں میوزیکل نوٹس کی نمائندگی کرتی ہے۔
آپ کا کام اس سٹرنگ کو پارس کرنا اور انٹیجرز کی ایسی لسٹ واپس کرنا ہے جو ظاہر کرے کہ ہر
نوٹ کتنی بیٹس (beats) تک جاری رہتا ہے۔
لیجنڈ... |
HumanEval/18 |
def how_many_times(string: str, substring: str) -> int:
""" Find how many times a given substring can be found in the original string. Count overlaping cases.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
| times = 0
for i in range(len(string) - len(substring) + 1):
if string[i:i+len(substring)] == substring:
times += 1
return times
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('', 'x') == 0
assert candidate('xyxyxyx', 'x') == 4
assert candidate('cacacacac', 'cac') == 4
assert candidate('john doe', 'john') == 1
| how_many_times |
def how_many_times(string: str, substring: str) -> int:
""" মূল string-টোত এটা নিৰ্দিষ্ট substring কিমানবাৰ পোৱা যাব পাৰে সেয়া নিৰ্ণয় কৰক। Overlapping ক্ষেত্রসমূহো গণনা কৰক।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" একটি প্রদত্ত substring মূল string-এ কতবার পাওয়া যায় তা বের করুন। Overlapping ক্ষেত্রগুলোও গণনা করুন।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" મૂળ string માં આપેલ substring કેટલી વાર મળી શકે છે તે શોધો. Overlapping કિસ્સાઓ પણ ગણો.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" ज्ञात करें कि मूल string में दिया गया substring कितनी बार पाया जा सकता है। ओवरलैप होने वाले मामलों को भी गिनें।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" ನೀಡಿರುವ substring ಮೂಲ string ನಲ್ಲಿ ಎಷ್ಟು ಬಾರಿ ಕಂಡುಬರುತ್ತದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ. ಅತಿಕ್ರಮಿಸುವ (overlapping) ಸಂದರ್ಭಗಳನ್ನು ಎಣಿಸಿ.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
... |
def how_many_times(string: str, substring: str) -> int:
""" നൽകിയിട്ടുള്ള string-ൽ തന്നിരിക്കുന്ന substring എത്ര തവണ കണ്ടെത്താൻ കഴിയുമെന്ന് കണ്ടെത്തുക. Overlapping ആയുള്ള സന്ദർഭങ്ങളും എണ്ണുക.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
... |
def how_many_times(string: str, substring: str) -> int:
""" मूळ string मध्ये दिलेली substring किती वेळा आढळू शकते ते शोधा. ओव्हरलॅपिंग (overlapping) प्रकरणांची गणना करा.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" दिइएको मूल string मा कुनै दिइएको substring कति पटक फेला पार्न सकिन्छ पत्ता लगाउनुहोस्। ओभरल्याप हुने केसहरू पनि गणना गर्नुहोस्।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
... |
def how_many_times(string: str, substring: str) -> int:
""" ମୂଳ string ରେ ଏକ ଦିଆଯାଇଥିବା substring କେତେ ଥର ମିଳିପାରିବ ତାହା ଖୋଜନ୍ତୁ। Overlapping କ୍ଷେତ୍ରଗୁଡ଼ିକୁ ଗଣନା କରନ୍ତୁ।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" ਪਤਾ ਕਰੋ ਕਿ ਦਿੱਤੀ ਗਈ substring ਮੂਲ string ਵਿੱਚ ਕਿੰਨੀ ਵਾਰ ਲੱਭੀ ਜਾ ਸਕਦੀ ਹੈ। ਓਵਰਲੈਪ ਹੋਣ ਵਾਲੇ ਕੇਸਾਂ ਦੀ ਵੀ ਗਿਣਤੀ ਕਰੋ।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" दत्तायां मूल-string मध्ये कश्चन दत्तः substring कतिवारं प्राप्यते इति अन्विष्यतु। परस्परव्यापकान् (overlapping) सन्दर्भान् गणयतु।
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
... |
def how_many_times(string: str, substring: str) -> int:
""" கொடுக்கப்பட்ட அசல் string-இல் கொடுக்கப்பட்ட substring எத்தனை முறை காணப்படுகிறது என்பதைக் கண்டறியவும். ஒன்றுடன் ஒன்று மேற்பொருந்தும் (overlapping) நிகழ்வுகளையும் கணக்கிடவும்.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
... |
def how_many_times(string: str, substring: str) -> int:
""" ఇచ్చిన అసలు string లో ఇచ్చిన substring ఎన్నిసార్లు కనిపిస్తుందో కనుగొనండి. Overlapping సందర్భాలను కూడా లెక్కించండి.
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
def how_many_times(string: str, substring: str) -> int:
""" معلوم کریں کہ دی گئی substring اصل string میں کتنی بار مل سکتی ہے۔ اوورلیپنگ (overlapping) کیسز کو بھی شمار کریں۔
>>> how_many_times('', 'a')
0
>>> how_many_times('aaa', 'a')
3
>>> how_many_times('aaaa', 'aa')
3
"""
|
HumanEval/19 | from typing import List
def sort_numbers(numbers: str) -> str:
""" Input is a space-delimited string of numberals from 'zero' to 'nine'.
Valid choices are 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' and 'nine'.
Return the string with numbers sorted from smallest to largest
>... | value_map = {
'zero': 0,
'one': 1,
'two': 2,
'three': 3,
'four': 4,
'five': 5,
'six': 6,
'seven': 7,
'eight': 8,
'nine': 9
}
return ' '.join(sorted([x for x in numbers.split(' ') if x], key=lambda x: value_map[x]))
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('three') == 'three'
assert candidate('three five nine') == 'three five nine'
assert candidate('five zero four seven nine eight') == 'zero four five seven eight nine'
assert ... | sort_numbers | from typing import List
def sort_numbers(numbers: str) -> str:
""" ইনপুট হৈছে 'zero' ৰ পৰা 'nine' লৈ সংখ্যাৰ এটা স্পেচ-বিভাজিত ষ্ট্ৰিং।
বৈধ বিকল্পসমূহ হ'ল 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' আৰু 'nine'।
সংখ্যাবোৰ সৰুৰ পৰা ডাঙৰলৈ সজাই ষ্ট্ৰিংটো ৰিটাৰ্ন কৰক
>>> sort_nu... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ইনপুট হলো 'zero' থেকে 'nine' পর্যন্ত সংখ্যার একটি স্পেস-বিভক্ত স্ট্রিং।
বৈধ পছন্দগুলো হলো 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' এবং 'nine'।
ছোট থেকে বড় ক্রমানুসারে সাজানো সংখ্যাগুলোর স্ট্রিংটি রিটার্ন করুন
... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ઇનપુટ એ 'zero' થી 'nine' સુધીના અંકોની સ્પેસ-વિભાજિત (space-delimited) સ્ટ્રિંગ છે.
માન્ય વિકલ્પો 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' અને 'nine' છે.
સૌથી નાનાથી મોટા ક્રમમાં ગોઠવેલી સંખ્યાઓ સાથેની સ્ટ્રિં... | from typing import List
def sort_numbers(numbers: str) -> str:
""" इनपुट 'zero' से 'nine' तक के संख्या-शब्दों (numberals) की स्पेस-डिलिमिटेड स्ट्रिंग है।
मान्य विकल्प 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' और 'nine' हैं।
संख्याओं को सबसे छोटे से सबसे बड़े क्रम में सॉर्ट करक... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ಇನ್ಪುಟ್ ಎಂಬುದು 'zero' ದಿಂದ 'nine' ವರೆಗಿನ ಸಂಖ್ಯಾಪದಗಳ ಸ್ಪೇಸ್-ಡಿಲಿಮಿಟೆಡ್ ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ.
ಮಾನ್ಯವಾದ ಆಯ್ಕೆಗಳು 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' ಮತ್ತು 'nine'.
ಸಂಖ್ಯೆಗಳನ್ನು ಚಿಕ್ಕದರಿಂದ ದೊಡ್ಡದರ ಕ್ರಮದಲ್ಲಿ ವಿಂಗಡಿ... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ഇൻപുട്ട് എന്നത് 'zero' മുതൽ 'nine' വരെയുള്ള സംഖ്യകളുടെ സ്പേസ് കൊണ്ട് വേർതിരിച്ച ഒരു സ്ട്രിംഗ് ആണ്.
സാധുവായ ചോയ്സുകൾ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine' എന്നിവയാണ്.
സംഖ്യകൾ ഏറ്റവും ചെറുതിൽ നിന്ന് ... | from typing import List
def sort_numbers(numbers: str) -> str:
""" इनपुट ही 'zero' ते 'nine' पर्यंतच्या संख्यांची स्पेस-डिलिमिटेड स्ट्रिंग आहे.
वैध पर्याय 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' आणि 'nine' आहेत.
संख्यांची लहानाकडून मोठ्याकडे क्रमवारी लावलेली स्ट्रिंग परत करा... | from typing import List
def sort_numbers(numbers: str) -> str:
""" इनपुट 'zero' देखि 'nine' सम्मका संख्याहरूको स्पेसले छुट्याइएको स्ट्रिङ हो।
मान्य विकल्पहरू 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' र 'nine' हुन्।
संख्याहरूलाई सानोबाट ठूलो क्रममा क्रमबद्ध गरिएको स्ट्रिङ फिर्त... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ଇନପୁଟ୍ ହେଉଛି 'zero' ରୁ 'nine' ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ସ୍ପେସ୍-ବିଭାଜିତ (space-delimited) ଷ୍ଟ୍ରିଙ୍ଗ।
ବୈଧ ବିକଳ୍ପଗୁଡ଼ିକ ହେଉଛି 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' ଏବଂ 'nine'।
କ୍ଷୁଦ୍ରତମରୁ ବୃହତ୍ତମ କ୍ରମରେ ସଜାଯା... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ਇਨਪੁਟ 'zero' ਤੋਂ 'nine' ਤੱਕ ਦੇ ਅੰਕਾਂ ਦੀ ਇੱਕ space-delimited string ਹੈ।
ਮਾਨਯੋਗ ਵਿਕਲਪ 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' ਅਤੇ 'nine' ਹਨ।
ਸਭ ਤੋਂ ਛੋਟੇ ਤੋਂ ਸਭ ਤੋਂ ਵੱਡੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ (sorted) ਸੰਖਿਆਵਾਂ ਵਾਲੀ ... | from typing import List
def sort_numbers(numbers: str) -> str:
""" आदानं 'zero' तः 'nine' पर्यन्तं सङ्ख्याशब्दानां रिक्तस्थान-विभक्ता (space-delimited) स्ट्रिंग् वर्तते।
वैधविकल्पाः 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' तथा 'nine' सन्ति।
लघुतमक्रमात् बृहत्तमक्रमपर्यन्तं क्... | from typing import List
def sort_numbers(numbers: str) -> str:
""" உள்ளீடு என்பது 'zero' முதல் 'nine' வரையிலான எண்களின் இடைவெளியால் பிரிக்கப்பட்ட ஒரு string ஆகும்.
செல்லுபடியாகும் தேர்வுகள் 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' மற்றும் 'nine' ஆகும்.
சிறியதிலிருந்து பெரியது... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ఇన్పుట్ అనేది 'zero' నుండి 'nine' వరకు గల సంఖ్యల స్పేస్-డీలిమిటెడ్ (space-delimited) స్ట్రింగ్.
చెల్లుబాటు అయ్యే ఎంపికలు 'zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight' మరియు 'nine'.
చిన్న నుండి పెద్ద క్రమంలో సంఖ్యల... | from typing import List
def sort_numbers(numbers: str) -> str:
""" ان پٹ 'zero' سے 'nine' تک کے ہندسوں کی ایک space-delimited سٹرنگ ہے۔
درست اختیارات 'zero'، 'one'، 'two'، 'three'، 'four'، 'five'، 'six'، 'seven'، 'eight' اور 'nine' ہیں۔
اعداد کو چھوٹے سے بڑے کی ترتیب میں ترتیب دے کر سٹرنگ واپس کریں
>>... |
HumanEval/20 | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" From a supplied list of numbers (of length at least two) select and return two that are the closest to each
other and return them in order (smaller number, larger number).
>>> find_closest_elements([... | closest_pair = None
distance = None
for idx, elem in enumerate(numbers):
for idx2, elem2 in enumerate(numbers):
if idx != idx2:
if distance is None:
distance = abs(elem - elem2)
closest_pair = tuple(sorted([elem, elem2]))
... |
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([1.0, 2.0, 3.9, 4.0, 5.0, 2.2]) == (3.9, 4.0)
assert candidate([1.0, 2.0, 5.9, 4.0, 5.0]) == (5.0, 5.9)
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0, 2.2]) == (2.0, 2.2)
assert candidate([1.0, 2.0, 3.0, 4.0,... | find_closest_elements | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" যোগান ধৰা এটা সংখ্যাৰ তালিকাৰ পৰা (যাৰ দৈৰ্ঘ্য কমেও দুই) পৰস্পৰৰ আটাইতকৈ ওচৰত থকা দুটা সংখ্যা
বাছনি কৰক আৰু সেই দুটাক ক্ৰমত (সৰু সংখ্যা, ডাঙৰ সংখ্যা) ঘূৰাই দিয়ক।
>>> find_closest_elements([1.0, 2.0,... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" প্রদত্ত সংখ্যার একটি তালিকা (যার দৈর্ঘ্য কমপক্ষে দুই) থেকে এমন দুটি সংখ্যা নির্বাচন করুন যা একে অপরের সবচেয়ে
কাছাকাছি এবং সেগুলিকে ক্রমানুসারে (ছোট সংখ্যা, বড় সংখ্যা) রিটার্ন করুন।
>>> find_closest... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" આપેલી સંખ્યાઓની લિસ્ટ (ઓછામાં ઓછી બે લંબાઈની) માંથી એવી બે સંખ્યાઓ પસંદ કરો જે એકબીજાની સૌથી નજીક હોય અને તેમને ક્રમમાં (નાની સંખ્યા, મોટી સંખ્યા) રિટર્ન કરો.
>>> find_closest_elements([1.0, 2.0, 3.0, 4.... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" दी गई संख्याओं की सूची (कम से कम दो लंबाई की) में से ऐसी दो संख्याएँ चुनें और लौटाएँ जो एक दूसरे के सबसे करीब हों तथा उन्हें क्रमबद्ध रूप में (छोटी संख्या, बड़ी संख्या) लौटाएँ।
>>> find_closest_elements(... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" ನೀಡಲಾದ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯಿಂದ (ಕನಿಷ್ಠ ಎರಡು ಉದ್ದವಿರುವ) ಪರಸ್ಪರ ಅತ್ಯಂತ ಸಮೀಪದಲ್ಲಿರುವ
ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಅವುಗಳನ್ನು ಕ್ರಮದಲ್ಲಿ (ಚಿಕ್ಕ ಸಂಖ್ಯೆ, ದೊಡ್ಡ ಸಂಖ್ಯೆ) ಹಿಂತಿರುಗಿಸಿ.
>>> find_closest_elements(... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" നൽകിയിട്ടുള്ള സംഖ്യകളുടെ ലിസ്റ്റിൽ നിന്ന് (കുറഞ്ഞത് രണ്ട് നീളമുള്ളത്) പരസ്പരം ഏറ്റവും അടുത്തുള്ള രണ്ട് സംഖ്യകൾ തിരഞ്ഞെടുത്ത് അവയെ ക്രമത്തിൽ (ചെറിയ സംഖ്യ, വലിയ സംഖ്യ) നൽകുക.
>>> find_closest_elements([1.0... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" दिलेल्या संख्यांच्या सूचीमधून (किमान दोन लांबीची) एकमेकांच्या सर्वात जवळ असणाऱ्या दोन संख्या निवडा
आणि त्या क्रमाने (लहान संख्या, मोठी संख्या) परत करा.
>>> find_closest_elements([1.0, 2.0, 3.0, 4.0, ... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" दिइएको संख्याहरूको सूची (कम्तीमा दुई लम्बाइ भएको) बाट एकअर्कासँग सबैभन्दा नजिक रहेका दुईवटा संख्याहरू छनोट गर्नुहोस् र तिनीहरूलाई क्रममा (सानो संख्या, ठूलो संख्या) फिर्ता गर्नुहोस्।
>>> find_closest_elem... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" ପ୍ରଦତ୍ତ ସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ତାଲିକାରୁ (ଯାହାର ଦୈର୍ଘ୍ୟ ଅତି କମରେ ଦୁଇ) ପରସ୍ପର ସହିତ ସବୁଠାରୁ ନିକଟତର ଥିବା ଦୁଇଟି ସଂଖ୍ୟା ବାଛନ୍ତୁ
ଏବଂ ସେଗୁଡ଼ିକୁ କ୍ରମାନୁସାରେ (ଛୋଟ ସଂଖ୍ୟା, ବଡ଼ ସଂଖ୍ୟା) ଫେରାନ୍ତୁ।
>>> find_closest_eleme... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" ਦਿੱਤੀ ਗਈ ਸੰਖਿਆਵਾਂ ਦੀ ਸੂਚੀ (ਘੱਟੋ-ਘੱਟ ਦੋ ਦੀ ਲੰਬਾਈ ਵਾਲੀ) ਵਿੱਚੋਂ ਉਹ ਦੋ ਸੰਖਿਆਵਾਂ ਚੁਣੋ ਅਤੇ ਵਾਪਸ ਕਰੋ ਜੋ ਇੱਕ ਦੂਜੇ ਦੇ ਸਭ ਤੋਂ ਨੇੜੇ ਹਨ
ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕ੍ਰਮ ਵਿੱਚ (ਛੋਟੀ ਸੰਖਿਆ, ਵੱਡੀ ਸੰਖਿਆ) ਵਾਪਸ ਕਰੋ।
>>> find_closest... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" प्रदत्तायाः संख्यानां सूच्याः (यस्याः दैर्घ्यं न्यूनतमतया द्वौ भवेत्) परस्परं सर्वाधिकनिकटवर्तिन्यौ द्वे संख्यौ चित्वा ते क्रमेण (लघुसंख्या, बृहत्संख्या) प्रतिददातु।
>>> find_closest_elements([1.0, 2.0, ... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" வழங்கப்பட்ட எண்களின் பட்டியலில் இருந்து (குறைந்தது இரண்டு நீளம் கொண்டது) ஒன்றுக்கொன்று மிகவும் நெருக்கமாக
இருக்கும் இரண்டு எண்களைத் தேர்ந்தெடுத்து, அவற்றை வரிசைப்படி (சிறிய எண், பெரிய எண்) திருப்பியளிக்க... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" ఇవ్వబడిన సంఖ్యల జాబితా నుండి (కనీసం రెండు పొడవు గల), ఒకదానికొకటి అత్యంత సమీపంలో ఉండే రెండు సంఖ్యలను ఎంచుకుని,
వాటిని క్రమంలో (చిన్న సంఖ్య, పెద్ద సంఖ్య) రిటర్న్ చేయండి.
>>> find_closest_elements([1.0,... | from typing import List, Tuple
def find_closest_elements(numbers: List[float]) -> Tuple[float, float]:
""" دی گئی اعداد کی فہرست (جس کی لمبائی کم از کم دو ہو) میں سے دو ایسے اعداد منتخب کریں جو ایک دوسرے کے سب سے قریب ہوں اور انہیں ترتیب سے (چھوٹا عدد، بڑا عدد) واپس کریں۔
>>> find_closest_elements([1.0, 2.0, ... |
HumanEval/21 | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" Given list of numbers (of at least two elements), apply a linear transform to that list,
such that the smallest number will become 0 and the largest will become 1
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, ... | min_number = min(numbers)
max_number = max(numbers)
return [(x - min_number) / (max_number - min_number) for x in numbers]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([2.0, 49.9]) == [0.0, 1.0]
assert candidate([100.0, 49.9]) == [1.0, 0.0]
assert candidate([1.0, 2.0, 3.0, 4.0, 5.0]) == [0.0, 0.25, 0.5, 0.75, 1.0]
assert candidate([2.0, 1.0, 5.0, 3.0, 4.0]) == [0.25, 0.... | rescale_to_unit | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" এটা সংখ্যাৰ তালিকা দিয়া থাকিলে (য'ত অন্ততঃ দুটা উপাদান আছে), সেই তালিকাখনত এটা linear transform প্ৰয়োগ কৰক,
যাতে আটাইতকৈ সৰু সংখ্যাটো 0 হয় আৰু আটাইতকৈ ডাঙৰটো 1 হয়
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" সংখ্যার একটি তালিকা (কমপক্ষে দুটি উপাদানের) দেওয়া থাকলে, সেই তালিকায় একটি linear transform প্রয়োগ করুন,
যাতে ক্ষুদ্রতম সংখ্যাটি 0 এবং বৃহত্তম সংখ্যাটি 1 হয়ে যায়
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" આપેલી સંખ્યાઓની લિસ્ટ (ઓછામાં ઓછા બે ઘટકો ધરાવતી) પર એક લીનિયર ટ્રાન્સફોર્મ લાગુ કરો,
જેથી સૌથી નાની સંખ્યા 0 બની જશે અને સૌથી મોટી સંખ્યા 1 બની જશે
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.7... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" दी गई संख्याओं की सूची (कम से कम दो तत्वों वाली) पर एक रैखिक रूपांतरण (linear transform) लागू करें,
ताकि सबसे छोटी संख्या 0 बन जाए और सबसे बड़ी संख्या 1 बन जाए
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.2... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" ನೀಡಲಾದ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಗೆ (ಕನಿಷ್ಠ ಎರಡು ಅಂಶಗಳಿರುವ), ಆ ಪಟ್ಟಿಗೆ ರೇಖೀಯ ರೂಪಾಂತರವನ್ನು ಅನ್ವಯಿಸಿ,
ಇದರಿಂದ ಅತ್ಯಂತ ಚಿಕ್ಕ ಸಂಖ್ಯೆಯು 0 ಆಗುತ್ತದೆ ಮತ್ತು ಅತ್ಯಂತ ದೊಡ್ಡ ಸಂಖ್ಯೆಯು 1 ಆಗುತ್ತದೆ
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" തന്നിരിക്കുന്ന സംഖ്യകളുടെ ലിസ്റ്റിൽ (കുറഞ്ഞത് രണ്ട് എലമെന്റുകളെങ്കിലും ഉള്ളത്), ഏറ്റവും ചെറിയ സംഖ്യ 0 ആയും ഏറ്റവും വലിയ സംഖ്യ 1 ആയും മാറുന്ന രീതിയിൽ ഒരു ലീനിയർ ട്രാൻസ്ഫോർമേഷൻ പ്രയോഗിക്കുക
>>> rescale_to_unit([1.0, 2.0, 3.0, ... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" दिलेल्या संख्यांच्या सूचीवर (किमान दोन घटकांची), असा लिनियर ट्रान्सफॉर्म लागू करा,
ज्यामुळे सर्वात लहान संख्या 0 होईल आणि सर्वात मोठी संख्या 1 होईल
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.75... | टाइपिङ इम्पोर्ट सूचीबाट लिइएको
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" संख्याहरूको दिइएको सूची (कम्तीमा दुई तत्वहरू भएको) मा, उक्त सूचीमा एक रैखिक रूपान्तरण लागू गर्नुहोस्,
ताकि सबैभन्दा सानो संख्या 0 र सबैभन्दा ठूलो संख्या 1 बनोस्
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" ସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ତାଲିକା (ଅତି କମରେ ଦୁଇଟି ଉପାଦାନ ଥିବା) ଦିଆଗଲେ, ସେହି ତାଲିକାରେ ଏକ linear transform ପ୍ରୟୋଗ କରନ୍ତୁ,
ଯେପରିକି ସବୁଠାରୁ ଛୋଟ ସଂଖ୍ୟା 0 ହେବ ଏବଂ ସବୁଠାରୁ ବଡ଼ ସଂଖ୍ୟା 1 ହେବ
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" ਸੰਖਿਆਵਾਂ ਦੀ ਦਿੱਤੀ ਗਈ ਸੂਚੀ (ਘੱਟੋ-ਘੱਟ ਦੋ ਐਲੀਮੈਂਟਸ ਵਾਲੀ) 'ਤੇ ਇੱਕ linear transform ਲਾਗੂ ਕਰੋ,
ਤਾਂ ਜੋ ਸਭ ਤੋਂ ਛੋਟੀ ਸੰਖਿਆ 0 ਬਣ ਜਾਵੇ ਅਤੇ ਸਭ ਤੋਂ ਵੱਡੀ 1 ਬਣ ਜਾਵੇ
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" दत्तायां सङ्ख्यानां सूच्याम् (न्यूनातिन्यूनं द्वयोः घटकयोः), तस्यां सूचौ तादृशं रैखिकं रूपान्तरणं प्रयोज्यताम्,
यथा लघुतमा सङ्ख्या 0 तथा महत्तमा सङ्ख्या 1 भवेत्
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" கொடுக்கப்பட்ட எண்களின் பட்டியலுக்கு (குறைந்தது இரண்டு உறுப்புகள் கொண்ட), மிகச்சிறிய எண் 0 ஆகவும் மிகப்பெரிய எண் 1 ஆகவும் மாறும் வகையில், அந்தப் பட்டியலில் நேரியல் உருமாற்றத்தைப் (linear transform) பிரயோகிக்கவும்
>>> rescale_... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" ఇవ్వబడిన సంఖ్యల లిస్ట్కు (కనీసం రెండు ఎలిమెంట్లు కలిగినది), ఒక లీనియర్ ట్రాన్స్ఫార్మ్ను వర్తింపజేయండి,
తద్వారా అతిచిన్న సంఖ్య 0 మరియు అతిపెద్ద సంఖ్య 1 అవుతుంది
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, ... | from typing import List
def rescale_to_unit(numbers: List[float]) -> List[float]:
""" دی گئی اعداد کی لسٹ (کم از کم دو عناصر پر مشتمل) پر ایک لکیری تبدیلی (linear transform) لاگو کریں،
تاکہ سب سے چھوٹا عدد 0 اور سب سے بڑا عدد 1 بن جائے
>>> rescale_to_unit([1.0, 2.0, 3.0, 4.0, 5.0])
[0.0, 0.25, 0.5, 0.... |
HumanEval/22 | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" Filter given list of any python values only for integers
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| return [x for x in values if isinstance(x, int)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([4, {}, [], 23.2, 9, 'adasd']) == [4, 9]
assert candidate([3, 'c', 3, 3, 'a', 'b']) == [3, 3, 3]
| filter_integers | from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" যিকোনো python মানৰ প্ৰদত্ত তালিকাখন কেৱল integer-ৰ বাবে ফিল্টাৰ কৰক
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" যেকোনো python মানের প্রদত্ত একটি তালিকা থেকে শুধুমাত্র পূর্ণসংখ্যাগুলো ফিল্টার করুন
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" કોઈપણ python વેલ્યુઓની આપેલ લિસ્ટમાંથી ફક્ત પૂર્ણાંકો (integers) ફિલ્ટર કરો
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" किसी भी python मानों की दी गई सूची में से केवल पूर्णांकों (integers) को फ़िल्टर करें
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" ನೀಡಲಾದ ಯಾವುದೇ python ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯಿಂದ ಕೇವಲ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" നൽകിയിരിക്കുന്ന പൈത്തൺ മൂല്യങ്ങളുടെ ലിസ്റ്റിൽ നിന്ന് ഇന്റിജറുകൾ മാത്രം ഫിൽട്ടർ ചെയ്യുക
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" दिलेल्या कोणत्याही python मूल्यांच्या सूचीमधून फक्त integers फिल्टर करा
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" कुनै पनि python मानहरूको दिइएको सूचीबाट केवल integers मात्र फिल्टर गर्नुहोस्
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" ପ୍ରଦତ୍ତ ଯେକୌଣସି python ମୂଲ୍ୟଗୁଡ଼ିକର ତାଲିକାରୁ କେବଳ integers କୁ ଫିଲ୍ଟର କରନ୍ତୁ
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" ਕਿਸੇ ਵੀ python ਮੁੱਲਾਂ ਦੀ ਦਿੱਤੀ ਗਈ ਸੂਚੀ ਨੂੰ ਸਿਰਫ਼ ਪੂਰਨ ਅੰਕਾਂ (integers) ਲਈ ਫ਼ਿਲਟਰ ਕਰੋ
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" दत्तायाः कस्यापि python-मूल्यानां सूच्याः केवलं पूर्णाङ्कान् निष्पन्दयन्तु (filter कुर्वन्तु)
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" கொடுக்கப்பட்ட ஏதேனும் python மதிப்புகளின் பட்டியலிலிருந்து முழு எண்களை (integers) மட்டும் வடிகட்டவும்
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" ఇచ్చిన ఏవైనా python విలువల జాబితా నుండి కేవలం integers మాత్రమే ఫిల్టర్ చేయండి
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
| from typing import List, Any
def filter_integers(values: List[Any]) -> List[int]:
""" دی گئی کسی بھی python values کی فہرست کو صرف integers کے لیے فلٹر کریں
>>> filter_integers(['a', 3.14, 5])
[5]
>>> filter_integers([1, 2, 3, 'abc', {}, []])
[1, 2, 3]
"""
|
HumanEval/23 |
def strlen(string: str) -> int:
""" Return length of given string
>>> strlen('')
0
>>> strlen('abc')
3
"""
| return len(string)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == 0
assert candidate('x') == 1
assert candidate('asdasnakj') == 9
| strlen |
def strlen(string: str) -> int:
""" প্ৰদত্ত string-ৰ দৈৰ্ঘ্য ঘূৰাই দিয়ক
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" প্রদত্ত string-এর দৈর্ঘ্য রিটার্ন করুন
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" આપેલી string ની લંબાઈ પરત કરો
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" दी गई string की लंबाई लौटाएं
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" ನೀಡಲಾದ ಸ್ಟ್ರಿಂಗ್ನ ಉದ್ದವನ್ನು ಹಿಂತಿರುಗಿಸಿ
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" നൽകിയിരിക്കുന്ന string-ന്റെ നീളം തിരികെ നൽകുക
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" दिलेल्या string ची लांबी परत करा
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" दिइएको string को लम्बाइ फर्काउनुहोस्
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" ପ୍ରଦତ୍ତ string ର ଲମ୍ବ ଫେରାନ୍ତୁ
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" ਦਿੱਤੀ ਗਈ string ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰੋ
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" दत्तस्य string इत्यस्य दैर्घ्यं प्रत्यर्पयतु
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" கொடுக்கப்பட்ட string-இன் நீளத்தைத் திருப்பியளிக்கவும்
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" ఇచ్చిన string యొక్క పొడవును రిటర్న్ చేయండి
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
def strlen(string: str) -> int:
""" دی گئی سٹرنگ کی لمبائی واپس کریں۔
>>> strlen('')
0
>>> strlen('abc')
3
"""
|
HumanEval/24 |
def largest_divisor(n: int) -> int:
""" For a given number n, find the largest number that divides n evenly, smaller than n
>>> largest_divisor(15)
5
"""
| for i in reversed(range(n)):
if n % i == 0:
return i
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(3) == 1
assert candidate(7) == 1
assert candidate(10) == 5
assert candidate(100) == 50
assert candidate(49) == 7
| largest_divisor |
def largest_divisor(n: int) -> int:
""" এটা প্ৰদত্ত সংখ্যা n-ৰ বাবে, n-ক নিঃশেষে বিভাজ্য কৰা n-তকৈ সৰু আটাইতকৈ ডাঙৰ সংখ্যাটো বিচাৰক
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" একটি প্রদত্ত সংখ্যা n-এর জন্য, n-এর চেয়ে ছোট এমন বৃহত্তম সংখ্যাটি খুঁজুন যা n-কে নিঃশেষে বিভাজ্য করে
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" આપેલ સંખ્યા n માટે, n કરતાં નાની એવી સૌથી મોટી સંખ્યા શોધો જે n ને નિઃશેષ ભાગી શકે
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" दी गई संख्या n के लिए, n से छोटी वह सबसे बड़ी संख्या ज्ञात करें जो n को पूरी तरह से विभाजित करती है
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" ಕೊಟ್ಟಿರುವ ಸಂಖ್ಯೆ n ಗೆ, n ಅನ್ನು ನಿಶ್ಶೇಷವಾಗಿ ಭಾಗಿಸುವ, n ಗಿಂತ ಚಿಕ್ಕದಾದ ಅತಿ ದೊಡ್ಡ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" നൽകിയിരിക്കുന്ന സംഖ്യ n-ന്, n-നെ നിശ്ശേഷം ഹരിക്കാൻ കഴിയുന്നതും n-നേക്കാൾ ചെറുതുമായ ഏറ്റവും വലിയ സംഖ്യ കണ്ടെത്തുക
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" दिलेल्या n संख्येसाठी, n पेक्षा लहान असणारी आणि n ला पूर्ण भाग जाणारी सर्वात मोठी संख्या शोधा
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" दिइएको संख्या n का लागि, n लाई निःशेष भाग जाने, n भन्दा सानो सबैभन्दा ठूलो संख्या पत्ता लगाउनुहोस्
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" ଗୋଟିଏ ପ୍ରଦତ୍ତ ସଂଖ୍ୟା n ପାଇଁ, n ଠାରୁ ଛୋଟ ଏବଂ n କୁ ସମ୍ପୂର୍ଣ୍ଣ ଭାବରେ ବିଭାଜିତ କରୁଥିବା ସବୁଠାରୁ ବଡ଼ ସଂଖ୍ୟା ଖୋଜନ୍ତୁ
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ n ਲਈ, n ਤੋਂ ਛੋਟੀ ਉਹ ਸਭ ਤੋਂ ਵੱਡੀ ਸੰਖਿਆ ਲੱਭੋ ਜੋ n ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਵੰਡਦੀ ਹੋਵੇ
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" दत्तायाः संख्यायाः n कृते, n-तः लघीयसीं तादृशीं महत्तमां संख्यां प्राप्नुत या n निःशेषं विभाजयति
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" கொடுக்கப்பட்ட எண் n-க்கு, n-ஐ மீதமின்றி வகுக்கக்கூடிய, n-ஐ விடச் சிறிய மிகப்பெரிய எண்ணைக் கண்டறியவும்
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" ఇచ్చిన సంఖ్య n కొరకు, n కంటే చిన్నదై ఉంటూ n ను నిశ్శేషంగా భాగించే అతిపెద్ద సంఖ్యను కనుగొనండి
>>> largest_divisor(15)
5
"""
|
def largest_divisor(n: int) -> int:
""" دیے گئے عدد n کے لیے، n سے چھوٹا ایسا سب سے بڑا عدد معلوم کریں جو n کو پورا پورا تقسیم کرتا ہو
>>> largest_divisor(15)
5
"""
|
HumanEval/25 | from typing import List
def factorize(n: int) -> List[int]:
""" Return list of prime factors of given integer in the order from smallest to largest.
Each of the factors should be listed number of times corresponding to how many times it appeares in factorization.
Input number should be equal to the produc... | import math
fact = []
i = 2
while i <= int(math.sqrt(n) + 1):
if n % i == 0:
fact.append(i)
n //= i
else:
i += 1
if n > 1:
fact.append(n)
return fact
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate(2) == [2]
assert candidate(4) == [2, 2]
assert candidate(8) == [2, 2, 2]
assert candidate(3 * 19) == [3, 19]
assert candidate(3 * 19 * 3 * 19) == [3, 3, 19, 19]
assert candidate(3 * 19 * 3 * 19 * ... | factorize | from typing import List
def factorize(n: int) -> List[int]:
""" প্ৰদত্ত অখণ্ড সংখ্যাৰ মৌলিক উৎপাদকসমূহৰ তালিকা সৰুৰ পৰা ডাঙৰ ক্ৰমত ঘূৰাই দিয়ক।
প্ৰতিটো উৎপাদক উৎপাদকীকৰণত যিমান বাৰ ওলায়, সিমান বাৰেই তালিকাত উল্লেখ থাকিব লাগিব।
ইনপুট সংখ্যাটো সকলো উৎপাদকৰ গুণফলৰ সমান হ'ব লাগিব
>>> factorize(8)
[2,... | from typing import List
def factorize(n: int) -> List[int]:
""" প্রদত্ত পূর্ণসংখ্যার মৌলিক উৎপাদকগুলোর তালিকা ছোট থেকে বড় ক্রমে রিটার্ন করুন।
উৎপাদকে বিশ্লেষণের সময় প্রতিটি উৎপাদক যতবার আসে, ততবার সেটিকে তালিকাভুক্ত করা উচিত।
ইনপুট সংখ্যাটি সমস্ত উৎপাদকের গুণফলের সমান হওয়া উচিত
>>> factorize(8)
[2... | from typing import List
def factorize(n: int) -> List[int]:
""" આપેલ પૂર્ણાંકના અવિભાજ્ય અવયવોની યાદી સૌથી નાનાથી સૌથી મોટાના ક્રમમાં રિટર્ન કરો.
દરેક અવયવ અવયવીકરણમાં જેટલી વખત આવે છે તેટલી વખત યાદીમાં દર્શાવવો જોઈએ.
ઇનપુટ સંખ્યા બધા અવયવોના ગુણાકાર જેટલી હોવી જોઈએ
>>> factorize(8)
[2, 2, 2]
... | from typing import List
def factorize(n: int) -> List[int]:
""" दिए गए पूर्णांक के अभाज्य गुणनखंडों की सूची सबसे छोटे से सबसे बड़े के क्रम में लौटाएं।
प्रत्येक गुणनखंड उतनी बार सूचीबद्ध होना चाहिए जितनी बार वह गुणनखंडन में आता है।
इनपुट संख्या सभी गुणनखंडों के गुणनफल के बराबर होनी चाहिए
>>> factorize(... | from typing import List
def factorize(n: int) -> List[int]:
""" ನೀಡಲಾದ ಪೂರ್ಣಾಂಕದ ಅವಿಭಾಜ್ಯ ಅಪವರ್ತನಗಳ (prime factors) ಪಟ್ಟಿಯನ್ನು ಚಿಕ್ಕದರಿಂದ ದೊಡ್ಡ ಕ್ರಮದಲ್ಲಿ ಹಿಂತಿರುಗಿಸಿ.
ಪ್ರತಿಯೊಂದು ಅಪವರ್ತನವು ಅಪವರ್ತಿಸುವಿಕೆಯಲ್ಲಿ ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆಯೋ ಅಷ್ಟು ಬಾರಿ ಪಟ್ಟಿಯಲ್ಲಿ ನಮೂದಿಸಬೇಕು.
ಇನ್ಪುಟ್ ಸಂಖ್ಯೆಯು ಎಲ್ಲಾ ಅಪವರ್ತನಗಳ ... | from typing import List
def factorize(n: int) -> List[int]:
""" നൽകിയിരിക്കുന്ന പൂർണ്ണസംഖ്യയുടെ അഭാജ്യ ഘടകങ്ങളുടെ (prime factors) ലിസ്റ്റ് ഏറ്റവും ചെറുതിൽ നിന്ന് വലുതിലേക്ക് എന്ന ക്രമത്തിൽ നൽകുക.
ഘടകീകരണത്തിൽ ഓരോ ഘടകവും എത്ര തവണ വരുന്നുവോ അത്രയും തവണ ലിസ്റ്റിൽ ഉൾപ്പെടുത്തേണ്ടതാണ്.
നൽകിയിരിക്കുന്ന സംഖ്യ എല... | from typing import List
def factorize(n: int) -> List[int]:
""" दिलेल्या पूर्णांकाच्या मूळ अवयवांची (prime factors) लहानाकडून मोठ्या क्रमात यादी परत करा.
प्रत्येक अवयव अवयवीकरणात जितक्या वेळा येतो तितक्या वेळा यादीत नोंदवला गेला पाहिजे.
इनपुट संख्या ही सर्व अवयवांच्या गुणाकाराएवढी असावी
>>> factorize(... | from typing import List
def factorize(n: int) -> List[int]:
""" दिइएको पूर्णाङ्कको अभाज्य गुणनखण्डहरूको सूची सानोदेखि ठूलोको क्रममा फर्काउनुहोस्।
प्रत्येक गुणनखण्डलाई फ्याक्टराइजेसनमा जति पटक आउँछ त्यति नै पटक सूचीकृत गरिनुपर्छ।
इनपुट सङ्ख्या सबै गुणनखण्डहरूको गुणनफल बराबर हुनुपर्छ
>>> factorize(8)
... | from typing import List
def factorize(n: int) -> List[int]:
""" ପ୍ରଦତ୍ତ ପୂର୍ଣ୍ଣସଂଖ୍ୟାର ମୌଳିକ ଗୁଣନୀୟକଗୁଡ଼ିକର ଏକ ତାଲିକା କ୍ଷୁଦ୍ରତମରୁ ବୃହତ୍ତମ କ୍ରମରେ ଫେରାନ୍ତୁ।
ପ୍ରତ୍ୟେକ ଗୁଣନୀୟକ ତାର ଗୁଣନଖଣ୍ଡୀକରଣରେ ଯେତେ ଥର ଆସିଥାଏ, ସେହି ଅନୁସାରେ ସେତିକି ଥର ତାଲିକାଭୁକ୍ତ ହେବା ଉଚିତ।
ଇନପୁଟ୍ ସଂଖ୍ୟାଟି ସମସ୍ତ ଗୁଣନୀୟକଗୁଡ଼ିକର ଗୁଣନଫଳ ସହିତ ସମାନ... | from typing import List
def factorize(n: int) -> List[int]:
""" ਦਿੱਤੇ ਗਏ ਪੂਰਨ ਅੰਕ ਦੇ ਅਭਾਜ ਗੁਣਨਖੰਡਾਂ ਦੀ ਸੂਚੀ ਸਭ ਤੋਂ ਛੋਟੇ ਤੋਂ ਸਭ ਤੋਂ ਵੱਡੇ ਦੇ ਕ੍ਰਮ ਵਿੱਚ ਵਾਪਸ ਕਰੋ।
ਹਰੇਕ ਗੁਣਨਖੰਡ ਨੂੰ ਓਨੀ ਵਾਰ ਸੂਚੀਬੱਧ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿੰਨੀ ਵਾਰ ਇਹ ਗੁਣਨਖੰਡੀਕਰਨ ਵਿੱਚ ਆਉਂਦਾ ਹੈ।
ਇਨਪੁੱਟ ਸੰਖਿਆ ਸਾਰੇ ਗੁਣਨਖੰਡਾਂ ਦੇ ਗੁਣਨਫਲ ਦੇ ਬਰਾਬਰ ਹੋਣੀ ਚਾ... | from typing import List
def factorize(n: int) -> List[int]:
""" दत्तपूर्णाङ्कस्य अभाज्यगुणनखण्डानां सूचीं लघुतमात् बृहत्तमक्रमेण प्रत्यायच्छतु।
प्रत्येकः गुणनखण्डः गुणनखण्डने यावत्कृत्वः आगच्छति तावत्कृत्वः सूच्यां भवेत्।
दत्ता सङ्ख्या सर्वेषां गुणनखण्डानां गुणनफलस्य समाना भवेत्।
>>> factorize(8)
... | from typing import List
def factorize(n: int) -> List[int]:
""" கொடுக்கப்பட்ட முழுஎண்ணின் பகா காரணிகளைச் சிறியதிலிருந்து பெரியது என்ற வரிசையில் பட்டியலாகத் திருப்பியளிக்கவும்.
ஒவ்வொரு காரணியும் காரணிப்படுத்துதலில் எத்தனை முறை வருகிறதோ அத்தனை முறை பட்டியலிடப்பட வேண்டும்.
உள்ளீட்டு எண் அனைத்துக் காரணிகளின் ... | from typing import List
def factorize(n: int) -> List[int]:
""" ఇచ్చిన పూర్ణాంకం యొక్క ప్రధాన కారణాంకాల జాబితాను చిన్న నుండి పెద్ద క్రమంలో రిటర్న్ చేయండి.
ప్రతి కారణాంకం దాని కారణాంక విభజనలో ఎన్నిసార్లు కనిపిస్తుందో అన్ని సార్లు జాబితా చేయబడాలి.
ఇన్పుట్ సంఖ్య అన్ని కారణాంకాల లబ్దానికి సమానంగా ఉండాలి
... | from typing import List
def factorize(n: int) -> List[int]:
""" دیے گئے integer کے prime factors کی فہرست چھوٹے سے بڑے کی ترتیب میں واپس کریں۔
ہر factor کو اتنی بار درج کیا جانا چاہیے جتنی بار وہ factorization میں ظاہر ہوتا ہے۔
ان پٹ نمبر تمام factors کے حاصل ضرب کے برابر ہونا چاہیے
>>> factorize(8)
... |
HumanEval/26 | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" From a list of integers, remove all elements that occur more than once.
Keep order of elements left the same as in the input.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| import collections
c = collections.Counter(numbers)
return [n for n in numbers if c[n] <= 1]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == []
assert candidate([1, 2, 3, 4]) == [1, 2, 3, 4]
assert candidate([1, 2, 3, 2, 4, 3, 5]) == [1, 4, 5]
| remove_duplicates | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" এটা অখণ্ড সংখ্যাৰ তালিকাৰ পৰা, একাধিকবাৰ অহা সকলো উপাদান আঁতৰাওক।
বাকী থকা উপাদানসমূহৰ ক্ৰম ইনপুটত থকাৰ দৰেই একে ৰাখক।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" একটি পূর্ণসংখ্যার তালিকা থেকে, একাধিকবার আসা সমস্ত উপাদান সরিয়ে ফেলুন।
অবশিষ্ট উপাদানগুলির ক্রম ইনপুটের মতো একই রাখুন।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" પૂર્ણાંકોની એક યાદીમાંથી, એક કરતાં વધુ વખત આવતા તમામ ઘટકોને દૂર કરો.
બાકી રહેલા ઘટકોનો ક્રમ ઇનપુટ મુજબ જ જાળવી રાખો.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" पूर्णांकों की एक सूची में से, उन सभी तत्वों को हटा दें जो एक से अधिक बार आते हैं।
बचे हुए तत्वों का क्रम इनपुट के समान ही बनाए रखें।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯಿಂದ, ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಕಂಡುಬರುವ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಿ.
ಉಳಿದ ಅಂಶಗಳ ಕ್ರಮವನ್ನು ಇನ್ಪುಟ್ನಲ್ಲಿರುವಂತೆಯೇ ಇರಿಸಿ.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റിൽ നിന്ന്, ഒന്നിൽ കൂടുതൽ തവണ വരുന്ന എല്ലാ എലമെന്റുകളെയും ഒഴിവാക്കുക.
ശേഷിക്കുന്ന എലമെന്റുകളുടെ ക്രമം ഇൻപുട്ടിലേതുപോലെ തന്നെ നിലനിർത്തുക.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
... | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" पूर्णांकांच्या एका सूचीमधून, एकापेक्षा जास्त वेळा येणारे सर्व घटक काढून टाका.
उरलेल्या घटकांचा क्रम इनपुटमधील क्रमासारखाच ठेवा.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" इन्टिजरहरूको सूचीबाट, एक पटकभन्दा बढी देखा पर्ने सबै तत्वहरू हटाउनुहोस्।
बाँकी रहेका तत्वहरूको क्रम इनपुटमा जस्तै राख्नुहोस्।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ତାଲିକାରୁ, ଏକରୁ ଅଧିକ ଥର ଆସୁଥିବା ସମସ୍ତ ଉପାଦାନକୁ ହଟାନ୍ତୁ।
ବାକି ରହିଥିବା ଉପାଦାନଗୁଡ଼ିକର କ୍ରମକୁ ଇନପୁଟ୍ ଭଳି ସମାନ ରଖନ୍ତୁ।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਵਿੱਚੋਂ, ਉਹ ਸਾਰੇ ਤੱਤ ਹਟਾਓ ਜੋ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਆਉਂਦੇ ਹਨ।
ਬਾਕੀ ਬਚੇ ਤੱਤਾਂ ਦਾ ਕ੍ਰਮ ਇਨਪੁਟ ਦੇ ਸਮਾਨ ਹੀ ਰੱਖੋ।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" पूर्णाङ्कानां सूच्याः तानि सर्वाणि तत्त्वानि निष्कासयत यानि एकाधिकवारं वर्तन्ते।
अवशिष्टानां तत्त्वानां क्रमम् आदानवत् एव स्थापयत।
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" முழு எண்களின் பட்டியலிலிருந்து, ஒன்றுக்கு மேற்பட்ட முறை தோன்றும் அனைத்து உறுப்புகளையும் நீக்கவும்.
மீதமுள்ள உறுப்புகளின் வரிசையை உள்ளீட்டில் உள்ளவாறே வைத்திருக்கவும்.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
... | from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" పూర్ణాంకాల జాబితా నుండి, ఒకటి కంటే ఎక్కువ సార్లు కనిపించే అన్ని మూలకాలను తొలగించండి.
మిగిలిన మూలకాల క్రమాన్ని ఇన్పుట్లో ఉన్నట్లుగానే ఉంచండి.
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
| from typing import List
def remove_duplicates(numbers: List[int]) -> List[int]:
""" انٹیجرز کی فہرست میں سے، وہ تمام عناصر ہٹا دیں جو ایک سے زیادہ بار آتے ہیں۔
باقی رہ جانے والے عناصر کی ترتیب وہی رکھیں جو ان پٹ میں ہے۔
>>> remove_duplicates([1, 2, 3, 2, 4])
[1, 3, 4]
"""
|
HumanEval/27 |
def flip_case(string: str) -> str:
""" For a given string, flip lowercase characters to uppercase and uppercase to lowercase.
>>> flip_case('Hello')
'hELLO'
"""
| return string.swapcase()
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate('') == ''
assert candidate('Hello!') == 'hELLO!'
assert candidate('These violent delights have violent ends') == 'tHESE VIOLENT DELIGHTS HAVE VIOLENT ENDS'
| flip_case |
def flip_case(string: str) -> str:
""" এটা দিয়া ষ্ট্ৰিঙৰ বাবে, lowercase বৰ্ণসমূহক uppercase লৈ আৰু uppercase বৰ্ণসমূহক lowercase লৈ সলনি কৰক।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" একটি প্রদত্ত string-এর ক্ষেত্রে, lowercase অক্ষরগুলোকে uppercase-এ এবং uppercase অক্ষরগুলোকে lowercase-এ পরিবর্তন করুন।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" આપેલી string માટે, lowercase અક્ષરોને uppercase માં અને uppercase અક્ષરોને lowercase માં ફેરવો.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" दिए गए string के लिए, lowercase वर्णों को uppercase में और uppercase वर्णों को lowercase में बदलें।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" ಕೊಟ್ಟಿರುವ string ಗಾಗಿ, lowercase ಅಕ್ಷರಗಳನ್ನು uppercase ಗೆ ಮತ್ತು uppercase ಅಕ್ಷರಗಳನ್ನು lowercase ಗೆ ಬದಲಾಯಿಸಿ.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" നൽകിയിരിക്കുന്ന ഒരു സ്ട്രിംഗിലെ lowercase അക്ഷരങ്ങളെ uppercase ആയും uppercase അക്ഷരങ്ങളെ lowercase ആയും മാറ്റുക.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" दिलेल्या string साठी, lowercase अक्षरे uppercase मध्ये आणि uppercase अक्षरे lowercase मध्ये बदला.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" दिइएको string का लागि, lowercase क्यारेक्टरहरूलाई uppercase मा र uppercase क्यारेक्टरहरूलाई lowercase मा उल्टाउनुहोस्।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" ଗୋଟିଏ ପ୍ରଦତ୍ତ string ପାଇଁ, lowercase ଅକ୍ଷରଗୁଡ଼ିକୁ uppercase ଏବଂ uppercase ଅକ୍ଷରଗୁଡ଼ିକୁ lowercase ରେ ପରିବର୍ତ୍ତନ କରନ୍ତୁ।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" ਦਿੱਤੀ ਗਈ string ਲਈ, lowercase ਅੱਖਰਾਂ ਨੂੰ uppercase ਵਿੱਚ ਅਤੇ uppercase ਅੱਖਰਾਂ ਨੂੰ lowercase ਵਿੱਚ ਬਦਲੋ।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" दत्तस्य string इत्यस्य कृते, लघ्वक्षराणि बृहदक्षररूपेण तथा बृहदक्षराणि लघ्वक्षररूपेण परिवर्तयतु।
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" கொடுக்கப்பட்ட ஒரு சரத்தில், சிறிய எழுத்துக்களை பெரிய எழுத்துக்களாகவும், பெரிய எழுத்துக்களை சிறிய எழுத்துக்களாகவும் மாற்றவும்.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" ఇచ్చిన string కోసం, lowercase అక్షరాలను uppercase గా మరియు uppercase అక్షరాలను lowercase గా మార్చండి.
>>> flip_case('Hello')
'hELLO'
"""
|
def flip_case(string: str) -> str:
""" دی گئی string کے لیے، lowercase حروف کو uppercase میں اور uppercase حروف کو lowercase میں تبدیل کریں۔
>>> flip_case('Hello')
'hELLO'
"""
|
HumanEval/28 | from typing import List
def concatenate(strings: List[str]) -> str:
""" Concatenate list of strings into a single string
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| return ''.join(strings)
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([]) == ''
assert candidate(['x', 'y', 'z']) == 'xyz'
assert candidate(['x', 'y', 'z', 'w', 'k']) == 'xyzwk'
| concatenate | from typing import List
def concatenate(strings: List[str]) -> str:
""" ষ্ট্ৰিংৰ এখন তালিকাক এটা একক ষ্ট্ৰিংলৈ সংযোগ কৰক
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" স্ট্রিংয়ের তালিকাকে একটি একক স্ট্রিংয়ে যুক্ত করুন
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" સ્ટ્રિંગ્સની લિસ્ટને એક જ સ્ટ્રિંગમાં જોડો
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" स्ट्रिंग्स की सूची को एक एकल स्ट्रिंग में जोड़ें
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" ಸ್ಟ್ರಿಂಗ್ಗಳ ಪಟ್ಟಿಯನ್ನು ಒಂದೇ ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಸಂಯೋಜಿಸಿ
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" സ്ട്രിംഗുകളുടെ ലിസ്റ്റിനെ ഒരൊറ്റ സ്ട്രിംഗായി സംയോജിപ്പിക്കുക
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" स्ट्रिंग्सच्या सूचीला एकाच स्ट्रिंगमध्ये एकत्र जोडा
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" स्ट्रिङहरूको सूचीलाई एउटा एकल स्ट्रिङमा जोड्नुहोस्
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" ଷ୍ଟ୍ରିଙ୍ଗଗୁଡ଼ିକର ଏକ list କୁ ଗୋଟିଏ ଏକକ ଷ୍ଟ୍ରିଙ୍ଗରେ concatenate କରନ୍ତୁ
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਟ੍ਰਿੰਗ ਵਿੱਚ ਜੋੜੋ
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" सूत्राणां सूचीम् एकस्मिन् सूत्रे संयोजयतु
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" சரங்களின் பட்டியலை ஒரே சரமாக இணைக்கவும்
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" స్ట్రింగ్ల లిస్ట్ను ఒకే స్ట్రింగ్గా కలపండి
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
| from typing import List
def concatenate(strings: List[str]) -> str:
""" strings کی فہرست کو جوڑ کر ایک واحد string بنائیں
>>> concatenate([])
''
>>> concatenate(['a', 'b', 'c'])
'abc'
"""
|
HumanEval/29 | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" Filter an input list of strings only for ones that start with a given prefix.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""
| return [x for x in strings if x.startswith(prefix)]
|
METADATA = {
'author': 'jt',
'dataset': 'test'
}
def check(candidate):
assert candidate([], 'john') == []
assert candidate(['xxx', 'asd', 'xxy', 'john doe', 'xxxAAA', 'xxx'], 'xxx') == ['xxx', 'xxxAAA', 'xxx']
| filter_by_prefix | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" এটা প্ৰদত্ত prefix-ৰে আৰম্ভ হোৱা string-সমূহৰ বাবে কেৱল ইনপুট string-ৰ তালিকাখন ফিল্টাৰ কৰক।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" একটি ইনপুট স্ট্রিংয়ের তালিকা থেকে শুধুমাত্র প্রদত্ত prefix দিয়ে শুরু হওয়া স্ট্রিংগুলোকে ফিল্টার করুন।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', '... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" સ્ટ્રિંગ્સની ઇનપુટ લિસ્ટમાંથી ફક્ત આપેલા prefix થી શરૂ થતી સ્ટ્રિંગ્સને ફિલ્ટર કરો.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
"""
| from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" स्ट्रिंग्स की एक इनपुट सूची को केवल उन स्ट्रिंग्स के लिए फ़िल्टर करें जो दिए गए prefix से शुरू होती हैं।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc'... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" ನೀಡಿರುವ ಪ್ರಿಫಿಕ್ಸ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುವ ಸ್ಟ್ರಿಂಗ್ ಗಳಿಗಾಗಿ ಮಾತ್ರ ಇನ್ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಗಳ ಪಟ್ಟಿಯನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಿ.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" നൽകിയിരിക്കുന്ന ഒരു prefix ഉപയോഗിച്ച് ആരംഭിക്കുന്ന സ്ട്രിംഗുകൾ മാത്രമായി നൽകിയിട്ടുള്ള സ്ട്രിംഗുകളുടെ ലിസ്റ്റിനെ ഫിൽട്ടർ ചെയ്യുക.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', ... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" दिलेल्या prefix ने सुरू होणाऱ्या strings साठीच इनपुट स्ट्रिंग्सची सूची फिल्टर करा.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
""" | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" दिइएको prefix बाट सुरु हुने स्ट्रिङहरू मात्र समावेश गर्नका लागि इनपुट स्ट्रिङहरूको सूचीलाई फिल्टर गर्नुहोस्।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" ଏକ ପ୍ରଦତ୍ତ prefix ସହିତ ଆରମ୍ଭ ହେଉଥିବା string ଗୁଡ଼ିକ ପାଇଁ କେବଳ strings ର ଏକ ଇନପୁଟ୍ ତାଲିକାକୁ ଫିଲ୍ଟର କରନ୍ତୁ।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc'... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਇੱਕ ਇਨਪੁਟ ਲਿਸਟ ਨੂੰ ਸਿਰਫ਼ ਉਹਨਾਂ ਲਈ ਫਿਲਟਰ ਕਰੋ ਜੋ ਦਿੱਤੇ ਗਏ prefix ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'arra... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" प्रदत्तां स्ट्रिंग्-सूचिं केवलं तादृशानां कृते शोधयन्तु यानि दत्तेन prefix इत्यनेन आरभन्ते।
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" கொடுக்கப்பட்ட prefix உடன் தொடங்கும் சரங்களை மட்டும் உள்ளீட்டு சரங்களின் பட்டியலிலிருந்து வடிகட்டவும்.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', '... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" ఇచ్చిన prefix తో ప్రారంభమయ్యే వాటిని మాత్రమే ఉంచడానికి ఇన్పుట్ స్ట్రింగ్ల లిస్ట్ను ఫిల్టర్ చేయండి.
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', '... | from typing import List
def filter_by_prefix(strings: List[str], prefix: str) -> List[str]:
""" سٹرنگز کی ایک ان پٹ لسٹ کو صرف ان سٹرنگز کے لیے فلٹر کریں جو دیے گئے prefix سے شروع ہوتی ہیں۔
>>> filter_by_prefix([], 'a')
[]
>>> filter_by_prefix(['abc', 'bcd', 'cde', 'array'], 'a')
['abc', 'array']
... |
HumanEval/30 |
def get_positive(l: list):
"""Return only positive numbers in the list.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
| return [e for e in l if e > 0]
|
METADATA = {}
def check(candidate):
assert candidate([-1, -2, 4, 5, 6]) == [4, 5, 6]
assert candidate([5, 3, -5, 2, 3, 3, 9, 0, 123, 1, -10]) == [5, 3, 2, 3, 3, 9, 123, 1]
assert candidate([-1, -2]) == []
assert candidate([]) == []
| get_positive |
def get_positive(l: list):
"""তালিকাখনৰ কেৱল ধনাত্মক সংখ্যাবোৰ ওভতাই দিয়ক।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""তালিকায় থাকা কেবল ধনাত্মক সংখ্যাগুলো রিটার্ন করুন।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""લિસ્ટમાં રહેલી ફક્ત ધન સંખ્યાઓ પરત કરો.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""सूची में से केवल धनात्मक संख्याएँ लौटाएं।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""ಪಟ್ಟಿಯಲ್ಲಿರುವ ಧನಾತ್ಮಕ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಹಿಂದಿರುಗಿಸಿ.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""ലിസ്റ്റിലെ പോസിറ്റീവ് സംഖ്യകൾ മാത്രം തിരികെ നൽകുക.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""list मधील फक्त धन संख्या परत करा.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""सूचीमा रहेका धनात्मक संख्याहरू मात्र फिर्ता गर्नुहोस्।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""ତାଲିକାରେ ଥିବା କେବଳ ଧନାତ୍ମକ ସଂଖ୍ୟାଗୁଡ଼ିକୁ ଫେରାନ୍ତୁ।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""ਸੂਚੀ ਵਿੱਚੋਂ ਸਿਰਫ਼ ਧਨਾਤਮਕ ਸੰਖਿਆਵਾਂ ਵਾਪਸ ਕਰੋ।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""सूचौ केवलं धनात्मकसंख्याः प्रत्यानयतु।
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""பட்டியலில் உள்ள நேர்மறை எண்களை மட்டும் திருப்பியளிக்கவும்.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""జాబితాలోని ధనాత్మక సంఖ్యలను మాత్రమే రిటర్న్ చేయండి.
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
def get_positive(l: list):
"""لسٹ میں موجود صرف مثبت اعداد واپس کریں۔
>>> get_positive([-1, 2, -4, 5, 6])
[2, 5, 6]
>>> get_positive([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
[5, 3, 2, 3, 9, 123, 1]
"""
|
HumanEval/31 |
def is_prime(n):
"""Return true if a given number is prime, and false otherwise.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
| if n < 2:
return False
for k in range(2, n - 1):
if n % k == 0:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate(6) == False
assert candidate(101) == True
assert candidate(11) == True
assert candidate(13441) == True
assert candidate(61) == True
assert candidate(4) == False
assert candidate(1) == False
assert candidate(5) == True
assert ca... | is_prime |
def is_prime(n):
"""যদি এটা প্ৰদত্ত সংখ্যা মৌলিক হয় তেন্তে true, আৰু অন্যথা false ৰিটাৰ্ণ কৰক।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
... |
def is_prime(n):
"""প্রদত্ত সংখ্যাটি মৌলিক হলে true, এবং অন্যথায় false রিটার্ন করুন।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
def is_prime(n):
"""જો આપેલી સંખ્યા અવિભાજ્ય હોય તો true, અને અન્યથા false પરત કરો.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
def is_prime(n):
"""यदि दी गई संख्या अभाज्य (prime) है तो true लौटाएं, और अन्यथा false लौटाएं।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"... |
def is_prime(n):
"""ನೀಡಿರುವ ಸಂಖ್ಯೆಯು ಅವಿಭಾಜ್ಯವಾಗಿದ್ದರೆ true, ಇಲ್ಲದಿದ್ದರೆ false ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
... |
def is_prime(n):
"""നൽകിയിരിക്കുന്ന സംഖ്യ prime ആണെങ്കിൽ true എന്നും, അല്ലാത്തപക്ഷം false എന്നും നൽകുക.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
Fa... |
def is_prime(n):
"""दिलेली संख्या मूळ संख्या (prime) असल्यास true, आणि अन्यथा false परत करा.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""... |
def is_prime(n):
"""यदि दिइएको संख्या prime हो भने True, र अन्यथा False फर्काउनुहोस्।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
def is_prime(n):
"""ଯଦି ଏକ ପ୍ରଦତ୍ତ ସଂଖ୍ୟା ମୌଳିକ ହୋଇଥାଏ ତେବେ true, ଏବଂ ଅନ୍ୟଥା false ଫେରାନ୍ତୁ।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""... |
def is_prime(n):
"""ਜੇਕਰ ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ ਅਭਾਜ (prime) ਹੈ ਤਾਂ true ਵਾਪਸ ਕਰੋ, ਅਤੇ ਨਹੀਂ ਤਾਂ false।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"... |
def is_prime(n):
"""यदि प्रदत्ता सङ्ख्या अभाज्या (prime) अस्ति तर्हि true, अन्यथा false प्रत्यर्पयतु।
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
Fals... |
def is_prime(n):
"""கொடுக்கப்பட்ட எண் பகா எண் (prime) எனில் true என்பதையும், இல்லையெனில் false என்பதையும் திருப்பியளிக்கவும்.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
... |
def is_prime(n):
"""ఇచ్చిన సంఖ్య ప్రధాన సంఖ్య అయితే true, లేకపోతే false రిటర్న్ చేయండి.
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
def is_prime(n):
"""اگر دیا گیا عدد prime ہو تو true واپس کریں، بصورت دیگر false۔
>>> is_prime(6)
False
>>> is_prime(101)
True
>>> is_prime(11)
True
>>> is_prime(13441)
True
>>> is_prime(61)
True
>>> is_prime(4)
False
>>> is_prime(1)
False
"""
|
HumanEval/32 | import math
def poly(xs: list, x: float):
"""
Evaluates polynomial with coefficients xs at point x.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs are coefficients of a polynomia... | begin, end = -1., 1.
while poly(xs, begin) * poly(xs, end) > 0:
begin *= 2.0
end *= 2.0
while end - begin > 1e-10:
center = (begin + end) / 2.0
if poly(xs, center) * poly(xs, begin) > 0:
begin = center
else:
end = center
return begin
|
METADATA = {}
def check(candidate):
import math
import random
rng = random.Random(42)
import copy
for _ in range(100):
ncoeff = 2 * rng.randint(1, 4)
coeffs = []
for _ in range(ncoeff):
coeff = rng.randint(-10, 10)
if coeff == 0:
co... | find_zero | import math
def poly(xs: list, x: float):
"""
x বিন্দুত xs সহগবিশিষ্ট বহুপদ ৰাশিৰ মান নিৰ্ণয় কৰে।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs হৈছে এটা বহুপদ ৰাশিৰ সহগসমূহ।
... | import math
def poly(xs: list, x: float):
"""
x বিন্দুতে xs সহগবিশিষ্ট বহুপদী মূল্যায়ন করে।
xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n রিটার্ন করে
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs হলো একটি বহুপদীর সহগসমূহ।
fin... | import math
def poly(xs: list, x: float):
"""
બિંદુ x પર સહગુણકો xs ધરાવતી બહુપદીનું મૂલ્યાંકન કરે છે.
xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n પરત કરે છે
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs એ બહુપદીના સહગુણકો છે.
... | import math
def poly(xs: list, x: float):
"""
बिंदु x पर गुणांक xs वाले बहुपद (polynomial) का मान निकालता है।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs एक बहुपद के गुणांक है... | import math
def poly(xs: list, x: float):
"""
x ಬಿಂದುವಿನಲ್ಲಿ xs ಗುಣಕಗಳನ್ನು ಹೊಂದಿರುವ ಬಹುಪದೋಕ್ತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs ಒಂದು ಬಹುಪದ... | import math
def poly(xs: list, x: float):
"""
x എന്ന ബിന്ദുവിൽ xs കോഫിഫിഷ്യന്റുകളായുള്ള പോളിനോമിയലിന്റെ മൂല്യം കണക്കാക്കുന്നു.
xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n റിട്ടേൺ ചെയ്യുന്നു
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
... | import math
def poly(xs: list, x: float):
"""
xs हे सहगुणक असलेल्या बहुपदीचे x या बिंदूवर मूल्य काढते.
xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n परत करते
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs हे एका बहुपदीचे सहगुणक आहे... | import math
def poly(xs: list, x: float):
"""
बिन्दु x मा गुणाङ्कहरू xs भएको बहुपद (polynomial) को मूल्याङ्कन गर्दछ।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs एउटा बहुपदका ग... | import math
def poly(xs: list, x: float):
"""
x ବିନ୍ଦୁରେ xs ସହଗ (coefficients) ଥିବା polynomial ର ମୂଲ୍ୟାଙ୍କନ କରେ।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs ହେଉଛି ଏକ polynomia... | import math
def poly(xs: list, x: float):
"""
ਬਿੰਦੂ x 'ਤੇ ਗੁਣਾਂਕਾਂ xs ਵਾਲੇ ਬਹੁਪਦ (polynomial) ਦਾ ਮੁੱਲ ਕੱਢਦਾ ਹੈ।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs ਇੱਕ ਬਹੁਪਦ (polynomi... | import math
def poly(xs: list, x: float):
"""
xs गुणाङ्कैः युक्तस्य बहुपदीयस्य मूल्यं x बिन्दौ गणयति।
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs बहुपदीयस्य गुणाङ्काः सन्ति।
... | import math
def poly(xs: list, x: float):
"""
புள்ளி x இல் xs கெழுக்களைக் கொண்ட பல்லுறுப்புக் கோவையை மதிப்பிடுகிறது.
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs என்பவை ஒரு பல்... | import math
def poly(xs: list, x: float):
"""
x బిందువు వద్ద xs గుణకాలతో బహుపది విలువను లెక్కిస్తుంది.
xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n ని రిటర్న్ చేస్తుంది
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs అనేవి ఒక బహుపద... | import math
def poly(xs: list, x: float):
"""
پوائنٹ x پر عددی سروں xs والے کثیر رقمی کی قدر معلوم کرتا ہے۔
return xs[0] + xs[1] * x + xs[1] * x^2 + .... xs[n] * x^n
"""
return sum([coeff * math.pow(x, i) for i, coeff in enumerate(xs)])
def find_zero(xs: list):
""" xs ایک کثیر رقمی کے عددی ... |
HumanEval/33 |
def sort_third(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the indicies that are not divisible by three, while its values at the indicies that are divisible by three are equal
to the values of the corresponding indicies of l, but sorted.
>>> sort_t... | l = list(l)
l[::3] = sorted(l[::3])
return l
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple(sort_third([1, 2, 3]))
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple(sort_third([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10]))
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple(so... | sort_third |
def sort_third(l: list):
"""এই ফলনটোৱে এটা তালিকা l গ্ৰহণ কৰে আৰু এনে এটা তালিকা l' ঘূৰাই দিয়ে যাতে
তিনিৰে বিভাজ্য নোহোৱা সূচকসমূহত l' তালিকাখন l-ৰ সৈতে একে হয়, আনহাতে তিনিৰে বিভাজ্য সূচকসমূহত ইয়াৰ মানসমূহ
l-ৰ অনুৰূপ সূচকসমূহৰ মানৰ সৈতে সমান কিন্তু ক্ৰমিত (sorted) হয়।
>>> sort_third([1, 2, 3])
[1,... |
def sort_third(l: list):
"""এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং এমন একটি তালিকা l' প্রদান করে যেন
l'-এর যে সূচকগুলি তিন দ্বারা বিভাজ্য নয় সেগুলিতে এটি l-এর অনুরূপ থাকে, আর যে সূচকগুলি তিন দ্বারা বিভাজ্য সেগুলির মানসমূহ
l-এর সংশ্লিষ্ট সূচকগুলির মানের সমান কিন্তু সাজানো (sorted) থাকে।
>>> sort_third... |
def sort_third(l: list):
"""આ વિધેય એક સૂચિ l લે છે અને એવી સૂચિ l' પરત કરે છે જેથી
l' એ ત્રણ વડે વિભાજ્ય ન હોય તેવી અનુક્રમણિકાઓ પર l ને સમાન હોય, જ્યારે ત્રણ વડે વિભાજ્ય હોય તેવી અનુક્રમણિકાઓ પરના તેના મૂલ્યો
l ના અનુરૂપ અનુક્રમણિકાઓના મૂલ્યો સમાન હોય, પરંતુ ચઢતા ક્રમમાં ગોઠવેલા હોય.
>>> sort_th... |
def sort_third(l: list):
"""यह फ़ंक्शन एक list l लेता है और एक list l' लौटाता है ताकि
l' उन indicies पर l के समान हो जो तीन से विभाज्य नहीं हैं, जबकि उन indicies पर इसके मान जो तीन से विभाज्य हैं, l के संगत indicies के मानों के बराबर लेकिन sorted हों।
>>> sort_third([1, 2, 3])
[1, 2, 3]
>>> sort_t... |
def sort_third(l: list):
"""ಈ ಫಂಕ್ಷನ್ ಒಂದು ಲಿಸ್ಟ್ l ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು l' ಎಂಬ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಂದರೆ
ಮೂರರಿಂದ ಭಾಗವಾಗದ ಇಂಡೆಕ್ಸ್ಗಳಲ್ಲಿ l' ಲಿಸ್ಟ್ l ನಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಮೂರರಿಂದ ಭಾಗವಾಗುವ ಇಂಡೆಕ್ಸ್ಗಳಲ್ಲಿನ ಅದರ ಮೌಲ್ಯಗಳು
l ನ ಅನುಗುಣವಾದ ಇಂಡೆಕ್ಸ್ಗಳ ಮೌಲ್ಯಗಳಿಗೆ ಸಮಾನವಾಗಿದ್ದು, ಆದರೆ ವಿಂಗಡಿಸಲಾಗಿ... |
def sort_third(l: list):
"""ഈ ഫംഗ്ഷൻ ഒരു ലിസ്റ്റ് l സ്വീകരിക്കുകയും l' എന്നൊരു ലിസ്റ്റ് നൽകുകയും ചെയ്യുന്നു, ഇതിൽ
മൂന്ന് കൊണ്ട് ഹരിക്കാനാവാത്ത ഇൻഡക്സുകളിൽ l' എന്നത് l-ന് സമാനമായിരിക്കും, എന്നാൽ മൂന്ന് കൊണ്ട് ഹരിക്കാവുന്ന ഇൻഡക്സുകളിലെ ഇതിന്റെ മൂല്യങ്ങൾ
l-ന്റെ അനുബന്ധ ഇൻഡക്സുകളിലെ മൂല്യങ്ങൾക്ക് തുല്യവും എന്... |
def sort_third(l: list):
"""हे फंक्शन एक list l घेते आणि अशी एक list l' परत करते ज्यामध्ये
l' हे तीनने भाग न जाणाऱ्या indices वर l सारखेच असते, तर तीनने भाग जाणाऱ्या indices वरील त्याची व्हॅल्यूज ही
l च्या संबंधित indices वरील व्हॅल्यूजसारखीच असतात, परंतु सॉर्ट केलेली (sorted) असतात.
>>> sort_third([1... |
def sort_third(l: list):
"""यो प्रकार्यले एउटासूची l लिन्छ र यस्तो सूची l' फर्काउँछ जहाँ
तीनले भाग नजाने indicies हरूमा l' सूची l सँग समान हुन्छ, जबकि तीनले भाग जाने indicies हरूमा रहेका यसका मानहरू
l का सम्बन्धित indicies का मानहरूसँग समान तर क्रमबद्ध (sorted) हुन्छन्।
>>> sort_third([1, 2, 3])
[... |
def sort_third(l: list):
"""ଏହି ଫଙ୍କସନ୍ ଏକ list l ନିଏ ଏବଂ ଏପରି ଏକ list l' ଫେରସ୍ତ କରେ ଯେପରିକି
l' ସେହି ଇଣ୍ଡେକ୍ସଗୁଡ଼ିକରେ l ସହିତ ସମାନ ରହେ ଯାହା ତିନି ଦ୍ୱାରା ବିଭାଜ୍ୟ ନୁହେଁ, ଯେତେବେଳେ ତିନି ଦ୍ୱାରା ବିଭାଜ୍ୟ ଥିବା ଇଣ୍ଡେକ୍ସଗୁଡ଼ିକରେ ଏହାର ମୂଲ୍ୟଗୁଡ଼ିକ
l ର ଅନୁରୂପ ଇଣ୍ଡେକ୍ସଗୁଡ଼ିକର ମୂଲ୍ୟ ସହିତ ସମାନ, କିନ୍ତୁ sorted ହୋଇଥାଏ।
>>... |
def sort_third(l: list):
"""ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ list l ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ list l' ਵਾਪਸ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ
l' ਉਹਨਾਂ indices ਉੱਤੇ l ਦੇ ਬਿਲਕੁਲ ਸਮਾਨ ਹੋਵੇ ਜੋ ਤਿੰਨ ਨਾਲ ਵੰਡਣਯੋਗ ਨਹੀਂ ਹਨ, ਜਦੋਂ ਕਿ ਤਿੰਨ ਨਾਲ ਵੰਡਣਯੋਗ indices ਉੱਤੇ ਇਸਦੇ ਮੁੱਲ l ਦੇ ਸੰਬੰਧਿਤ indices ਦੇ ਮੁੱਲਾਂ ਦੇ ਬਰਾਬਰ ਹੋਣ, ਪਰ sorted ਹੋਣ।
>>> sort_third([1, 2, 3])
[... |
def sort_third(l: list):
"""इदं फलनं सूचीं l स्वीकरोति तथा च एतादृशीं सूचीं l' प्रत्यापयति यत्र
ये सूचकाङ्काः त्रिभिः विभाज्याः न सन्ति, तेषु l' सूची l इत्यनेन समाना भवति, यदा तु ये सूचकाङ्काः त्रिभिः विभाज्याः सन्ति,
तेषु तस्याः मूल्यानि l इत्यस्य तत्सम्बद्धसूचकाङ्कानां मूल्यानां समानानि भवन्ति, किन्तु क... | def sort_third(l: list):
"""இந்தச் சார்பு l என்ற ஒரு பட்டியலை எடுத்துக்கொண்டு l' என்ற பட்டியலைத் திருப்பித் தருகிறது, இதில்
மூன்றால் வகுபடாத குறியீடுகளில் l' ஆனது l என்பதைப் போன்றே இருக்கும், அதே சமயம் மூன்றால் வகுபடக்கூடிய குறியீடுகளில் உள்ள அதன் மதிப்புகள்
l என்பதன் தொடர்புடைய குறியீடுகளின் மதிப்புகளுக்கு... |
def sort_third(l: list):
"""ఈ ఫంక్షన్ ఒక లిస్ట్ l ను తీసుకుంటుంది మరియు l' అనే లిస్ట్ను అందిస్తుంది, తద్వారా
మూడుతో నిశ్శేషంగా భాగించబడని ఇండెక్స్లలో l' అనేది l తో సమానంగా ఉంటుంది, కాగా మూడుతో నిశ్శేషంగా భాగించబడే ఇండెక్స్లలోని దాని విలువలు l యొక్క సంబంధిత ఇండెక్స్ల విలువలకు సమానంగా ఉంటూ, క్రమబద్ధీకరించబడ... |
def sort_third(l: list):
"""یہ فنکشن ایک لسٹ l لیتا ہے اور ایک ایسی لسٹ l' واپس کرتا ہے کہ
l' ان انڈیکسز پر l کے بالکل مماثل ہوتی ہے جو تین پر تقسیم نہیں ہوتے، جبکہ تین پر تقسیم ہونے والے انڈیکسز پر اس کی اقدار
l کے متعلقہ انڈیکسز کی اقدار کے برابر ہوتی ہیں، لیکن ترتیب شدہ (sorted) ہوتی ہیں۔
>>> sort_... |
HumanEval/34 |
def unique(l: list):
"""Return sorted unique elements in a list
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
| return sorted(list(set(l)))
|
METADATA = {}
def check(candidate):
assert candidate([5, 3, 5, 2, 3, 3, 9, 0, 123]) == [0, 2, 3, 5, 9, 123]
| unique |
def unique(l: list):
"""এখন তালিকাত থকা ক্ৰমবদ্ধ অনন্য উপাদানসমূহ ঘূৰাই দিয়ক
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""একটি তালিকার সাজানো অনন্য উপাদানগুলি রিটার্ন করুন
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""લિસ્ટમાં રહેલા સૉર્ટ કરેલા અનન્ય ઘટકો પરત કરો
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""एक list में क्रमबद्ध अद्वितीय तत्वों को लौटाएं
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ಒಂದು ಪಟ್ಟಿಯಲ್ಲಿರುವ ವಿಂಗಡಿಸಲಾದ ವಿಶಿಷ್ಟ ಅಂಶಗಳನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ഒരു ലിസ്റ്റിലെ സോർട്ട് ചെയ്ത യുണീക് എലമെന്റുകൾ റിട്ടേൺ ചെയ്യുക
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""एका list मधील सॉर्ट केलेले युनिक घटक परत करा
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""एउटा list मा रहेका अद्वितीय (unique) तत्वहरूलाई क्रमबद्ध (sorted) रूपमा फिर्ता गर्नुहोस्
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ଏକ list ରେ ଥିବା sorted unique ଉପାଦାନଗୁଡ଼ିକୁ ଫେରାନ୍ତୁ
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਕ੍ਰਮਬੱਧ (sorted) ਵਿਲੱਖਣ ਐਲੀਮੈਂਟਸ ਵਾਪਸ ਕਰੋ
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""सूचौ क्रमितानि अनन्यतत्त्वानि प्रत्यर्पयतु
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ஒரு list-ல் உள்ள தனித்துவமான உறுப்புகளை வரிசைப்படுத்தி திருப்பியளிக்கவும்
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ఒక లిస్ట్లోని సార్ట్ చేయబడిన యూనిక్ (unique) ఎలిమెంట్లను రిటర్న్ చేయండి
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
def unique(l: list):
"""ایک list میں ترتیب شدہ منفرد عناصر واپس کریں۔
>>> unique([5, 3, 5, 2, 3, 3, 9, 0, 123])
[0, 2, 3, 5, 9, 123]
"""
|
HumanEval/35 |
def max_element(l: list):
"""Return maximum element in the list.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
| m = l[0]
for e in l:
if e > m:
m = e
return m
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 3]) == 3
assert candidate([5, 3, -5, 2, -3, 3, 9, 0, 124, 1, -10]) == 124
| max_element |
def max_element(l: list):
"""তালিকাখনৰ সৰ্বোচ্চ উপাদানটো ঘূৰাই দিয়ক।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""লিস্টের সর্বোচ্চ উপাদানটি রিটার্ন করুন।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""લિસ્ટમાં રહેલો મહત્તમ એલિમેન્ટ પરત કરો.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""list में अधिकतम तत्व लौटाएं।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""ಪಟ್ಟಿಯಲ್ಲಿರುವ ಗರಿಷ್ಠ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""ലിസ്റ്റിലെ ഏറ്റവും വലിയ എലമെന്റ് നൽകുക.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""list मधील कमाल घटक परत करा.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""list मा रहेको अधिकतम तत्व फिर्ता गर्नुहोस्।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""ତାଲିକାରେ ଥିବା ସର୍ବାଧିକ ଉପାଦାନ ଫେରାନ୍ତୁ।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""ਲਿਸਟ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡਾ ਐਲੀਮੈਂਟ ਵਾਪਸ ਕਰੋ।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""सूच्यां महत्तमम् अवयवं प्रत्यानयतु।
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""பட்டியலில் உள்ள அதிகபட்ச உறுப்பைத் திருப்பியளிக்கவும்.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""లిస్ట్లోని గరిష్ట మూలకాన్ని రిటర్న్ చేయండి.
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
def max_element(l: list):
"""فہرست میں موجود سب سے بڑا عنصر واپس کریں۔
>>> max_element([1, 2, 3])
3
>>> max_element([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])
123
"""
|
HumanEval/36 |
def fizz_buzz(n: int):
"""Return the number of times the digit 7 appears in integers less than n which are divisible by 11 or 13.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
| ns = []
for i in range(n):
if i % 11 == 0 or i % 13 == 0:
ns.append(i)
s = ''.join(list(map(str, ns)))
ans = 0
for c in s:
ans += (c == '7')
return ans
|
METADATA = {}
def check(candidate):
assert candidate(50) == 0
assert candidate(78) == 2
assert candidate(79) == 3
assert candidate(100) == 3
assert candidate(200) == 6
assert candidate(4000) == 192
assert candidate(10000) == 639
assert candidate(100000) == 8026
| fizz_buzz |
def fizz_buzz(n: int):
"""n-তকৈ সৰু আৰু 11 বা 13-ৰে বিভাজ্য হোৱা অখণ্ড সংখ্যাবোৰত 7 অংকটো কিমানবাৰ দেখা যায় সেই সংখ্যাটো ঘূৰাই দিয়ক।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n-এর চেয়ে কম এবং 11 বা 13 দ্বারা বিভাজ্য এমন পূর্ণসংখ্যাগুলোতে 7 অঙ্কটি যতবার উপস্থিত থাকে তা রিটার্ন করুন।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""11 અથવા 13 વડે વિભાજ્ય હોય તેવા n કરતાં નાના પૂર્ણાંકોમાં અંક 7 કેટલી વાર આવે છે તે સંખ્યા પરત કરો.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n से कम उन पूर्णांकों में अंक 7 जितनी बार आता है, वह संख्या लौटाएं जो 11 या 13 से विभाज्य हैं।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""11 ಅಥವಾ 13 ರಿಂದ ಭಾಗಿಸಬಹುದಾದ, n ಗಿಂತ ಕಡಿಮೆಯಿರುವ ಪೂರ್ಣಾಂಕಗಳಲ್ಲಿ ಅಂಕಿ 7 ಎಷ್ಟು ಬಾರಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n-നേക്കാൾ ചെറിയതും 11 അല്ലെങ്കിൽ 13 കൊണ്ട് ഹരിക്കാവുന്നതുമായ പൂർണ്ണസംഖ്യകളിൽ 7 എന്ന അക്കം എത്ര തവണ വരുന്നുണ്ടെന്ന് റിട്ടേൺ ചെയ്യുക.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n पेक्षा लहान असलेल्या आणि 11 किंवा 13 ने विभाज्य असणाऱ्या पूर्णांकांमध्ये 7 हा अंक किती वेळा येतो ती संख्या परत करा.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""11 वा 13 ले भाग जाने n भन्दा साना पूर्णाङ्कहरूमा अङ्क 7 कति पटक आउँछ, सो संख्या फर्काउनुहोस्।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n ଠାରୁ କମ୍ ଏବଂ 11 କିମ୍ବା 13 ଦ୍ୱାରା ବିଭାଜ୍ୟ ହେଉଥିବା ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକରେ ଅଙ୍କ 7 କେତେ ଥର ଆସିଛି, ତାହା ଫେରାନ୍ତୁ।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n ਤੋਂ ਛੋਟੇ ਉਹਨਾਂ ਪੂਰਨ ਅੰਕਾਂ ਵਿੱਚ ਅੰਕ 7 ਜਿੰਨੀ ਵਾਰ ਆਉਂਦਾ ਹੈ ਉਹ ਗਿਣਤੀ ਵਾਪਸ ਕਰੋ, ਜੋ 11 ਜਾਂ 13 ਨਾਲ ਵੰਡਣਯੋਗ ਹਨ।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n तः न्यूनेषु तथा 11 अथवा 13 द्वारा विभाज्येषु पूर्णाङ्केषु 7 इति अङ्कः कतिवारम् आगच्छति तां सङ्ख्यां प्रत्यर्पयतु।
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""11 அல்லது 13 ஆல் வகுபடக்கூடிய, n-ஐ விடக் குறைவான முழு எண்களில் 7 என்ற இலக்கம் எத்தனை முறை தோன்றுகிறது என்பதைத் திருப்பியளிக்கவும்.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""11 లేదా 13 చే భాగింపబడే మరియు n కంటే తక్కువగా ఉండే పూర్ణాంకాలలో 7 అనే అంకె ఎన్నిసార్లు కనిపిస్తుందో ఆ సంఖ్యను ఇవ్వండి.
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
def fizz_buzz(n: int):
"""n سے کم ایسے صحیح اعداد (integers) میں ہندسہ 7 کے ظاہر ہونے کی تعداد واپس کریں جو 11 یا 13 پر قابل تقسیم ہوں۔
>>> fizz_buzz(50)
0
>>> fizz_buzz(78)
2
>>> fizz_buzz(79)
3
"""
|
HumanEval/37 |
def sort_even(l: list):
"""This function takes a list l and returns a list l' such that
l' is identical to l in the odd indicies, while its values at the even indicies are equal
to the values of the even indicies of l, but sorted.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
... | evens = l[::2]
odds = l[1::2]
evens.sort()
ans = []
for e, o in zip(evens, odds):
ans.extend([e, o])
if len(evens) > len(odds):
ans.append(evens[-1])
return ans
|
METADATA = {}
def check(candidate):
assert tuple(candidate([1, 2, 3])) == tuple([1, 2, 3])
assert tuple(candidate([5, 3, -5, 2, -3, 3, 9, 0, 123, 1, -10])) == tuple([-10, 3, -5, 2, -3, 3, 5, 0, 9, 1, 123])
assert tuple(candidate([5, 8, -12, 4, 23, 2, 3, 11, 12, -10])) == tuple([-12, 8, 3, 4, 5, 2, 12, 1... | sort_even |
def sort_even(l: list):
"""এই ফলনটোৱে এটা তালিকা l লয় আৰু এটা তালিকা l' ঘূৰাই দিয়ে যাতে
l' অযুগ্ম সূচকসমূহত l ৰ সৈতে একে হয়, আনহাতে ইয়াৰ যুগ্ম সূচকসমূহৰ মানবোৰ
l ৰ যুগ্ম সূচকসমূহৰ মানৰ সমান, কিন্তু সজোৱা (sorted)।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5,... |
def sort_even(l: list):
"""এই ফাংশনটি একটি তালিকা l গ্রহণ করে এবং এমন একটি তালিকা l' প্রদান করে যাতে
বিজোড় ইন্ডেক্সগুলোতে l' হুবহু l-এর মতো থাকে, যেখানে এর জোড় ইন্ডেক্সগুলোর মানসমূহ
l-এর জোড় ইন্ডেক্সগুলোর মানের সমান কিন্তু সাজানো (sorted) অবস্থায় থাকে।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> so... |
def sort_even(l: list):
"""આ ફંક્શન એક લિસ્ટ l લે છે અને એવું લિસ્ટ l' રીટર્ન કરે છે કે જેથી
l' એ odd indicies પર l જેવું જ હોય, જ્યારે even indicies પર તેના મૂલ્યો
l ના even indicies ના મૂલ્યો સમાન હોય, પરંતુ સૉર્ટ કરેલા હોય.
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
... |
def sort_even(l: list):
"""यह फ़ंक्शन एक list l लेता है और एक ऐसी list l' लौटाता है कि
l' odd indices पर l के समान हो, जबकि even indices पर इसके मान
l के even indices के मानों के बराबर हों, लेकिन sorted हों।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6, 5, 4]
""... |
def sort_even(l: list):
"""ಈ ಫಂಕ್ಷನ್ ಒಂದು ಲಿಸ್ಟ್ l ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು l' ಎಂಬ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ
l' ನ ಬೆಸ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿ (odd indicies) l ನಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಅದರ ಸಮ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿನ (even indicies) ಮೌಲ್ಯಗಳು
l ನ ಸಮ ಸೂಚ್ಯಂಕಗಳ ಮೌಲ್ಯಗಳಿಗೆ ಸಮಾನವಾಗಿದ್ದು, ವಿಂಗಡಿಸಲ್ಪಟ್ಟಿರುತ್ತವೆ (sorte... |
def sort_even(l: list):
"""ഈ ഫംഗ്ഷൻ ഒരു ലിസ്റ്റ് l സ്വീകരിക്കുകയും l' എന്നൊരു ലിസ്റ്റ് നൽകുകയും ചെയ്യുന്നു, ഇതിൽ
odd ഇൻഡക്സുകളിൽ l' എന്നത് l-ന് തുല്യമായിരിക്കും, അതേസമയം ഇതിന്റെ even ഇൻഡക്സുകളിലെ മൂല്യങ്ങൾ l-ന്റെ even ഇൻഡക്സുകളിലെ മൂല്യങ്ങൾക്ക് തുല്യവും എന്നാൽ സോർട്ട് ചെയ്തതുമായിരിക്കും.
>>> sort_even([1,... |
def sort_even(l: list):
"""हे फंक्शन एक list l घेते आणि अशी list l' परत करते की
l' ही विषम निर्देशांकांवर (odd indicies) l शी तंतोतंत समान असते, तर सम निर्देशांकांवरील तिची मूल्ये ही
l च्या सम निर्देशांकांवरील मूल्यांइतकीच असतात, परंतु क्रमवारी लावलेली (sorted) असतात.
>>> sort_even([1, 2, 3])
[1, ... |
def sort_even(l: list):
"""यो प्रकार्यले एउटा सूची l लिन्छ र एउटा यस्तो सूची l' फिर्ता गर्छ जहाँ
l' बिजोर इन्डेक्सहरूमा l सँग समान हुन्छ, जबकि यसको जोर इन्डेक्सहरूका मानहरू l का जोर
इन्डेक्सहरूका मानहरूसँग बराबर हुन्छन्, तर क्रमबद्ध (sorted) हुन्छन्।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort... |
def sort_even(l: list):
"""ଏହି function ଟି ଏକ list l ଗ୍ରହଣ କରେ ଏବଂ ଏପରି ଏକ list l' ଫେରସ୍ତ କରେ ଯେପରିକି
odd indicies ରେ l' ହେଉଛି l ସହିତ ସମାନ, ଯେତେବେଳେ even indicies ରେ ଏହାର ମାନଗୁଡ଼ିକ
l ର even indicies ର ମାନଗୁଡ଼ିକ ସହିତ ସମାନ, କିନ୍ତୁ sorted ହୋଇଥାଏ।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([... |
def sort_even(l: list):
"""ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ list l ਲੈਂਦਾ ਹੈ ਅਤੇ ਇੱਕ list l' ਵਾਪਸ ਕਰਦਾ ਹੈ ਤਾਂ ਕਿ
l' odd indicies ਉੱਤੇ l ਦੇ ਸਮਾਨ ਹੋਵੇ, ਜਦਕਿ even indicies ਉੱਤੇ ਇਸਦੇ ਮੁੱਲ
l ਦੇ even indicies ਦੇ ਮੁੱਲਾਂ ਦੇ ਬਰਾਬਰ ਹੋਣ, ਪਰ sorted ਹੋਣ।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> sort_even([5, 6, 3, 4])
[3, 6... |
def sort_even(l: list):
"""इदं फलनम् एकां सूचीं l गृह्णाति तथा च एतादृशीं सूचीं l' प्रत्यापयति यत्र
विषमसूचकाङ्केषु l' सूची l इव समाना भवति, यदा तु तस्याः समसूचकाङ्केषु स्थितानि मूल्यानि
l इत्यस्य समसूचकाङ्कानां मूल्यानां समानानि किन्तु क्रमितानि भवन्ति।
>>> sort_even([1, 2, 3])
[1, 2, 3]
>>> ... |
def sort_even(l: list):
"""இந்தச் சார்பு l என்ற பட்டியலை எடுத்துக்கொண்டு l' என்ற பட்டியலைத் தருகிறது, இதில்
l' ஆனது ஒற்றைப்படை குறியீடுகளில் l-ஐப் போலவே இருக்கும், அதே நேரத்தில் இரட்டைப்படை குறியீடுகளில் உள்ள அதன் மதிப்புகள்
l-இன் இரட்டைப்படை குறியீடுகளின் மதிப்புகளைப் போன்றே இருக்கும், ஆனால் வரிசைப்படுத்... |
def sort_even(l: list):
"""ఈ ఫంక్షన్ ఒక లిస్ట్ l ని తీసుకుని, l' అనే లిస్ట్ను రిటర్న్ చేస్తుంది. ఇందులో
l' అనేది బేసి ఇండిసెస్ (odd indicies) వద్ద l లాగే ఉంటుంది, అలాగే సరి ఇండిసెస్ (even indicies) వద్ద దీని విలువలు
l యొక్క సరి ఇండిసెస్ విలువల సమానంగా ఉంటూ, సార్ట్ చేయబడి (sorted) ఉంటాయి.
>>> sort_eve... |
def sort_even(l: list):
"""یہ فنکشن ایک فہرست l لیتا ہے اور ایک ایسی فہرست l' واپس کرتا ہے کہ
l' طاق انڈیکسز (odd indices) پر l کے بالکل مماثل ہو، جبکہ جفت انڈیکسز (even indices) پر اس کی ویلیوز l کے جفت انڈیکسز کی ویلیوز کے برابر ہوں، لیکن ترتیب شدہ (sorted) ہوں۔
>>> sort_even([1, 2, 3])
[1, 2, 3]
... |
HumanEval/38 |
def encode_cyclic(s: str):
"""
returns encoded string by cycling groups of three characters.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer elements than 3.
... | return encode_cyclic(encode_cyclic(s))
|
METADATA = {}
def check(candidate):
from random import randint, choice
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_cyclic(str)
assert candidate(encoded_str) == str
| decode_cyclic |
def encode_cyclic(s: str):
"""
তিনিটা বৰ্ণৰ গোটসমূহ চক্ৰাকাৰে ঘূৰাই এনকোড কৰা ষ্ট্ৰিং ঘূৰাই দিয়ে।
"""
# ষ্ট্ৰিংটোক গোটত ভাগ কৰক। প্ৰতিটোৰ দৈৰ্ঘ্য 3।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# প্ৰতিটো গোটৰ উপাদানসমূহ চক্ৰাকাৰে ঘূৰাওক। যদিহে গোটটোত 3টাতকৈ ... |
def encode_cyclic(s: str):
"""
তিনটি অক্ষরের গ্রুপগুলোকে চক্রাকারে আবর্তন করে এনকোড করা স্ট্রিং রিটার্ন করে।
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless group has fewer e... |
def encode_cyclic(s: str):
"""
ત્રણ અક્ષરોના જૂથોને સાયકલ કરીને એન્કોડ કરેલી સ્ટ્રિંગ પરત કરે છે.
"""
# સ્ટ્રિંગને જૂથોમાં વિભાજિત કરો. પ્રત્યેકની લંબાઈ 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# દરેક જૂથમાં તત્વોને સાયકલ કરો. સિવાય કે જૂથમાં 3 કરતાં ... |
def encode_cyclic(s: str):
"""
तीन वर्णों के समूहों को चक्रित (cycle) करके एन्कोड की गई स्ट्रिंग लौटाता है।
"""
# स्ट्रिंग को समूहों में विभाजित करें। प्रत्येक की लंबाई 3 है।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# प्रत्येक समूह के तत्वों को चक्रित कर... |
def encode_cyclic(s: str):
"""
ಮೂರು ಅಕ್ಷರಗಳ ಗುಂಪುಗಳನ್ನು ಆವರ್ತಿಸುವ (cycling) ಮೂಲಕ ಎನ್ಕೋಡ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Un... |
def encode_cyclic(s: str):
"""
മൂന്ന് അക്ഷരങ്ങൾ വീതമുള്ള ഗ്രൂപ്പുകളെ സൈക്കിൾ ചെയ്ത് എൻകോഡ് ചെയ്ത സ്ട്രിംഗ് നൽകുന്നു.
"""
# സ്ട്രിംഗിനെ ഗ്രൂപ്പുകളായി വിഭജിക്കുക. ഓരോന്നിനും 3 നീളം.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ഓരോ ഗ്രൂപ്പിലെയും ഘടകങ്ങളെ സൈക്... |
def encode_cyclic(s: str):
"""
तीन अक्षरांचे गट चक्रीय पद्धतीने फिरवून एन्कोड केलेली स्ट्रिंग परत करते.
"""
# स्ट्रिंगचे गटांमध्ये विभाजन करा. प्रत्येकाची लांबी 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# प्रत्येक गटातील घटकांना चक्रीय पद्धतीने फिरवा. ... |
def encode_cyclic(s: str):
"""
तीनवटा क्यारेक्टरहरूको समूहलाई चक्रीय (cycle) बनाएर इन्कोड गरिएको स्ट्रिङ फिर्ता गर्छ।
"""
# स्ट्रिङलाई समूहहरूमा विभाजन गर्नुहोस्। प्रत्येकको लम्बाइ 3।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# समूहमा 3 भन्दा कम तत्वहरू भ... |
def encode_cyclic(s: str):
"""
ତିନୋଟି ଅକ୍ଷରର ଗ୍ରୁପ୍ଗୁଡ଼ିକୁ ସାଇକଲ୍ କରି ଏନକୋଡ୍ ହୋଇଥିବା ଷ୍ଟ୍ରିଙ୍ଗ୍ ଫେରାଏ।
"""
# ଷ୍ଟ୍ରିଙ୍ଗକୁ ଗ୍ରୁପ୍ରେ ବିଭକ୍ତ କରନ୍ତୁ। ପ୍ରତ୍ୟେକର ଦୈର୍ଘ୍ୟ 3।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ପ୍ରତ୍ୟେକ ଗ୍ରୁପ୍ରେ ଉପାଦାନଗୁଡ଼ିକୁ ସାଇକଲ୍ କରନ... |
def encode_cyclic(s: str):
"""
ਤਿੰਨ ਅੱਖਰਾਂ ਦੇ ਸਮੂਹਾਂ ਨੂੰ ਸਾਈਕਲ ਕਰਕੇ ਏਨਕੋਡ ਕੀਤੀ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
"""
# ਸਤਰ ਨੂੰ ਸਮੂਹਾਂ ਵਿੱਚ ਵੰਡੋ। ਹਰੇਕ ਦੀ ਲੰਬਾਈ 3।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ਹਰੇਕ ਸਮੂਹ ਵਿੱਚ ਐਲੀਮੈਂਟਾਂ ਨੂੰ ਸਾਈਕਲ ਕਰੋ। ਜਦੋਂ ਤੱਕ ਸਮੂਹ ਵਿੱਚ 3 ਤੋਂ ... |
def encode_cyclic(s: str):
"""
त्रिवर्णानां समूहान् चक्रीकृत्य कूटबद्धं सूत्रं प्रत्याददाति।
"""
# सूत्रं समूहेषु विभजतु। प्रत्येकस्य दैर्घ्यं ३ अस्ति।
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# प्रत्येकसमूहे तत्त्वानि चक्रीकरोतु। यदि समूहे ३ तः न्यूनानि... |
def encode_cyclic(s: str):
"""
மூன்று எழுத்துக்கள் கொண்ட குழுக்களை சுழற்றுவதன் மூலம் குறியாக்கம் செய்யப்பட்ட சரத்தை வழங்குகிறது.
"""
# சரத்தை குழுக்களாகப் பிரிக்கவும். ஒவ்வொன்றும் நீளம் 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ஒவ்வொரு குழுவிலும் உள்... |
def encode_cyclic(s: str):
"""
మూడు అక్షరాల సమూహాలను సైకిల్ చేయడం ద్వారా ఎన్కోడ్ చేయబడిన స్ట్రింగ్ను రిటర్న్ చేస్తుంది.
"""
# split string to groups. Each of length 3.
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# cycle elements in each group. Unless grou... |
def encode_cyclic(s: str):
"""
تین حروف کے گروپس کو گردش دے کر انکوڈ شدہ اسٹرنگ واپس کرتا ہے۔
"""
# اسٹرنگ کو گروپس میں تقسیم کریں۔ ہر ایک کی لمبائی 3 ہو۔
groups = [s[(3 * i):min((3 * i + 3), len(s))] for i in range((len(s) + 2) // 3)]
# ہر گروپ کے عناصر کو گردش دیں۔ ماسوائے جب گروپ میں 3 سے ک... |
HumanEval/39 |
def prime_fib(n: int):
"""
prime_fib returns n-th number that is a Fibonacci number and it's also prime.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
| import math
def is_prime(p):
if p < 2:
return False
for k in range(2, min(int(math.sqrt(p)) + 1, p - 1)):
if p % k == 0:
return False
return True
f = [0, 1]
while True:
f.append(f[-1] + f[-2])
if is_prime(f[-1]):
... |
METADATA = {}
def check(candidate):
assert candidate(1) == 2
assert candidate(2) == 3
assert candidate(3) == 5
assert candidate(4) == 13
assert candidate(5) == 89
assert candidate(6) == 233
assert candidate(7) == 1597
assert candidate(8) == 28657
assert candidate(9) == 514229
... | prime_fib |
def prime_fib(n: int):
"""
prime_fib-এ n-তম সংখ্যাটো ঘূৰাই দিয়ে যি এটা Fibonacci সংখ্যা আৰু লগতে মৌলিক সংখ্যাও।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib n-তম এমন সংখ্যা রিটার্ন করে যা একটি Fibonacci সংখ্যা এবং একই সাথে মৌলিক।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib એવી n-મી સંખ્યા રીટર્ન કરે છે જે Fibonacci સંખ્યા પણ હોય અને અવિભાજ્ય (prime) પણ હોય.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib n-वीं ऐसी संख्या लौटाता है जो एक Fibonacci संख्या है और साथ ही अभाज्य (prime) भी है।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ಯು Fibonacci ಸಂಖ್ಯೆಯೂ ಮತ್ತು prime ಸಂಖ್ಯೆಯೂ ಆಗಿರುವ n-ನೇ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ഒരു ഫിബൊനാച്ചി സംഖ്യയും അതോടൊപ്പം ഒരു അഭാജ്യസംഖ്യയും ആയ n-ാമത്തെ സംഖ്യ നൽകുന്നു.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ही n-वी अशी संख्या परत करते जी Fibonacci संख्या आहे आणि मूळ संख्या (prime) देखील आहे.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ले Fibonacci संख्या र अभाज्य (prime) दुवै भएको n-औं संख्या फर्काउँछ।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ଏପରି n-ତମ ସଂଖ୍ୟା ଫେରସ୍ତ କରେ ଯାହା ଏକ Fibonacci ସଂଖ୍ୟା ଏବଂ ଏହା ମଧ୍ୟ ଏକ ମୌଳିକ ସଂଖ୍ୟା ଅଟେ।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ਉਹ n-ਵਾਂ ਨੰਬਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਇੱਕ Fibonacci ਨੰਬਰ ਹੈ ਅਤੇ ਇਹ ਪ੍ਰਾਈਮ ਵੀ ਹੈ।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib n-तमां तादृशीं संख्यां प्रत्यानयति या Fibonacci-संख्या अस्ति तथा अभाज्या (prime) अपि अस्ति।
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib ஆனது Fibonacci எண்ணாகவும் மற்றும் பகா எண்ணாகவும் இருக்கும் n-வது எண்ணைத் திருப்பித் தரும்.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib అనేది Fibonacci సంఖ్య మరియు ప్రధాన సంఖ్య కూడా అయిన n-వ సంఖ్యను రిటర్న్ చేస్తుంది.
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
def prime_fib(n: int):
"""
prime_fib وہ n-واں عدد واپس کرتا ہے جو Fibonacci عدد بھی ہے اور مفرد (prime) بھی ہے۔
>>> prime_fib(1)
2
>>> prime_fib(2)
3
>>> prime_fib(3)
5
>>> prime_fib(4)
13
>>> prime_fib(5)
89
"""
|
HumanEval/40 |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero takes a list of integers as an input.
it returns True if there are three distinct elements in the list that
sum to zero, and False otherwise.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
Tr... | for i in range(len(l)):
for j in range(i + 1, len(l)):
for k in range(j + 1, len(l)):
if l[i] + l[j] + l[k] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, 5, -1]) == False
assert candidate([1, 3, -2, 1]) == True
assert candidate([1, 2, 3, 7]) == False
assert candidate([1, 2, 5, 7]) == False
assert candidate([2, 4, -5, 3, 9, 7]) == True
asser... | triples_sum_to_zero |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero-এ ইনপুট হিচাপে এটা অখণ্ড সংখ্যাৰ তালিকা লয়।
যদি তালিকাত এনে তিনিটা সুকীয়া উপাদান থাকে যাৰ যোগফল শূন্য হয়, তেন্তে ই True ঘূৰাই দিয়ে, আৰু অন্যথা False ঘূৰাই দিয়ে।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ইনপুট হিসেবে পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে।
তালিকায় যদি এমন তিনটি স্বতন্ত্র উপাদান থাকে যাদের যোগফল শূন্য হয়,
তবে এটি True রিটার্ন করে, অন্যথায় False।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, ... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ઇનપુટ તરીકે પૂર્ણાંકોની એક list લે છે.
જો list માં ત્રણ અલગ ઘટકો હોય જેનો સરવાળો શૂન્ય થતો હોય તો તે True પરત કરે છે, અને અન્યથા False પરત કરે છે.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
T... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero इनपुट के रूप में पूर्णांकों (integers) की एक सूची लेता है।
यदि सूची में तीन अलग-अलग (distinct) तत्व हैं जिनका योग शून्य है, तो यह True लौटाता है,
अन्यथा False लौटाता है।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_t... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಪಟ್ಟಿಯಲ್ಲಿ ಮೊತ್ತ ಶೂನ್ಯವಾಗುವಂತಹ ಮೂರು ವಿಭಿನ್ನ ಅಂಶಗಳಿದ್ದರೆ ಇದು True ಅನ್ನು ನೀಡುತ್ತದೆ,
ಇಲ್ಲದಿದ್ದರೆ False ಅನ್ನು ನೀಡುತ್ತದೆ.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് ഇൻപുട്ടായി സ്വീകരിക്കുന്നു.
കൂട്ടുമ്പോൾ തുക പൂജ്യം ലഭിക്കുന്ന മൂന്ന് വ്യത്യസ്ത എലമെന്റുകൾ ലിസ്റ്റിൽ ഉണ്ടെങ്കിൽ
ഇത് True എന്നും, അല്ലാത്തപക്ഷം False എന്നും നൽകുന്നു.
>>> triples_sum_to_zero([1, 3, 5, 0])
Fa... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero पूर्णांकांची (integers) एक सूची इनपुट म्हणून घेते.
जर सूचीमध्ये बेरीज शून्य येणारे तीन भिन्न घटक असतील तर हे True परत करते, आणि अन्यथा False परत करते.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ले पूर्णाङ्कहरूको सूची इनपुटको रूपमा लिन्छ।
यदि सूचीमा योगफल शून्य हुने तीनवटा भिन्न तत्वहरू छन् भने यसले True फर्काउँछ, अन्यथा False फर्काउँछ।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
True... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ଇନପୁଟ୍ ଭାବରେ integers ର ଏକ list ଗ୍ରହଣ କରେ।
ଯଦି list ରେ ତିନୋଟି ପୃଥକ୍ ଉପାଦାନ ଥାଏ ଯାହାର ଯୋଗଫଳ
ଶୂନ ହୁଏ, ତେବେ ଏହା True ଫେରାଏ, ଏବଂ ଅନ୍ୟଥା False ଫେରାଏ।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ (list of integers) ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ।
ਇਹ True ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਤਿੰਨ ਵੱਖਰੇ ਤੱਤ (distinct elements) ਹੋਣ ਜਿਨ੍ਹਾਂ ਦਾ ਜੋੜ ਸਿਫ਼ਰ (zero) ਬਣਦਾ ਹੈ, ਅਤੇ ਨਹੀਂ ਤਾਂ False।
>>> triples_sum_to_zero([1, 3, 5, 0])
Fa... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero पूर्णाङ्कानां सूचीं निवेशरूपेण स्वीकरोति।
यदि सूच्यां त्रयः भिन्नाः अवयवाः सन्ति येषां योगः शून्यं भवति तर्हि
इदं True प्रत्यर्पयति, अन्यथा च False।
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero முழு எண்களின் பட்டியல் ஒன்றை உள்ளீடாகப் பெறுகிறது.
பட்டியலில் கூடுதல் பூஜ்ஜியமாக இருக்கும் மூன்று தனித்துவமான உறுப்புகள் இருந்தால்
இது True என்பதையும், இல்லையெனில் False என்பதையும் வழங்கும்.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero పూర్ణాంకాల జాబితాను ఇన్పుట్గా తీసుకుంటుంది.
జాబితాలో మొత్తం సున్నా అయ్యే మూడు విభిన్న మూలకాలు ఉంటే ఇది True ని, లేకపోతే False ని రిటర్న్ చేస్తుంది.
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])
... |
def triples_sum_to_zero(l: list):
"""
triples_sum_to_zero ان پٹ کے طور پر integers کی ایک فہرست لیتا ہے۔
اگر فہرست میں تین الگ الگ عناصر ایسے ہوں جن کا مجموعہ صفر بنتا ہو تو یہ True لوٹاتا ہے، بصورت دیگر False۔
>>> triples_sum_to_zero([1, 3, 5, 0])
False
>>> triples_sum_to_zero([1, 3, -2, 1])... |
HumanEval/41 |
def car_race_collision(n: int):
"""
Imagine a road that's a perfectly straight infinitely long line.
n cars are driving left to right; simultaneously, a different set of n cars
are driving right to left. The two sets of cars start out being very far from
each other. All cars move in the same s... | return n**2
|
METADATA = {}
def check(candidate):
assert candidate(2) == 4
assert candidate(3) == 9
assert candidate(4) == 16
assert candidate(8) == 64
assert candidate(10) == 100
| car_race_collision |
def car_race_collision(n: int):
"""
এখন ৰাস্তা কল্পনা কৰক যিডাল এটা সম্পূৰ্ণভাৱে পোন অসীমভাৱে দীঘল ৰেখা।
n খন গাড়ী বাওঁফালৰ পৰা সোঁফাললৈ চলাই থকা হৈছে; একে সময়তে, n খন গাড়ীৰ আন এটা গোটে
সোঁফালৰ পৰা বাওঁফাললৈ চলাই আছে। দুয়োটা গাড়ীৰ গোট ইটোৱে সিটোৰ পৰা বহুত দূৰৰ পৰা আৰম্ভ হয়।
সকলো গাড়ী একে গতিত গতি ... |
def car_race_collision(n: int):
"""
কল্পনা করুন একটি রাস্তা যা সম্পূর্ণ সোজা এবং অসীম দৈর্ঘ্যের একটি রেখা।
n-টি গাড়ি বাম থেকে ডানে যাচ্ছে; একই সাথে, n-টি গাড়ির আরেকটি দল
ডান থেকে বামে যাচ্ছে। গাড়ির দুটি দল একে অপরের থেকে অনেক দূর থেকে শুরু করে।
সব গাড়ি একই গতিতে চলে। দুটি গাড়ির মধ্যে সংঘর্ষ হ... |
def car_race_collision(n: int):
"""
એક એવા રસ્તાની કલ્પના કરો જે સંપૂર્ણપણે સીધી અને અનંત લાંબી રેખા છે.
n કાર ડાબેથી જમણે જઈ રહી છે; તે જ સમયે, n કારનો એક અલગ સમૂહ
જમણેથી ડાબે જઈ રહ્યો છે. કારના બંને સમૂહો એકબીજાથી ખૂબ દૂરથી
શરૂ થાય છે. બધી કાર એક જ ઝડપે આગળ વધે છે. જ્યારે ડાબેથી જમણે જતી કાર
... |
def car_race_collision(n: int):
"""
कल्पना कीजिए कि एक सड़क है जो बिल्कुल सीधी और अनंत रूप से लंबी रेखा है।
n कारें बाएं से दाएं चल रही हैं; साथ ही, n कारों का एक अलग समूह
दाएं से बाएं चल रहा है। कारों के दोनों समूह एक-दूसरे से बहुत दूर से शुरू होते हैं।
सभी कारें समान गति से चलती हैं। दो कारों की... |
def car_race_collision(n: int):
"""
ಸಂಪೂರ್ಣವಾಗಿ ನೇರವಾದ, ಅನಂತ ಉದ್ದದ ರೇಖೆಯಂತಿರುವ ರಸ್ತೆಯನ್ನು ಊಹಿಸಿಕೊಳ್ಳಿ.
n ಕಾರುಗಳು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಚಲಿಸುತ್ತಿವೆ; ಅದೇ ಸಮಯದಲ್ಲಿ, n ಕಾರುಗಳ ಮತ್ತೊಂದು ಗುಂಪು
ಬಲದಿಂದ ಎಡಕ್ಕೆ ಚಲಿಸುತ್ತಿದೆ. ಈ ಎರಡು ಗುಂಪಿನ ಕಾರುಗಳು ಪರಸ್ಪರ ಬಹಳ ದೂರದಿಂದ
ಪ್ರಾರಂಭವಾಗುತ್ತವೆ. ಎಲ್ಲಾ ಕಾರುಗಳು ಒಂದೇ ವೇಗದಲ್ಲಿ ಚಲಿಸುತ... |
def car_race_collision(n: int):
"""
പൂർണ്ണമായും നേരായ, അനന്തമായ നീളമുള്ള ഒരു റോഡ് സങ്കൽപ്പിക്കുക.
n കാറുകൾ ഇടത്തുനിന്ന് വലത്തോട്ട് സഞ്ചരിക്കുന്നു; ഒരേസമയം, n കാറുകളുടെ മറ്റൊരു കൂട്ടം
വലത്തുനിന്ന് ഇടത്തോട്ട് സഞ്ചരിക്കുന്നു. ഈ രണ്ട് കൂട്ടം കാറുകളും പരസ്പരം വളരെ അകലെ നിന്നാണ്
ആരംഭിക്കുന്നത്. എല്ലാ കാ... |
def car_race_collision(n: int):
"""
एका रस्त्याची कल्पना करा जो अगदी सरळ आणि अनंत लांबीची रेषा आहे.
n गाड्या डावीकडून उजवीकडे जात आहेत; त्याच वेळी, n गाड्यांचा दुसरा संच
उजवीकडून डावीकडे जात आहे. गाड्यांचे दोन्ही संच सुरुवातीला एकमेकांपासून खूप
दूर आहेत. सर्व गाड्या एकाच वेगाने धावत आहेत. जेव्हा ड... |
def car_race_collision(n: int):
"""
एउटा पूर्ण रूपमा सीधा र अनन्त लामो रेखा भएको सडकको कल्पना गर्नुहोस्।
n वटा कारहरू बायाँबाट दायाँतिर गुडिरहेका छन्; एकै समयमा, अर्को n वटा कारहरूको छुट्टै समूह
दायाँबाट बायाँतिर गुडिरहेका छन्। कारका दुई समूहहरू सुरुमा एकअर्काबाट धेरै टाढा हुन्छन्।
सबै कारहरू समान... |
def car_race_collision(n: int):
"""
ଏକ ସମ୍ପୂର୍ଣ୍ଣ ସିଧା ଏବଂ ଅସୀମ ଭାବେ ଲମ୍ବା ରାସ୍ତା ବିଷୟରେ କଳ୍ପନା କରନ୍ତୁ।
n ଟି କାର୍ ବାମରୁ ଡାହାଣକୁ ଯାଉଛନ୍ତି; ଏକ ସଙ୍ଗେ, n ଟି କାର୍ର ଅନ୍ୟ ଏକ ସେଟ୍
ଡାହାଣରୁ ବାମକୁ ଯାଉଛନ୍ତି। ଏହି ଦୁଇଟି ସେଟ୍ର କାର୍ ପରସ୍ପରଠାରୁ ବହୁତ ଦୂରରୁ
ଆରମ୍ଭ କରନ୍ତି। ସମସ୍ତ କାର୍ ସମାନ ବେଗରେ ଗତି କରନ୍ତି। ଦୁଇଟି କାର... |
def car_race_collision(n: int):
"""
ਕਲਪਨਾ ਕਰੋ ਕਿ ਇੱਕ ਸੜਕ ਹੈ ਜੋ ਇੱਕ ਬਿਲਕੁਲ ਸਿੱਧੀ ਅਨੰਤ ਲੰਬੀ ਲਾਈਨ ਹੈ।
n ਕਾਰਾਂ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਵੱਲ ਜਾ ਰਹੀਆਂ ਹਨ; ਇਸਦੇ ਨਾਲ ਹੀ, n ਕਾਰਾਂ ਦਾ ਇੱਕ ਵੱਖਰਾ ਸਮੂਹ
ਸੱਜੇ ਤੋਂ ਖੱਬੇ ਵੱਲ ਜਾ ਰਿਹਾ ਹੈ। ਕਾਰਾਂ ਦੇ ਦੋਵੇਂ ਸਮੂਹ ਇੱਕ ਦੂਜੇ ਤੋਂ ਬਹੁਤ ਦੂਰ
ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ। ਸਾਰੀਆਂ ਕਾਰਾਂ ਇੱਕੋ ਗਤੀ ਨਾਲ ਚੱਲਦੀਆਂ... |
def car_race_collision(n: int):
"""
कल्पयतु यदेकः मार्गः सर्वथा ऋजुः अनन्तदीर्घरेखास्वरूपश्च अस्ति।
n वाहनानि वामतः दक्षिणं प्रति चलन्ति; युगपदेव, अपरः n वाहनानां समूहः
दक्षिणतः वामं प्रति चलति। द्वौ अपि वाहनसमूहौ परस्परं सुदूरात्
आरभेते। सर्वाणि वाहनानि समानगत्या चलन्ति। यदा
वामतः दक्षिणं प्र... |
def car_race_collision(n: int):
"""
ஒரு சாலை முற்றிலும் நேராகவும் முடிவிலா நீளமுடைய ஒரு கோடாகவும் இருப்பதாகக் கற்பனை செய்து கொள்ளுங்கள்.
n கார்கள் இடமிருந்து வலமாகச் செல்கின்றன; அதே நேரத்தில், மற்றொரு n கார்களைக் கொண்ட தொகுப்பு
வலமிருந்து இடமாகச் செல்கிறது. இந்த இரண்டு கார் தொகுப்புகளும் ஒன்றுக்கொன்று... |
def car_race_collision(n: int):
"""
పూర్తిగా నిటారుగా మరియు అనంతమైన పొడవున్న ఒక సరళరేఖ లాంటి రహదారిని ఊహించుకోండి.
n కార్లు ఎడమ నుండి కుడికి డ్రైవ్ చేస్తున్నాయి; అదే సమయంలో, n కార్ల యొక్క వేరొక సమూహం
కుడి నుండి ఎడమకు డ్రైవ్ చేస్తోంది. ఈ రెండు కార్ల సమూహాలు ఒకదానికొకటి చాలా దూరంగా
ప్రారంభమవుతాయి. అ... |
def car_race_collision(n: int):
"""
ایک ایسی سڑک کا تصور کریں جو بالکل سیدھی اور لامتناہی طور پر لمبی لائن ہے۔
n گاڑیاں بائیں سے دائیں جانب چل رہی ہیں؛ بیک وقت، n گاڑیوں کا ایک مختلف سیٹ
دائیں سے بائیں جانب چل رہا ہے۔ گاڑیوں کے دونوں سیٹ شروع میں ایک دوسرے سے بہت دور
ہوتے ہیں۔ تمام گاڑیاں یکساں رف... |
HumanEval/42 |
def incr_list(l: list):
"""Return list with elements incremented by 1.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
| return [(e + 1) for e in l]
|
METADATA = {}
def check(candidate):
assert candidate([]) == []
assert candidate([3, 2, 1]) == [4, 3, 2]
assert candidate([5, 2, 5, 2, 3, 3, 9, 0, 123]) == [6, 3, 6, 3, 4, 4, 10, 1, 124]
| incr_list |
def incr_list(l: list):
"""উপাদানসমূহ 1 বৃদ্ধি কৰা list ঘূৰাই দিয়ক।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
| def incr_list(l: list):
"""উপাদানগুলি 1 বৃদ্ধি করে তৈরি লিস্ট রিটার্ন করুন।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
""" |
def incr_list(l: list):
"""1 વડે વધારવામાં આવેલા ઘટકો સાથેની લિસ્ટ રીટર્ન કરો.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""ऐसी सूची वापस लौटाएं जिसके तत्वों में 1 की वृद्धि की गई हो।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""ಅಂಶಗಳನ್ನು 1 ರಿಂದ ಹೆಚ್ಚಿಸಲಾದ ಪಟ್ಟಿಯನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""എലമെന്റുകൾ 1 വർദ്ധിപ്പിച്ച ലിസ്റ്റ് തിരികെ നൽകുക.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""1 ने वाढवलेले घटक असलेली लिस्ट परत करा.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""तत्वहरूलाई 1 ले बढाइएको सूची फिर्ता गर्नुहोस्।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""ଉପାଦାନଗୁଡ଼ିକ 1 ଦ୍ୱାରା ବୃଦ୍ଧି କରାଯାଇଥିବା list ଫେରାନ୍ତୁ।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""1 ਨਾਲ ਵਧਾਏ ਗਏ ਐਲੀਮੈਂਟਾਂ ਵਾਲੀ ਲਿਸਟ ਵਾਪਸ ਕਰੋ।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""1 इत्यनेन वर्धितैः अवयवैः युक्तां सूचीं प्रत्यर्पयतु।
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""உறுப்புகள் 1 அதிகரிக்கப்பட்ட பட்டியலைத் திருப்பியளிக்கவும்.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""మూలకాలను 1 పెంచిన లిస్ట్ను రిటర్న్ చేయండి.
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
def incr_list(l: list):
"""ایسی list واپس کریں جس کے عناصر میں 1 کا اضافہ کیا گیا ہو۔
>>> incr_list([1, 2, 3])
[2, 3, 4]
>>> incr_list([5, 3, 5, 2, 3, 3, 9, 0, 123])
[6, 4, 6, 3, 4, 4, 10, 1, 124]
"""
|
HumanEval/43 |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero takes a list of integers as an input.
it returns True if there are two distinct elements in the list that
sum to zero, and False otherwise.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs... | for i, l1 in enumerate(l):
for j in range(i + 1, len(l)):
if l1 + l[j] == 0:
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 3, 5, 0]) == False
assert candidate([1, 3, -2, 1]) == False
assert candidate([1, 2, 3, 7]) == False
assert candidate([2, 4, -5, 3, 5, 7]) == True
assert candidate([1]) == False
assert candidate([-3, 9, -1, 3, 2, 30]) == True
asser... | pairs_sum_to_zero |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero য়ে ইনপুট হিচাপে এটা অখণ্ড সংখ্যাৰ তালিকা লয়।
যদি তালিকাত এনে দুটা সুকীয়া উপাদান থাকে যাৰ যোগফল শূন্য হয় তেন্তে ই True ঘূৰাই দিয়ে, আৰু অন্যথা False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> p... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ইনপুট হিসেবে পূর্ণসংখ্যার একটি তালিকা গ্রহণ করে।
যদি তালিকায় এমন দুটি পৃথক উপাদান থাকে যাদের যোগফল শূন্য হয়, তবে এটি True রিটার্ন করে, এবং অন্যথায় False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ઇનપુટ તરીકે પૂર્ણાંકોની એક list લે છે.
જો list માં એવા બે અલગ ઘટકો હોય જેનો સરવાળો શૂન્ય થાય તો તે True આપે છે, અને અન્યથા False.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_to_zero([... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero इनपुट के रूप में पूर्णांकों की एक सूची लेता है।
यह True लौटाता है यदि सूची में दो अलग-अलग तत्व हैं जिनका
योग शून्य है, और अन्यथा False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಪಟ್ಟಿಯಲ್ಲಿ ಮೊತ್ತ ಶೂನ್ಯವಾಗುವಂತಹ ಎರಡು ವಿಭಿನ್ನ ಅಂಶಗಳಿದ್ದರೆ ಇದು True ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ,
ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ False ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ഒരു പൂർണ്ണസംഖ്യകളുടെ ലിസ്റ്റ് ഇൻപുട്ടായി സ്വീകരിക്കുന്നു.
ലിസ്റ്റിൽ തുക പൂജ്യമാകുന്ന വ്യത്യസ്തങ്ങളായ രണ്ട് എലമെന്റുകൾ ഉണ്ടെങ്കിൽ ഇത് True നൽകുന്നു,
അല്ലാത്തപക്ഷം False നൽകുന്നു.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero(... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero पूर्णांकांची सूची (list of integers) इनपुट म्हणून घेते.
जर सूचीमध्ये दोन भिन्न घटक असतील ज्यांची बेरीज शून्य होते, तर हे True परत करते,
आणि अन्यथा False परत करते.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ले पूर्णाङ्कहरूको एउटा list इनपुटको रूपमा लिन्छ।
यदि list मा योग शून्य हुने दुई भिन्न तत्वहरू छन् भने यसले True फिर्ता गर्छ, अन्यथा False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_sum_... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ଇନପୁଟ୍ ଭାବରେ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର (integers) ଏକ list ନିଏ।
ଯଦି list ରେ ଦୁଇଟି ପୃଥକ ଉପାଦାନ ଥାଏ ଯାହାର ଯୋଗଫଳ ଶୂନ ହୁଏ, ତେବେ ଏହା True ଫେରସ୍ତ କରେ,
ଏବଂ ଅନ୍ୟଥା False ଫେରସ୍ତ କରେ।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2,... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਨੂੰ ਇਨਪੁੱਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ।
ਇਹ True ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਦੋ ਵੱਖਰੇ ਐਲੀਮੈਂਟ ਹਨ ਜਿਨ੍ਹਾਂ ਦਾ
ਜੋੜ ਸਿਫ਼ਰ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਨਹੀਂ ਤਾਂ False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
Fal... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero पूर्णाङ्कानां सूचीम् आदानत्वेन स्वीकरोति।
यदि सूच्यां द्वौ भिन्नौ अवयवौ स्तः ययोः योगः शून्यं भवति, तर्हि इदं True प्रत्यर्पयति,
अन्यथा False।
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pa... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero முழு எண்களின் பட்டியலை உள்ளீடாகப் பெறுகிறது.
பட்டியலில் கூட்டுத்தொகை பூஜ்ஜியமாக வரும் வகையில் இரண்டு தனித்துவமான உறுப்புகள் இருந்தால்
இது True என்பதையும், இல்லையெனில் False என்பதையும் திருப்பியளிக்கிறது.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero పూర్ణాంకాల లిస్ట్ను ఇన్పుట్గా తీసుకుంటుంది.
లిస్ట్లో మొత్తం సున్నా అయ్యేలా రెండు వేర్వేరు మూలకాలు ఉంటే ఇది True ని,
లేకపోతే False ని అందిస్తుంది.
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
... |
def pairs_sum_to_zero(l):
"""
pairs_sum_to_zero انٹیجرز کی ایک لسٹ بطور ان پٹ لیتا ہے۔
اگر لسٹ میں دو الگ الگ عناصر موجود ہوں جن کا مجموعہ صفر ہو تو یہ True واپس کرتا ہے، بصورت دیگر False۔
>>> pairs_sum_to_zero([1, 3, 5, 0])
False
>>> pairs_sum_to_zero([1, 3, -2, 1])
False
>>> pairs_su... |
HumanEval/44 |
def change_base(x: int, base: int):
"""Change numerical base of input number x to base.
return string representation after the conversion.
base numbers are less than 10.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
| ret = ""
while x > 0:
ret = str(x % base) + ret
x //= base
return ret
|
METADATA = {}
def check(candidate):
assert candidate(8, 3) == "22"
assert candidate(9, 3) == "100"
assert candidate(234, 2) == "11101010"
assert candidate(16, 2) == "10000"
assert candidate(8, 2) == "1000"
assert candidate(7, 2) == "111"
for x in range(2, 8):
assert candidate(x, ... | change_base |
def change_base(x: int, base: int):
"""ইনপুট সংখ্যা x-ৰ সাংখ্যিক ভিত্তি (numerical base) base-লৈ সলনি কৰক।
ৰূপান্তৰৰ পিছত string ৰূপটো ৰিটাৰ্ণ কৰক।
base সংখ্যাবোৰ 10 তকৈ সৰু।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""ইনপুট সংখ্যা x-এর সাংখ্যিক ভিত্তি (numerical base) base-এ পরিবর্তন করুন।
রূপান্তরের পরে স্ট্রিং উপস্থাপনা রিটার্ন করুন।
base সংখ্যাগুলো 10-এর চেয়ে কম।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""... |
def change_base(x: int, base: int):
"""ઇનપુટ સંખ્યા x નો ન્યુમેરિકલ બેઝ બદલીને base કરો.
રૂપાંતરણ પછીનું સ્ટ્રિંગ સ્વરૂપ રિટર્ન કરો.
base સંખ્યાઓ 10 કરતાં ઓછી છે.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""इनपुट संख्या x के संख्यात्मक आधार (numerical base) को base में बदलें।
रूपांतरण के बाद स्ट्रिंग प्रतिनिधित्व (string representation) लौटाएं।
base संख्याएं 10 से कम हैं।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
... |
def change_base(x: int, base: int):
"""ಇನ್ಪುಟ್ ಸಂಖ್ಯೆ x ನ ಸಂಖ್ಯಾ ಬೇಸ್ ಅನ್ನು base ಗೆ ಬದಲಾಯಿಸಿ.
ಪರಿವರ್ತನೆಯ ನಂತರ ಸ್ಟ್ರಿಂಗ್ ರೆಪ್ರೆಸೆಂಟೇಶನ್ ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ.
base ಸಂಖ್ಯೆಗಳು 10 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿರುತ್ತವೆ.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
... |
def change_base(x: int, base: int):
"""ഇൻപുട്ട് സംഖ്യ x-ന്റെ ന്യൂമറിക്കൽ ബേസ് base-ലേക്ക് മാറ്റുക.
കൺവേർഷന് ശേഷമുള്ള സ്ട്രിംഗ് രൂപം റിട്ടേൺ ചെയ്യുക.
base സംഖ്യകൾ 10-ൽ കുറവാണ്.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""इन्पुट संख्या x चा numerical base बदलून base करा.
रूपांतरणानंतरचे string representation परत करा.
base संख्या 10 पेक्षा कमी आहेत.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""इनपुट संख्या x को numerical base लाई base मा परिवर्तन गर्नुहोस्।
रूपान्तरण पछिको string representation फिर्ता गर्नुहोस्।
base संख्याहरू 10 भन्दा कम हुन्छन्।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
... |
def change_base(x: int, base: int):
"""ଇନପୁଟ୍ ସଂଖ୍ୟା x ର ସାଂଖ୍ୟିକ base କୁ base ରେ ପରିବର୍ତ୍ତନ କରନ୍ତୁ।
ରୂପାନ୍ତରଣ ପରେ string ଉପସ୍ଥାପନା ଫେରାନ୍ତୁ।
base ସଂଖ୍ୟାଗୁଡ଼ିକ 10 ରୁ କମ୍ ଅଟେ।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""ਇਨਪੁਟ ਸੰਖਿਆ x ਦੇ ਸੰਖਿਆਤਮਕ ਬੇਸ ਨੂੰ base ਵਿੱਚ ਬਦਲੋ।
ਰੂਪਾਂਤਰਨ ਤੋਂ ਬਾਅਦ string representation ਵਾਪਸ ਕਰੋ।
base ਸੰਖਿਆਵਾਂ 10 ਤੋਂ ਘੱਟ ਹਨ।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""निवेशसङ्ख्यायाः x इत्यस्याः साङ्ख्यिकाधारं base प्रति परिवर्तयन्तु।
परिवर्तनानन्तरं string निरूपणं प्रत्यानयन्तु।
base सङ्ख्याः 10 तः न्यूनाः सन्ति।
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""உள்ளீட்டு எண் x-இன் எண்முறை அடிமானத்தை base-க்கு மாற்றவும்.
மாற்றத்திற்குப் பிறகு string வடிவை திருப்பியளிக்கவும்.
base எண்கள் 10-ஐ விடக் குறைவானவை.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
def change_base(x: int, base: int):
"""ఇన్పుట్ సంఖ్య x యొక్క న్యూమరికల్ బేస్ను base కి మార్చండి.
మార్పిడి తర్వాత స్ట్రింగ్ ప్రాతినిధ్యాన్ని రిటర్న్ చేయండి.
base సంఖ్యలు 10 కంటే తక్కువగా ఉంటాయి.
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
... |
def change_base(x: int, base: int):
"""ان پٹ نمبر x کی عددی بنیاد کو بیس میں تبدیل کریں۔
تبدیلی کے بعد string کی شکل میں نمائندگی واپس کریں۔
بیس کے نمبر 10 سے کم ہیں۔
>>> change_base(8, 3)
'22'
>>> change_base(8, 2)
'1000'
>>> change_base(7, 2)
'111'
"""
|
HumanEval/45 |
def triangle_area(a, h):
"""Given length of a side and high return area for a triangle.
>>> triangle_area(5, 3)
7.5
"""
| return a * h / 2.0
|
METADATA = {}
def check(candidate):
assert candidate(5, 3) == 7.5
assert candidate(2, 2) == 2.0
assert candidate(10, 8) == 40.0
| triangle_area |
def triangle_area(a, h):
"""এটা বাহুৰ দৈৰ্ঘ্য আৰু উচ্চতা দিয়া থাকিলে এটা ত্ৰিভুজৰ কালি ঘূৰাই দিয়ক।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""একটি বাহুর দৈর্ঘ্য এবং উচ্চতা দেওয়া থাকলে একটি ত্রিভুজের ক্ষেত্রফল রিটার্ন করুন।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""બાજુની લંબાઈ અને ઊંચાઈ આપેલ હોય ત્યારે ત્રિકોણનું ક્ષેત્રફળ રિટર્ન કરો.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""एक भुजा की लंबाई और ऊंचाई दिए जाने पर त्रिभुज का क्षेत्रफल लौटाएं।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ಒಂದು ಬಾಹುವಿನ ಉದ್ದ ಮತ್ತು ಎತ್ತರವನ್ನು ನೀಡಿದಾಗ ತ್ರಿಭುಜದ ವಿಸ್ತೀರ್ಣವನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ഒരു വശത്തിന്റെ നീളവും ഉയരവും നൽകിയാൽ ഒരു ത്രികോണത്തിന്റെ വിസ്തീർണ്ണം റിട്ടേൺ ചെയ്യുക.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""एका बाजूची लांबी आणि उंची दिली असता त्रिकोणाचे क्षेत्रफळ परत करा.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""एउटा भुजाको लम्बाइ र उचाइ दिइएको अवस्थामा त्रिभुजको क्षेत्रफल फर्काउनुहोस्।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ଗୋଟିଏ ବାହୁର ଦୈର୍ଘ୍ୟ ଏବଂ ଉଚ୍ଚତା ଦିଆଗଲେ ଏକ ତ୍ରିଭୁଜର କ୍ଷେତ୍ରଫଳ ଫେରାନ୍ତୁ।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ਇੱਕ ਭੁਜਾ ਦੀ ਲੰਬਾਈ ਅਤੇ ਉਚਾਈ ਦਿੱਤੇ ਜਾਣ 'ਤੇ ਇੱਕ ਤਿਕੋਣ ਦਾ ਖੇਤਰਫਲ ਵਾਪਸ ਕਰੋ।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""त्रिभुजस्य एकस्य बाहोः दैर्घ्ये औन्नत्ये च दत्ते सति क्षेत्रफलम् प्रत्यर्पयतु।
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ஒரு பக்கத்தின் நீளம் மற்றும் உயரம் கொடுக்கப்பட்டால், ஒரு முக்கோணத்தின் பரப்பளவைத் திருப்பியளிக்கவும்.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ఒక భుజం యొక్క పొడవు మరియు ఎత్తు ఇచ్చినప్పుడు త్రిభుజం యొక్క వైశాల్యాన్ని రిటర్న్ చేయండి.
>>> triangle_area(5, 3)
7.5
"""
|
def triangle_area(a, h):
"""ایک ضلع کی لمبائی اور اونچائی دیے جانے پر مثلث کا رقبہ واپس کریں۔
>>> triangle_area(5, 3)
7.5
"""
|
HumanEval/46 |
def fib4(n: int):
"""The Fib4 number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
Please write a function to efficiently compute the n-th el... | results = [0, 0, 2, 0]
if n < 4:
return results[n]
for _ in range(4, n + 1):
results.append(results[-1] + results[-2] + results[-3] + results[-4])
results.pop(0)
return results[-1]
|
METADATA = {}
def check(candidate):
assert candidate(5) == 4
assert candidate(8) == 28
assert candidate(10) == 104
assert candidate(12) == 386
| fib4 |
def fib4(n: int):
"""Fib4 সংখ্যাৰ অনুক্ৰমটো হৈছে Fibonacci অনুক্ৰমৰ সৈতে সাদৃশ্য থকা এটা অনুক্ৰম যাক তলত দিয়া ধৰণে সংজ্ঞায়িত কৰা হৈছে:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
অনুগ্ৰহ কৰি fib4 সংখ্যাৰ অনুক্ৰমৰ n-তম উপাদ... |
def fib4(n: int):
"""Fib4 সংখ্যা অনুক্রমটি হলো Fibonacci অনুক্রমের অনুরূপ একটি অনুক্রম যা নিম্নরূপ সংজ্ঞায়িত:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 সংখ্যা অনুক্রমের n-তম উপাদানটি দক্ষতার সাথে গণনা করার জন্য একটি ... |
def fib4(n: int):
"""Fib4 સંખ્યા શ્રેણી એ ફિબોનાકી (Fibonacci) શ્રેણી જેવી જ એક શ્રેણી છે જે નીચે મુજબ વ્યાખ્યાયિત થયેલ છે:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
કૃપા કરીને fib4 સંખ્યા શ્રેણીના n-મા તત્વની કાર્યક્ષમ રી... |
def fib4(n: int):
"""Fib4 संख्या अनुक्रम, Fibonacci अनुक्रम के समान एक अनुक्रम है जिसे निम्नानुसार परिभाषित किया गया है:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
कृपया fib4 संख्या अनुक्रम के n-वें तत्व की कुशलतापूर्वक गणन... |
def fib4(n: int):
"""Fib4 ಸಂಖ್ಯೆಯ ಸರಣಿಯು Fibbonacci ಸರಣಿಯನ್ನು ಹೋಲುವ ಒಂದು ಸರಣಿಯಾಗಿದ್ದು, ಅದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 ಸಂಖ್ಯೆಯ ಸರಣಿಯ n-ನೇ ಎಲಿಮೆಂಟ್ ಅನ್ನು ದಕ್ಷವಾಗಿ ಲೆಕ್ಕಾಚ... |
def fib4(n: int):
"""Fib4 സംഖ്യാ ശ്രേണി എന്നത് Fibonacci ശ്രേണിക്ക് സമാനമായ ഒരു ശ്രേണിയാണ്, അത് താഴെ പറയുന്ന രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 സംഖ്യാ ശ്രേണിയിലെ n-ാമത്തെ എലമെന്റ് ... |
def fib4(n: int):
"""Fib4 संख्या अनुक्रम हा Fibbonacci अनुक्रमासारखाच एक अनुक्रम आहे जो खालीलप्रमाणे परिभाषित केला आहे:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
कृपया fib4 संख्या अनुक्रमाचा n-वा घटक कार्यक्षमतेने काढण्यास... |
def fib4(n: int):
"""Fib4 संख्या अनुक्रम Fibonacci अनुक्रम जस्तै एउटा अनुक्रम हो जसलाई निम्न अनुसार परिभाषित गरिएको छ:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
कृपया fib4 संख्या अनुक्रमको n-औं तत्व कुशलतापूर्वक गणना गर्न ... |
def fib4(n: int):
"""Fib4 ସଂଖ୍ୟା କ୍ରମ ହେଉଛି Fibbonacci କ୍ରମ ସହିତ ସମାନ ଏକ କ୍ରମ ଯାହା ନିମ୍ନଲିଖିତ ଭାବରେ ବ୍ୟାଖ୍ୟା କରାଯାଇଛି:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4)।
fib4 ସଂଖ୍ୟା କ୍ରମର n-ତମ ଉପାଦାନକୁ ଦକ୍ଷତାର ସହିତ ଗଣନା କରିବା ପାଇଁ ... |
def fib4(n: int):
"""Fib4 ਸੰਖਿਆ ਕ੍ਰਮ (number sequence) Fibbonacci ਕ੍ਰਮ ਦੇ ਸਮਾਨ ਇੱਕ ਅਜਿਹਾ ਕ੍ਰਮ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਪਰਿਭਾਸ਼ਿਤ ਹੈ:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
ਕਿਰਪਾ ਕਰਕੇ fib4 ਸੰਖਿਆ ਕ੍ਰਮ ਦੇ n-ਵੇਂ ਐਲੀਮੈਂਟ ਦੀ ... |
def fib4(n: int):
"""Fib4 सङ्ख्याश्रेणी Fibbonacci श्रेण्या सदृशी एका श्रेणी अस्ति या निम्नरूपेण परिभाषिता अस्ति:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 सङ्ख्याश्रेण्याः n-तमं पदं कार्यक्षमरीत्या गणयितुम् एकं फलनं ... |
def fib4(n: int):
"""Fib4 எண் வரிசை என்பது Fibonacci வரிசை போன்ற ஒரு வரிசையாகும், இது பின்வருமாறு வரையறுக்கப்படுகிறது:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 எண் வரிசையின் n-வது உறுப்பைத் திறம்படக் கணக்கிட ஒரு func... |
def fib4(n: int):
"""Fib4 సంఖ్యా శ్రేణి అనేది Fibbonacci శ్రేణిని పోలిన ఒక శ్రేణి, ఇది క్రింది విధంగా నిర్వచించబడింది:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
fib4 సంఖ్యా శ్రేణి యొక్క n-వ మూలకాన్ని సమర్థవంతంగా లెక్కించడా... |
def fib4(n: int):
"""Fib4 نمبر تسلسل ایک ایسا تسلسل ہے جو Fibonacci تسلسل سے مشابہ ہے اور اس کی تعریف درج ذیل کے مطابق کی گئی ہے:
fib4(0) -> 0
fib4(1) -> 0
fib4(2) -> 2
fib4(3) -> 0
fib4(n) -> fib4(n-1) + fib4(n-2) + fib4(n-3) + fib4(n-4).
براہ کرم fib4 نمبر تسلسل کے n-th عنصر کا مؤثر طریق... |
HumanEval/47 |
def median(l: list):
"""Return median of elements in the list l.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
| l = sorted(l)
if len(l) % 2 == 1:
return l[len(l) // 2]
else:
return (l[len(l) // 2 - 1] + l[len(l) // 2]) / 2.0
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == 3
assert candidate([-10, 4, 6, 1000, 10, 20]) == 8.0
assert candidate([5]) == 5
assert candidate([6, 5]) == 5.5
assert candidate([8, 1, 3, 9, 9, 2, 7]) == 7
| median |
def median(l: list):
"""তালিকা l-ৰ উপাদানসমূহৰ মধ্যমা ঘূৰাই দিয়ক।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l তালিকার উপাদানগুলির মধ্যমা রিটার্ন করুন।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""લિસ્ટ l ના ઘટકોનો મધ્યસ્થ પરત કરો.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""सूची l के तत्वों की माध्यिका (median) लौटाएं।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l ಲಿಸ್ಟ್ನಲ್ಲಿರುವ ಅಂಶಗಳ ಮಧ್ಯಾಂಕವನ್ನು (median) ಹಿಂತಿರುಗಿಸಿ.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l എന്ന ലിസ്റ്റിലെ എലമെന്റുകളുടെ മീഡിയൻ നൽകുക.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l या list मधील घटकांचा median परत करा.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""सूची l मा रहेका तत्वहरूको median फर्काउनुहोस्।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""list l ରେ ଥିବା ଉପାଦାନଗୁଡ଼ିକର median ଫେରାନ୍ତୁ।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""ਲਿਸਟ l ਵਿਚਲੇ ਤੱਤਾਂ ਦਾ ਮੀਡੀਅਨ ਵਾਪਸ ਕਰੋ।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l सूच्याः तत्त्वानां माध्यिकां (median) प्रत्यर्पयतु।
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l என்ற list-ல் உள்ள உறுப்புகளின் இடைநிலையை (median) திருப்பியளிக்கவும்.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""l లిస్ట్లోని ఎలిమెంట్ల యొక్క మధ్యగతాన్ని (median) రిటర్న్ చేయండి.
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
def median(l: list):
"""لسٹ l کے عناصر کا میڈین (median) واپس کریں۔
>>> median([3, 1, 2, 4, 5])
3
>>> median([-10, 4, 6, 1000, 10, 20])
15.0
"""
|
HumanEval/48 |
def is_palindrome(text: str):
"""
Checks if given string is a palindrome
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
| for i in range(len(text)):
if text[i] != text[len(text) - 1 - i]:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate('') == True
assert candidate('aba') == True
assert candidate('aaaaa') == True
assert candidate('zbcd') == False
assert candidate('xywyx') == True
assert candidate('xywyz') == False
assert candidate('xywzx') == False
| is_palindrome |
def is_palindrome(text: str):
"""
প্ৰদত্ত ষ্ট্ৰিংটো এটা palindrome হয় নে নহয় পৰীক্ষা কৰে
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
প্রদত্ত স্ট্রিংটি একটি প্যালিনড্রোম কিনা তা পরীক্ষা করে
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
આપેલી સ્ટ્રિંગ પેલિન્ડ્રોમ છે કે નહીં તે તપાસે છે
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
जांच करता है कि क्या दी गई स्ट्रिंग एक पैलिंड्रोम है
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
ಕೊಟ್ಟಿರುವ string ಒಂದು palindrome ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
നൽകിയിരിക്കുന്ന സ്ട്രിംഗ് ഒരു പാലിൻഡ്രോം ആണോ എന്ന് പരിശോധിക്കുന്നു
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
दिलेली स्ट्रिंग पॅलिंड्रोम (palindrome) आहे का ते तपासते
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
दिइएको स्ट्रिङ प्यालिन्ड्रोम हो कि होइन जाँच गर्छ
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
ଦିଆଯାଇଥିବା string ଏକ palindrome କି ନାହିଁ ତାହା ଯାଞ୍ଚ କରେ
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਦਿੱਤੀ ਗਈ string ਇੱਕ palindrome ਹੈ ਜਾਂ ਨਹੀਂ
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
दत्ता string palindrome अस्ति वा इति परीक्षते
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
கொடுக்கப்பட்ட string ஒரு palindrome-ஆ என்பதைச் சரிபார்க்கிறது
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
ఇచ్చిన స్ట్రింగ్ ఒక palindrome అవునో కాదో తనిఖీ చేస్తుంది
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
def is_palindrome(text: str):
"""
چیک کرتا ہے کہ آیا دی گئی سٹرنگ palindrome ہے
>>> is_palindrome('')
True
>>> is_palindrome('aba')
True
>>> is_palindrome('aaaaa')
True
>>> is_palindrome('zbcd')
False
"""
|
HumanEval/49 |
def modp(n: int, p: int):
"""Return 2^n modulo p (be aware of numerics).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
| ret = 1
for i in range(n):
ret = (2 * ret) % p
return ret
|
METADATA = {}
def check(candidate):
assert candidate(3, 5) == 3
assert candidate(1101, 101) == 2
assert candidate(0, 101) == 1
assert candidate(3, 11) == 8
assert candidate(100, 101) == 1
assert candidate(30, 5) == 4
assert candidate(31, 5) == 3
| modp |
def modp(n: int, p: int):
"""2^n modulo p ঘূৰাই দিয়ক (সাংখ্যিক দিশটোৰ প্ৰতি সচেতন থাকক)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p রিটার্ন করুন (নিউমেরিক্স সম্পর্কে সতর্ক থাকুন)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p પરત કરો (ન્યુમેરિક્સનું ધ્યાન રાખો).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p वापस करें (numerics का ध्यान रखें)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ (ಸಂಖ್ಯಾತ್ಮಕ ಅಂಶಗಳ ಬಗ್ಗೆ ಎಚ್ಚರವಿರಲಿ).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p നൽകുക (numerics ശ്രദ്ധിക്കുക).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p परत करा (numerics ची काळजी घ्या).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p फिर्ता गर्नुहोस् (numerics बारे सचेत रहनुहोस्)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p ଫେରାନ୍ତୁ (numerics ପ୍ରତି ଧ୍ୟାନ ଦିଅନ୍ତୁ)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p ਵਾਪਸ ਕਰੋ (ਸੰਖਿਆਤਮਕ ਗਣਨਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖੋ)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p प्रतिददातु (साङ्ख्यिकविषये सावधानाः भवन्तु)।
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p-ஐத் திருப்பியளிக்கவும் (numerics குறித்து கவனமாக இருக்கவும்).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p ను రిటర్న్ చేయండి (న్యూమరిక్స్ పట్ల జాగ్రత్తగా ఉండండి).
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
def modp(n: int, p: int):
"""2^n modulo p واپس کریں (numerics کا خیال رکھیں)۔
>>> modp(3, 5)
3
>>> modp(1101, 101)
2
>>> modp(0, 101)
1
>>> modp(3, 11)
8
>>> modp(100, 101)
1
"""
|
HumanEval/50 |
def encode_shift(s: str):
"""
returns encoded string by shifting every character by 5 in the alphabet.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
takes as input string encoded with encode_shift function. Returns decoded str... | return "".join([chr(((ord(ch) - 5 - ord("a")) % 26) + ord("a")) for ch in s])
|
METADATA = {}
def check(candidate):
from random import randint, choice
import copy
import string
letters = string.ascii_lowercase
for _ in range(100):
str = ''.join(choice(letters) for i in range(randint(10, 20)))
encoded_str = encode_shift(str)
assert candidate(copy.dee... | decode_shift |
def encode_shift(s: str):
"""
বৰ্ণমালাত প্ৰতিটো বৰ্ণক 5 স্থান স্থানান্তৰিত কৰি এনকোড কৰা ষ্ট্ৰিং ঘূৰাই দিয়ে।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ফলনৰ দ্বাৰা এনকোড কৰা এটা ষ্ট্ৰিং ইনপুট হিচাপে লয়। ডিকোড ... |
def encode_shift(s: str):
"""
বর্ণমালায় প্রতিটি অক্ষরকে 5 ঘর শিফট করে এনকোড করা স্ট্রিং রিটার্ন করে।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ফাংশন দ্বারা এনকোড করা স্ট্রিংকে ইনপুট হিসেবে গ্রহণ করে। ডিকোড কর... |
def encode_shift(s: str):
"""
મૂળાક્ષરોમાં દરેક અક્ષરને 5 સ્થાન શિફ્ટ કરીને એન્કોડ કરેલી સ્ટ્રિંગ પરત કરે છે.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
ઇનપુટ તરીકે encode_shift ફંક્શન વડે એન્કોડ કરેલી સ્ટ્રિંગ લે છે. ડીકોડ... |
def encode_shift(s: str):
"""
वर्णमाला में प्रत्येक वर्ण को 5 से शिफ्ट करके एन्कोड की गई स्ट्रिंग लौटाता है।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift फ़ंक्शन द्वारा एन्कोड की गई स्ट्रिंग को इनपुट के रूप में ल... |
def encode_shift(s: str):
"""
ವರ್ಣಮಾಲೆಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವನ್ನು 5 ರಷ್ಟು ಮುಂದಕ್ಕೆ ಶಿಫ್ಟ್ ಮಾಡುವ ಮೂಲಕ ಎನ್ಕೋಡ್ ಮಾಡಲಾದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ಫಂಕ್ಷನ್ನೊಂದಿಗೆ ... |
def encode_shift(s: str):
"""
ആൽഫബെറ്റിലെ ഓരോ അക്ഷരത്തെയും 5 സ്ഥാനങ്ങൾ ഷിഫ്റ്റ് ചെയ്ത് എൻകോഡ് ചെയ്ത സ്ട്രിംഗ് റിട്ടേൺ ചെയ്യുന്നു.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ഫംഗ്ഷൻ ഉപയോഗിച്ച് എൻകോഡ് ചെയ്ത സ്ട്രി... |
def encode_shift(s: str):
"""
वर्णमालेतील प्रत्येक वर्ण ५ ने शिफ्ट करून एन्कोड केलेली स्ट्रिंग परत करते.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift फंक्शनद्वारे एन्कोड केलेली स्ट्रिंग इनपुट म्हणून घेते. डीकोड क... |
def encode_shift(s: str):
"""
वर्णमालामा प्रत्येक क्यारेक्टरलाई 5 ले सारेर इन्कोड गरिएको स्ट्रिङ फर्काउँछ।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift प्रकार्यद्वारा इन्कोड गरिएको स्ट्रिङलाई इनपुटको रूपमा लिन्छ।... |
def encode_shift(s: str):
"""
ବର୍ଣ୍ଣମାଳାରେ ପ୍ରତ୍ୟେକ character କୁ 5 ସ୍ଥାନ shift କରି encode ହୋଇଥିବା string ଫେରାଏ।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ଫଙ୍କସନ୍ ଦ୍ୱାରା encode ହୋଇଥିବା string କୁ input ଭାବରେ ନିଏ... |
def encode_shift(s: str):
"""
ਵਰਣਮਾਲਾ ਵਿੱਚ ਹਰੇਕ character ਨੂੰ 5 ਸਥਾਨ ਸ਼ਿਫਟ ਕਰਕੇ ਇਨਕੋਡ ਕੀਤੀ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ਫੰਕਸ਼ਨ ਨਾਲ ਇਨਕੋਡ ਕੀਤੀ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ।... |
def encode_shift(s: str):
"""
वर्णमालायां प्रत्येकं वर्णं 5 स्थानानि विस्थाप्य कूटबद्धं सूत्रं प्रतिददाति।
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift फलनेन कूटबद्धं सूत्रम् आदानरूपेण स्वीकरोति। विकूटितं सूत्रं ... |
def encode_shift(s: str):
"""
நெடுங்கணக்கில் ஒவ்வொரு எழுத்தையும் 5 இடங்கள் நகர்த்துவதன் மூலம் குறியாக்கம் செய்யப்பட்ட சரத்தைத் திருப்புகிறது.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift சார்பினால் குறியாக்கம் செ... |
def encode_shift(s: str):
"""
వర్ణమాలలో ప్రతి అక్షరాన్ని 5 స్థానాలు షిఫ్ట్ చేయడం ద్వారా ఎన్కోడ్ చేయబడిన స్ట్రింగ్ను రిటర్న్ చేస్తుంది.
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift ఫంక్షన్తో ఎన్కోడ్ చేయబడిన స్... |
def encode_shift(s: str):
"""
حروف تہجی میں ہر کریکٹر کو 5 پوزیشن آگے منتقل کر کے انکوڈ شدہ سٹرنگ واپس کرتا ہے۔
"""
return "".join([chr(((ord(ch) + 5 - ord("a")) % 26) + ord("a")) for ch in s])
def decode_shift(s: str):
"""
encode_shift فنکشن سے انکوڈ شدہ سٹرنگ بطور ان پٹ لیتا ہے۔ ڈی کوڈ شدہ... |
HumanEval/51 |
def remove_vowels(text):
"""
remove_vowels is a function that takes string and returns string without vowels.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaB... | return "".join([s for s in text if s.lower() not in ["a", "e", "i", "o", "u"]])
|
METADATA = {}
def check(candidate):
assert candidate('') == ''
assert candidate("abcdef\nghijklm") == 'bcdf\nghjklm'
assert candidate('fedcba') == 'fdcb'
assert candidate('eeeee') == ''
assert candidate('acBAA') == 'cB'
assert candidate('EcBOO') == 'cB'
assert candidate('ybcd') == 'ybcd'... | remove_vowels |
def remove_vowels(text):
"""
remove_vowels হৈছে এটা ফলন যিয়ে এটা string গ্ৰহণ কৰে আৰু vowels নোহোৱাকৈ string ঘূৰাই দিয়ে।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remov... |
def remove_vowels(text):
"""
remove_vowels হলো একটি ফাংশন যা একটি string গ্রহণ করে এবং vowels ছাড়া string রিটার্ন করে।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vo... |
def remove_vowels(text):
"""
remove_vowels એ એક ફંક્શન છે જે સ્ટ્રિંગ લે છે અને સ્વરો (vowels) વગરની સ્ટ્રિંગ રિટર્ન કરે છે.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> rem... |
def remove_vowels(text):
"""
remove_vowels एक ऐसा फ़ंक्शन है जो एक string लेता है और बिना vowels के string लौटाता है।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vow... |
def remove_vowels(text):
"""
remove_vowels ಎಂಬುದು ಒಂದು string ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಸ್ವರಗಳಿಲ್ಲದ (vowels ಇಲ್ಲದ) string ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದೆ.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels... |
def remove_vowels(text):
"""
remove_vowels എന്നത് ഒരു string സ്വീകരിക്കുകയും vowels ഇല്ലാത്ത string തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷനാണ്.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
... |
def remove_vowels(text):
"""
remove_vowels हे एक फंक्शन आहे जे string घेते आणि vowels नसलेली string परत करते.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('aaB... |
def remove_vowels(text):
"""
remove_vowels एउटा function हो जसले string लिन्छ र vowels बिनाको string फिर्ता गर्छ।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels(... |
def remove_vowels(text):
"""
remove_vowels ହେଉଛି ଏକ function ଯାହା ଏକ string ଗ୍ରହଣ କରେ ଏବଂ vowels ବିନା string ଫେରସ୍ତ କରେ।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_... |
def remove_vowels(text):
"""
remove_vowels ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਇੱਕ string ਲੈਂਦਾ ਹੈ ਅਤੇ ਬਿਨਾਂ vowels ਦੇ string ਵਾਪਸ ਕਰਦਾ ਹੈ।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> r... |
def remove_vowels(text):
"""
remove_vowels इति फलनम् एकं string स्वीकरोति तथा च स्वरवर्णरहितं string प्रतिददाति।
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vowels('... |
def remove_vowels(text):
"""
remove_vowels என்பது ஒரு string-ஐப் பெற்று, உயிரெழுத்துக்கள் (vowels) இல்லாத string-ஐத் திருப்பியளிக்கும் ஒரு function ஆகும்.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowe... |
def remove_vowels(text):
"""
remove_vowels అనేది ఒక స్ట్రింగ్ను తీసుకుని, అచ్చులు (vowels) లేని స్ట్రింగ్ను రిటర్న్ చేసే ఫంక్షన్.
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
... |
def remove_vowels(text):
"""
remove_vowels ایک ایسا فنکشن ہے جو string لیتا ہے اور vowels کے بغیر string واپس کرتا ہے۔
>>> remove_vowels('')
''
>>> remove_vowels("abcdef\nghijklm")
'bcdf\nghjklm'
>>> remove_vowels('abcdef')
'bcdf'
>>> remove_vowels('aaaaa')
''
>>> remove_vo... |
HumanEval/52 |
def below_threshold(l: list, t: int):
"""Return True if all numbers in the list l are below threshold t.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
| for e in l:
if e >= t:
return False
return True
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10], 100)
assert not candidate([1, 20, 4, 10], 5)
assert candidate([1, 20, 4, 10], 21)
assert candidate([1, 20, 4, 10], 22)
assert candidate([1, 8, 4, 10], 11)
assert not candidate([1, 8, 4, 10], 10)
| below_threshold |
def below_threshold(l: list, t: int):
"""যদি তালিকা l-ৰ সকলো সংখ্যা threshold t-তকৈ কম হয় তেন্তে True প্ৰদান কৰক।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""তালিকা l-এর সমস্ত সংখ্যা threshold t-এর নিচে হলে True রিটার্ন করুন।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""જો લિસ્ટ l માં રહેલી તમામ સંખ્યાઓ થ્રેશોલ્ડ t કરતાં ઓછી હોય તો True રિટર્ન કરો.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""यदि सूची l की सभी संख्याएँ थ्रेशोल्ड t से कम हैं, तो True रिटर्न करें।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""l ಪಟ್ಟಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು threshold t ಗಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ True ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""l എന്ന ലിസ്റ്റിലെ എല്ലാ സംഖ്യകളും t എന്ന ത്രെഷോൾഡിനേക്കാൾ കുറവാണെങ്കിൽ True നൽകുക.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""जर list l मधील सर्व संख्या threshold t पेक्षा कमी असतील तर True परत करा.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""यदि सूची l मा भएका सबै संख्याहरू threshold t भन्दा कम छन् भने True फर्काउनुहोस्।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""ଯଦି list l ର ସମସ୍ତ ସଂଖ୍ୟା threshold t ଠାରୁ କମ୍ ହୁଏ ତେବେ True ଫେରାନ୍ତୁ।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""ਜੇਕਰ ਲਿਸਟ l ਵਿਚਲੀਆਂ ਸਾਰੀਆਂ ਸੰਖਿਆਵਾਂ ਥ੍ਰੈਸ਼ਹੋਲਡ t ਤੋਂ ਘੱਟ ਹਨ ਤਾਂ True ਵਾਪਸ ਕਰੋ।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""यदि l सूच्यां सर्वाः सङ्ख्याः देहलीमानात् t न्यूनाः सन्ति तर्हि True प्रत्यानयतु।
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""பட்டியல் l-ல் உள்ள அனைத்து எண்களும் வரம்பு t-ஐ விடக் குறைவாக இருந்தால் True எனத் திருப்பியளிக்கவும்.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""జాబితా l లోని అన్ని సంఖ్యలు threshold t కంటే తక్కువగా ఉంటే True ని రిటర్న్ చేయండి.
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
def below_threshold(l: list, t: int):
"""اگر لسٹ l کے تمام اعداد تھریشولڈ t سے کم ہوں تو True واپس کریں۔
>>> below_threshold([1, 2, 4, 10], 100)
True
>>> below_threshold([1, 20, 4, 10], 5)
False
"""
|
HumanEval/53 |
def add(x: int, y: int):
"""Add two numbers x and y
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
| return x + y
|
METADATA = {}
def check(candidate):
import random
assert candidate(0, 1) == 1
assert candidate(1, 0) == 1
assert candidate(2, 3) == 5
assert candidate(5, 7) == 12
assert candidate(7, 5) == 12
for i in range(100):
x, y = random.randint(0, 1000), random.randint(0, 1000)
a... | add |
def add(x: int, y: int):
"""দুটা সংখ্যা x আৰু y যোগ কৰক
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""দুটি সংখ্যা x এবং y যোগ করুন
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""બે સંખ્યાઓ x અને y નો સરવાળો કરો
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""दो संख्याओं x और y को जोड़ें
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""x ಮತ್ತು y ಎಂಬ ಎರಡು ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿ
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""x, y എന്നീ രണ്ട് സംഖ്യകൾ കൂട്ടുക
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""x आणि y या दोन संख्यांची बेरीज करा
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""दुई संख्याहरू x र y जोड्नुहोस्
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""ଦୁଇଟି ସଂଖ୍ୟା x ଏବଂ y କୁ ଯୋଗ କରନ୍ତୁ
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""ਦੋ ਸੰਖਿਆਵਾਂ x ਅਤੇ y ਨੂੰ ਜੋੜੋ
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""x तथा y इति द्वयोः संख्ययोः योगं कुरुत
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""x மற்றும் y ஆகிய இரண்டு எண்களைக் கூட்டவும்
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""రెండు సంఖ్యలు x మరియు y లను కూడండి
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
def add(x: int, y: int):
"""دو اعداد x اور y کو جمع کریں
>>> add(2, 3)
5
>>> add(5, 7)
12
"""
|
HumanEval/54 |
def same_chars(s0: str, s1: str):
"""
Check if two words have the same characters.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same... | return set(s0) == set(s1)
|
METADATA = {}
def check(candidate):
assert candidate('eabcdzzzz', 'dddzzzzzzzddeddabc') == True
assert candidate('abcd', 'dddddddabc') == True
assert candidate('dddddddabc', 'abcd') == True
assert candidate('eabcd', 'dddddddabc') == False
assert candidate('abcd', 'dddddddabcf') == False
asse... | same_chars |
def same_chars(s0: str, s1: str):
"""
দুটা শব্দত একেবোৰ বৰ্ণ আছে নে নাই পৰীক্ষা কৰক।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> sa... |
def same_chars(s0: str, s1: str):
"""
দুটি শব্দে একই অক্ষর রয়েছে কিনা পরীক্ষা করুন।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> sa... |
def same_chars(s0: str, s1: str):
"""
બે શબ્દોમાં સમાન અક્ષરો છે કે નહીં તે ચકાસો.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> same... |
def same_chars(s0: str, s1: str):
"""
जाँच करें कि क्या दो शब्दों में समान वर्ण हैं।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> sa... |
def same_chars(s0: str, s1: str):
"""
ಎರಡು ಪದಗಳು ಒಂದೇ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
... |
def same_chars(s0: str, s1: str):
"""
രണ്ട് വാക്കുകളിലും ഒരേ അക്ഷരങ്ങൾ ഉണ്ടോ എന്ന് പരിശോധിക്കുക.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
Fals... |
def same_chars(s0: str, s1: str):
"""
दोन शब्दांमध्ये समान अक्षरे आहेत का ते तपासा.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> sam... |
def same_chars(s0: str, s1: str):
"""
दुईवटा शब्दहरूमा समान क्यारेक्टरहरू छन् कि छैनन् भनी जाँच गर्नुहोस्।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc'... |
def same_chars(s0: str, s1: str):
"""
ଦୁଇଟି ଶବ୍ଦରେ ସମାନ ଅକ୍ଷର ରହିଛି କି ନାହିଁ ଯାଞ୍ଚ କରନ୍ତୁ।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
... |
def same_chars(s0: str, s1: str):
"""
ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਦੋ ਸ਼ਬਦਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹੇ ਅੱਖਰ ਹਨ।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> ... |
def same_chars(s0: str, s1: str):
"""
द्वयोः शब्दयोः समानाः वर्णाः सन्ति वा इति परीक्ष्यताम्।
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
... |
def same_chars(s0: str, s1: str):
"""
இரண்டு சொற்கள் ஒரே எழுத்துக்களைக் கொண்டுள்ளனவா என்பதைச் சரிபார்க்கவும்.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'ddddddda... |
def same_chars(s0: str, s1: str):
"""
రెండు పదాలు ఒకే అక్షరాలను కలిగి ఉన్నాయో లేదో తనిఖీ చేయండి.
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
Fals... |
def same_chars(s0: str, s1: str):
"""
چیک کریں کہ آیا دو الفاظ میں ایک جیسے حروف ہیں۔
>>> same_chars('eabcdzzzz', 'dddzzzzzzzddeddabc')
True
>>> same_chars('abcd', 'dddddddabc')
True
>>> same_chars('dddddddabc', 'abcd')
True
>>> same_chars('eabcd', 'dddddddabc')
False
>>> s... |
HumanEval/55 |
def fib(n: int):
"""Return n-th Fibonacci number.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
| if n == 0:
return 0
if n == 1:
return 1
return fib(n - 1) + fib(n - 2)
|
METADATA = {}
def check(candidate):
assert candidate(10) == 55
assert candidate(1) == 1
assert candidate(8) == 21
assert candidate(11) == 89
assert candidate(12) == 144
| fib |
def fib(n: int):
"""n-তম Fibonacci সংখ্যাটো ঘূৰাই দিয়ক।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-তম Fibonacci সংখ্যা রিটার্ন করুন।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-મી Fibonacci સંખ્યા રિટર્ન કરો.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-वीं Fibonacci संख्या लौटाएं।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-ನೇ Fibonacci ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-ാമത്തെ Fibonacci സംഖ്യ നൽകുക.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-वी Fibonacci संख्या परत करा.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-औँ Fibonacci सङ्ख्या फर्काउनुहोस्।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-ତମ Fibonacci ସଂଖ୍ୟା ଫେରାନ୍ତୁ।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-ਵਾਂ Fibonacci ਨੰਬਰ ਵਾਪਸ ਕਰੋ।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-तमां Fibonacci सङ्ख्यां प्रत्यायच्छतु।
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-வது Fibonacci எண்ணைத் திருப்பியளிக்கவும்.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-వ Fibonacci సంఖ్యను రిటర్న్ చేయండి.
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
def fib(n: int):
"""n-واں Fibonacci نمبر واپس کریں۔
>>> fib(10)
55
>>> fib(1)
1
>>> fib(8)
21
"""
|
HumanEval/56 |
def correct_bracketing(brackets: str):
""" brackets is a string of "<" and ">".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bracketin... | depth = 0
for b in brackets:
if b == "<":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("<>")
assert candidate("<<><>>")
assert candidate("<><><<><>><>")
assert candidate("<><><<<><><>><>><<><><<>>>")
assert not candidate("<<<><>>>>")
assert not candidate("><<>")
assert not candidate("<")
assert not candidate("<<<<")
... | correct_bracketing |
def correct_bracketing(brackets: str):
""" brackets হ'ল "<" আৰু ">" ৰ এটা string।
যদি প্ৰতিটো opening bracket-ৰ এটা অনুৰূপ closing bracket থাকে তেন্তে True ৰিটাৰ্ণ কৰক।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> co... |
def correct_bracketing(brackets: str):
""" brackets হলো "<" এবং ">" এর একটি স্ট্রিং।
যদি প্রতিটি ওপেনিং ব্র্যাকেটের একটি সংশ্লিষ্ট ক্লোজিং ব্র্যাকেট থাকে তবে True রিটার্ন করুন।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
... |
def correct_bracketing(brackets: str):
""" brackets એ "<" અને ">" ની એક string છે.
જો દરેક opening bracket માટે અનુરૂપ closing bracket હોય, તો True રિટર્ન કરો.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_bra... |
def correct_bracketing(brackets: str):
""" brackets, "<" और ">" की एक स्ट्रिंग है।
यदि प्रत्येक ओपनिंग ब्रैकेट का एक संगत क्लोजिंग ब्रैकेट है, तो True रिटर्न करें।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct... |
def correct_bracketing(brackets: str):
""" brackets ಎಂಬುದು "<" ಮತ್ತು ">" ಗಳ ಒಂದು string ಆಗಿದೆ.
ಪ್ರತಿಯೊಂದು opening bracket ಗೂ ಅನುಗುಣವಾದ closing bracket ಇದ್ದರೆ True ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
T... |
def correct_bracketing(brackets: str):
""" brackets എന്നത് "<" ഉം ">" ഉം അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് ആണ്.
ഓരോ ഓപ്പണിംഗ് ബ്രാക്കറ്റിനും അനുയോജ്യമായ ക്ലോസിംഗ് ബ്രാക്കറ്റ് ഉണ്ടെങ്കിൽ True നൽകുക.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
... |
def correct_bracketing(brackets: str):
""" brackets ही "<" आणि ">" यांची एक स्ट्रिंग आहे.
प्रत्येक ओपनिंग ब्रॅकेटला संबंधित क्लोजिंग ब्रॅकेट असल्यास True परत करा.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct_... |
def correct_bracketing(brackets: str):
""" brackets "<" र ">" को एउटा string हो।
प्रत्येक opening bracket को सम्बन्धित closing bracket छ भने True return गर्नुहोस्।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correct... |
def correct_bracketing(brackets: str):
""" brackets ହେଉଛି "<" ଏବଂ ">" ର ଏକ string ।
ଯଦି ପ୍ରତ୍ୟେକ opening bracket ର ଏକ ଅନୁରୂପ closing bracket ଥାଏ, ତେବେ True ଫେରାନ୍ତୁ ।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> corr... |
def correct_bracketing(brackets: str):
""" brackets, "<" ਅਤੇ ">" ਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਹੈ।
ਜੇਕਰ ਹਰੇਕ opening bracket ਦਾ ਇੱਕ ਸੰਬੰਧਿਤ closing bracket ਹੋਵੇ ਤਾਂ True ਵਾਪਸ ਕਰੋ।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>>> correc... |
def correct_bracketing(brackets: str):
""" brackets इति "<" तथा ">" इत्यनयोः एका string वर्तते।
यदि प्रत्येकस्य उद्घाटनकोष्ठकस्य सङ्गतं समापनकोष्ठकं वर्तते तर्हि True प्रतिददातु।
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
... |
def correct_bracketing(brackets: str):
""" brackets என்பது "<" மற்றும் ">" ஆகியவற்றைக் கொண்ட ஒரு string ஆகும்.
ஒவ்வொரு திறக்கும் அடைப்புக்குறிக்கும் அதற்குரிய மூடும் அடைப்புக்குறி இருந்தால் True என return செய்யவும்.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> c... |
def correct_bracketing(brackets: str):
""" brackets అనేది "<" మరియు ">" లతో కూడిన స్ట్రింగ్.
ప్రతి opening bracket కు అనుగుణమైన closing bracket ఉంటే True అని రిటర్న్ చేయండి.
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
>... |
def correct_bracketing(brackets: str):
""" brackets ایک سٹرنگ ہے جو "<" اور ">" پر مشتمل ہے۔
اگر ہر کھولنے والی بریکٹ کے لیے ایک متعلقہ بند کرنے والی بریکٹ ہو تو True واپس کریں۔
>>> correct_bracketing("<")
False
>>> correct_bracketing("<>")
True
>>> correct_bracketing("<<><>>")
True
... |
HumanEval/57 |
def monotonic(l: list):
"""Return True is list elements are monotonically increasing or decreasing.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
| if l == sorted(l) or l == sorted(l, reverse=True):
return True
return False
|
METADATA = {}
def check(candidate):
assert candidate([1, 2, 4, 10]) == True
assert candidate([1, 2, 4, 20]) == True
assert candidate([1, 20, 4, 10]) == False
assert candidate([4, 1, 0, -10]) == True
assert candidate([4, 1, 1, 0]) == True
assert candidate([1, 2, 3, 2, 5, 60]) == False
ass... | monotonic |
def monotonic(l: list):
"""যদি তালিকাৰ উপাদানসমূহ monotonically বৃদ্ধিমান বা হ্রাসমান হয় তেন্তে True ৰিটাৰ্ন কৰক।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
| def monotonic(l: list):
"""যদি list-এর উপাদানগুলো ধারাবাহিকভাবে বৃদ্ধি বা হ্রাস পায়, তবে True রিটার্ন করে।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
""" |
def monotonic(l: list):
"""જો સૂચિના તત્વો એકવિધ રીતે વધતા અથવા ઘટતા હોય તો True પરત કરો.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""True लौटाएं यदि list के तत्व monotonically increasing या decreasing हैं।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""ಲಿಸ್ಟ್ನ ಅಂಶಗಳು ಏಕತಾನವಾಗಿ ಹೆಚ್ಚುತ್ತಿದ್ದರೆ ಅಥವಾ ಕಡಿಮೆಯಾಗುತ್ತಿದ್ದರೆ True ಎಂದು ಹಿಂತಿರುಗಿಸಿ.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""ലിസ്റ്റിലെ എലമെന്റുകൾ മോണോടോണിക്കലായി വർദ്ധിക്കുകയോ കുറയുകയോ ചെയ്യുകയാണെങ്കിൽ True നൽകുക.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""जर list चे घटक monotonically वाढत किंवा कमी होत असतील तर True परत करा.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""यदि list का तत्वहरू monotonically बढ्दो वा घट्दो क्रममा छन् भने True फर्काउनुहोस्।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""ଯଦି list ର ଉପାଦାନଗୁଡ଼ିକ monotonically increasing କିମ୍ବା decreasing ହୋଇଥାଏ, ତେବେ True ଫେରାନ୍ତୁ।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""ਜੇਕਰ list ਦੇ ਐਲੀਮੈਂਟ monotonically ਵੱਧ ਰਹੇ ਜਾਂ ਘੱਟ ਰਹੇ ਹਨ ਤਾਂ True ਵਾਪਸ ਕਰੋ।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""यदि सूच्याः तत्त्वानि एकदिष्टरूपेण वर्धमानानि अथवा ह्रासमानानि सन्ति तर्हि True इति प्रत्यानयतु।
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
| def monotonic(l: list):
"""பட்டியலின் உறுப்புகள் ஒரே மாதிரியாக அதிகரிக்கும் அல்லது குறையும் எனில் True எனத் திருப்பியளிக்கவும்.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
""" |
def monotonic(l: list):
"""లిస్ట్లోని ఎలిమెంట్లు మోనోటోనికల్గా పెరుగుతూ లేదా తగ్గుతూ ఉంటే True ని రిటర్న్ చేయండి.
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
def monotonic(l: list):
"""اگر list کے عناصر monotonically increasing یا decreasing ہوں تو True واپس کریں۔
>>> monotonic([1, 2, 4, 20])
True
>>> monotonic([1, 20, 4, 10])
False
>>> monotonic([4, 1, 0, -10])
True
"""
|
HumanEval/58 |
def common(l1: list, l2: list):
"""Return sorted unique common elements for two lists.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
| ret = set()
for e1 in l1:
for e2 in l2:
if e1 == e2:
ret.add(e1)
return sorted(list(ret))
|
METADATA = {}
def check(candidate):
assert candidate([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121]) == [1, 5, 653]
assert candidate([5, 3, 2, 8], [3, 2]) == [2, 3]
assert candidate([4, 3, 2, 8], [3, 2, 4]) == [2, 3, 4]
assert candidate([4, 3, 2, 8], []) == []
| common |
def common(l1: list, l2: list):
"""দুটা তালিকাৰ বাবে ক্ৰমবদ্ধ অনন্য উমৈহতীয়া উপাদানসমূহ ঘূৰাই দিয়ক।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""দুটি list-এর সাজানো অনন্য সাধারণ উপাদানগুলি ফেরত দিন।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""બે લિસ્ટ માટે સૉર્ટ કરેલા અનન્ય સામાન્ય ઘટકો પરત કરો.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""दो सूचियों (lists) के लिए सॉर्ट किए गए अद्वितीय उभयनिष्ठ (unique common) तत्व लौटाएं।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""ಎರಡು ಲಿಸ್ಟ್ಗಳಿಗೆ ವಿಂಗಡಿಸಲಾದ ಅನನ್ಯ ಸಾಮಾನ್ಯ ಅಂಶಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""രണ്ട് ലിസ്റ്റുകളിലെ പൊതുവായ യുണീക് (unique) ഘടകങ്ങളെ ക്രമീകരിച്ച് (sorted) തിരികെ നൽകുക.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""दोन lists मधील सॉर्ट केलेले युनिक सामाईक घटक परत करा.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""दुईवटा सूचीहरूका लागि क्रमबद्ध अद्वितीय साझा तत्वहरू फर्काउनुहोस्।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""ଦୁଇଟି list ପାଇଁ sorted unique ସାଧାରଣ ଉପାଦାନଗୁଡ଼ିକ ଫେରାନ୍ତୁ।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""ਦੋ ਸੂਚੀਆਂ ਲਈ ਕ੍ਰਮਬੱਧ ਵਿਲੱਖਣ ਸਾਂਝੇ ਐਲੀਮੈਂਟ ਵਾਪਸ ਕਰੋ।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""द्वयोः सूच्योः कृते क्रमबद्धान् अद्वितीय-उभयनिष्ठ-अवयवान् प्रत्यर्पयतु।
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""இரண்டு பட்டியல்களுக்குமான வரிசைப்படுத்தப்பட்ட தனித்துவமான பொதுவான உறுப்புகளைத் திருப்பியளிக்கவும்.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""రెండు లిస్ట్లలోని సార్ట్ చేయబడిన ప్రత్యేక ఉమ్మడి మూలకాలను రిటర్న్ చేయండి.
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
def common(l1: list, l2: list):
"""دو فہرستوں کے لیے ترتیب شدہ منفرد مشترکہ عناصر واپس کریں۔
>>> common([1, 4, 3, 34, 653, 2, 5], [5, 7, 1, 5, 9, 653, 121])
[1, 5, 653]
>>> common([5, 3, 2, 8], [3, 2])
[2, 3]
"""
|
HumanEval/59 |
def largest_prime_factor(n: int):
"""Return the largest prime factor of n. Assume n > 1 and is not a prime.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
| def is_prime(k):
if k < 2:
return False
for i in range(2, k - 1):
if k % i == 0:
return False
return True
largest = 1
for j in range(2, n + 1):
if n % j == 0 and is_prime(j):
largest = max(largest, j)
return largest
|
METADATA = {}
def check(candidate):
assert candidate(15) == 5
assert candidate(27) == 3
assert candidate(63) == 7
assert candidate(330) == 11
assert candidate(13195) == 29
| largest_prime_factor |
def largest_prime_factor(n: int):
"""n-ৰ বৃহত্তম মৌলিক উৎপাদকটো ঘূৰাই দিয়ক। ধৰি লওক n > 1 আৰু ই এটা মৌলিক সংখ্যা নহয়।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n-এর বৃহত্তম মৌলিক উৎপাদক রিটার্ন করুন। ধরে নিন n > 1 এবং এটি মৌলিক সংখ্যা নয়।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n નો સૌથી મોટો અવિભાજ્ય અવયવ પરત કરો. ધારો કે n > 1 છે અને તે અવિભાજ્ય નથી.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n का सबसे बड़ा prime factor लौटाएं। मान लें कि n > 1 है और यह prime नहीं है।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n ನ ಅತ್ಯಂತ ದೊಡ್ಡ ಅವಿಭಾಜ್ಯ ಅಪವರ್ತನವನ್ನು ಹಿಂತಿರುಗಿಸಿ. n > 1 ಮತ್ತು ಅದು ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಯಲ್ಲ ಎಂದು ಊಹಿಸಿ.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n-ന്റെ ഏറ്റവും വലിയ prime factor തിരികെ നൽകുക. n > 1 ആണെന്നും prime അല്ലെന്നും കരുതുക.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n चा सर्वात मोठा मूळ अवयव परत करा. गृहीत धरा की n > 1 आहे आणि ती मूळ संख्या नाही.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n को सबैभन्दा ठूलो prime factor फर्काउनुहोस्। मान्नुहोस् n > 1 र यो prime होइन।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n ର ସବୁଠାରୁ ବୃହତ୍ତମ ମୌଳିକ ଗୁଣନୀୟକ ଫେରାନ୍ତୁ। ଧରିନିଅନ୍ତୁ n > 1 ଏବଂ ଏହା ଏକ ମୌଳିକ ସଂଖ୍ୟା ନୁହେଁ।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n ਦਾ ਸਭ ਤੋਂ ਵੱਡਾ ਅਭਾਜ ਗੁਣਨਖੰਡ ਵਾਪਸ ਕਰੋ। ਮੰਨ ਲਓ n > 1 ਹੈ ਅਤੇ ਇਹ ਅਭਾਜ ਸੰਖਿਆ ਨਹੀਂ ਹੈ।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n इत्यस्य बृहत्तमम् अविभाज्यगुणनखण्डं प्रत्यर्पयतु। मन्यतां यत् n > 1 तथा च एषा अविभाज्यसंख्या नास्ति।
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n-இன் மிகப்பெரிய பகா காரணியைத் திருப்பியளிக்கவும். n > 1 மற்றும் அது ஒரு பகா எண் அல்ல எனக் கொள்க.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n యొక్క అతిపెద్ద ప్రధాన కారణాంకాన్ని రిటర్న్ చేయండి. n > 1 మరియు అది ప్రధాన సంఖ్య కాదని భావించండి.
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
def largest_prime_factor(n: int):
"""n کا سب سے بڑا prime factor واپس کریں۔ فرض کریں کہ n > 1 ہے اور یہ prime نہیں ہے۔
>>> largest_prime_factor(13195)
29
>>> largest_prime_factor(2048)
2
"""
|
HumanEval/60 |
def sum_to_n(n: int):
"""sum_to_n is a function that sums numbers from 1 to n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
| return sum(range(n + 1))
|
METADATA = {}
def check(candidate):
assert candidate(1) == 1
assert candidate(6) == 21
assert candidate(11) == 66
assert candidate(30) == 465
assert candidate(100) == 5050
| sum_to_n |
def sum_to_n(n: int):
"""sum_to_n হৈছে এনে এটা ফলন যিয়ে 1-ৰ পৰা n-লৈ সংখ্যাবোৰ যোগ কৰে।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n হলো একটি ফাংশন যা 1 থেকে n পর্যন্ত সংখ্যাগুলোর যোগফল নির্ণয় করে।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n એ એક ફંક્શન છે જે 1 થી n સુધીની સંખ્યાઓનો સરવાળો કરે છે.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n एक फ़ंक्शन है जो 1 से n तक की संख्याओं का योग करता है।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n ಎಂಬುದು 1 ರಿಂದ n ವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಕೂಡಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ಆಗಿದೆ.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""1 മുതൽ n വരെയുള്ള സംഖ്യകൾ കൂട്ടുന്ന ഒരു ഫംഗ്ഷനാണ് sum_to_n.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n हे एक फंक्शन आहे जे 1 पासून n पर्यंतच्या संख्यांची बेरीज करते.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n एउटा function हो जसले 1 देखि n सम्मका संख्याहरू जोड्छ।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n ହେଉଛି ଏକ ଫଙ୍କସନ୍ ଯାହା 1 ରୁ n ପର୍ଯ୍ୟନ୍ତ ସଂଖ୍ୟାଗୁଡ଼ିକର ଯୋଗଫଳ ନିର୍ଣ୍ଣୟ କରେ।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜੋ 1 ਤੋਂ n ਤੱਕ ਦੀਆਂ ਸੰਖਿਆਵਾਂ ਦਾ ਜੋੜ ਕਰਦਾ ਹੈ।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n इति फलनं 1 तः n पर्यन्तं सङ्ख्यानां योगं करोति।
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n என்பது 1 முதல் n வரையிலான எண்களைக் கூட்டும் ஒரு சார்பு ஆகும்.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n అనేది 1 నుండి n వరకు ఉన్న సంఖ్యలను కూడే ఒక ఫంక్షన్.
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
def sum_to_n(n: int):
"""sum_to_n ایک فنکشن ہے جو 1 سے n تک کے اعداد کو جمع کرتا ہے۔
>>> sum_to_n(30)
465
>>> sum_to_n(100)
5050
>>> sum_to_n(5)
15
>>> sum_to_n(10)
55
>>> sum_to_n(1)
1
"""
|
HumanEval/61 |
def correct_bracketing(brackets: str):
""" brackets is a string of "(" and ")".
return True if every opening bracket has a corresponding closing bracket.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_bracketin... | depth = 0
for b in brackets:
if b == "(":
depth += 1
else:
depth -= 1
if depth < 0:
return False
return depth == 0
|
METADATA = {}
def check(candidate):
assert candidate("()")
assert candidate("(()())")
assert candidate("()()(()())()")
assert candidate("()()((()()())())(()()(()))")
assert not candidate("((()())))")
assert not candidate(")(()")
assert not candidate("(")
assert not candidate("((((")
... | correct_bracketing |
def correct_bracketing(brackets: str):
""" brackets হৈছে "(" আৰু ")" ৰ এটা ষ্ট্ৰিং।
যদি প্ৰতিটো opening bracket-ৰ এটা সংশ্লিষ্ট closing bracket থাকে তেন্তে True ৰিটাৰ্ণ কৰক।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>... |
def correct_bracketing(brackets: str):
""" brackets হলো "(" এবং ")" এর একটি string।
প্রতিটি opening bracket-এর একটি সংশ্লিষ্ট closing bracket থাকলে True রিটার্ন করুন।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> corr... |
def correct_bracketing(brackets: str):
""" brackets એ "(" અને ")" ની string છે.
જો દરેક opening bracket પાસે તેને અનુરૂપ closing bracket હોય તો True રીટર્ન કરો.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_br... |
def correct_bracketing(brackets: str):
""" brackets, "(" और ")" की एक स्ट्रिंग है।
यदि प्रत्येक opening bracket का एक संगत closing bracket है, तो True रिटर्न करें।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct... |
def correct_bracketing(brackets: str):
""" brackets ಎಂಬುದು "(" ಮತ್ತು ")" ಗಳ ಒಂದು string ಆಗಿದೆ.
ಪ್ರತಿಯೊಂದು opening bracket ಗೆ ಅನುಗುಣವಾದ closing bracket ಇದ್ದರೆ True ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಿ.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
T... |
def correct_bracketing(brackets: str):
""" brackets എന്നത് "(", ")" എന്നിവ അടങ്ങിയ ഒരു സ്ട്രിംഗ് ആണ്.
ഓരോ opening bracket-നും അനുയോജ്യമായ closing bracket ഉണ്ടെങ്കിൽ True റിട്ടേൺ ചെയ്യുക.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
... |
def correct_bracketing(brackets: str):
""" brackets ही "(" आणि ")" यांची स्ट्रिंग आहे.
प्रत्येक opening bracket ला संबंधित closing bracket असल्यास True परत करा.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct_br... |
def correct_bracketing(brackets: str):
""" brackets "(" र ")" को एउटा string हो।
प्रत्येक opening bracket को सम्बन्धित closing bracket छ भने True रिटर्न गर्नुहोस्।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct... |
def correct_bracketing(brackets: str):
""" brackets ହେଉଛି "(" ଏବଂ ")" ର ଏକ string ।
ଯଦି ପ୍ରତ୍ୟେକ opening bracket ର ଏକ ଅନୁରୂପ closing bracket ଥାଏ ତେବେ True ଫେରାନ୍ତୁ।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correc... |
def correct_bracketing(brackets: str):
""" brackets "(" ਅਤੇ ")" ਦੀ ਇੱਕ string ਹੈ।
ਜੇਕਰ ਹਰੇਕ opening bracket ਲਈ ਇੱਕ ਸੰਬੰਧਿਤ closing bracket ਹੋਵੇ ਤਾਂ True ਰਿਟਰਨ ਕਰੋ।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct... |
def correct_bracketing(brackets: str):
""" brackets इति "(" तथा ")" इत्येतयोः string अस्ति।
यदि प्रत्येकस्य उद्घाटककोष्ठकस्य अनुरूपः निमीलककोष्ठकः अस्ति, तर्हि True इति प्रत्याययतु।
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
Tr... | def correct_bracketing(brackets: str):
""" brackets என்பது "(" மற்றும் ")" ஆகியவற்றைக் கொண்ட ஒரு சரம் ஆகும்.
ஒவ்வொரு திறப்பு அடைப்புக்குறிக்கும் அதற்கான மூடும் அடைப்புக்குறி இருந்தால் சரி என திருப்பியளிக்கவும்.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_... |
def correct_bracketing(brackets: str):
""" brackets అనేది "(" మరియు ")" ల యొక్క string.
ప్రతి opening bracket కు సంబంధిత closing bracket ఉంటే True ని return చేయండి.
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correc... |
def correct_bracketing(brackets: str):
""" brackets، "(" اور ")" پر مشتمل ایک اسٹرنگ ہے۔
اگر ہر opening bracket کا ایک متعلقہ closing bracket ہو تو True واپس کریں۔
>>> correct_bracketing("(")
False
>>> correct_bracketing("()")
True
>>> correct_bracketing("(()())")
True
>>> correct... |
HumanEval/62 |
def derivative(xs: list):
""" xs represent coefficients of a polynomial.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
Return derivative of this polynomial in the same form.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
| return [(i * x) for i, x in enumerate(xs)][1:]
|
METADATA = {}
def check(candidate):
assert candidate([3, 1, 2, 4, 5]) == [1, 4, 12, 20]
assert candidate([1, 2, 3]) == [2, 6]
assert candidate([3, 2, 1]) == [2, 2]
assert candidate([3, 2, 1, 0, 4]) == [2, 2, 0, 16]
assert candidate([1]) == []
| derivative |
def derivative(xs: list):
""" xs-এ এটা বহুপদৰ সহগসমূহ প্ৰতিনিধিত্ব কৰে।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
এই বহুপদৰ derivative একে ৰূপত ঘূৰাই দিয়ক।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs একটি বহুপদীর সহগসমূহ উপস্থাপন করে।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
এই বহুপদীর অন্তরজ (derivative) একই আকারে রিটার্ন করুন।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs એ બહુપદીના સહગુણકો દર્શાવે છે.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
આ બહુપદીનું વિકલન (derivative) તે જ સ્વરૂપમાં પરત કરો.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs एक बहुपद (polynomial) के गुणांकों (coefficients) को दर्शाते हैं।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
इस बहुपद का अवकलज (derivative) उसी रूप में वापस करें।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs ಒಂದು ಬಹುಪದೋಕ್ತಿಯ (polynomial) ಗುಣಾಂಕಗಳನ್ನು (coefficients) ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
ಈ ಬಹುಪದೋಕ್ತಿಯ derivative ಅನ್ನು ಅದೇ ರೂಪದಲ್ಲಿ ರಿಟರ್ನ್ ಮಾಡಿ.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
... |
def derivative(xs: list):
""" xs ഒരു പോളിനോമിയലിന്റെ ഗുണകങ്ങളെ (coefficients) പ്രതിനിധീകരിക്കുന്നു.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
ഈ പോളിനോമിയലിന്റെ ഡെറിവേറ്റീവ് അതേ രൂപത്തിൽ നൽകുക.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs हे बहुपदीचे सहगुणक दर्शवतात.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
या बहुपदीचे डेरिव्हेटिव्ह त्याच स्वरूपात परत करा.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs ले बहुपदका गुणांकहरूलाई प्रतिनिधित्व गर्दछ।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
यस बहुपदको derivative लाई सोही रूपमा फिर्ता गर्नुहोस्।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs ଏକ polynomial ର coefficients କୁ ପ୍ରତିନିଧିତ୍ୱ କରେ।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
ଏହି polynomial ର derivative କୁ ସମାନ ଫର୍ମରେ ଫେରାନ୍ତୁ।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs ਇੱਕ polynomial ਦੇ coefficients ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
ਇਸ polynomial ਦਾ derivative ਇਸੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰੋ।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs एकस्य बहुपदस्य गुणकान् सूचयति।
xs[0] + xs[1] * x + xs[2] * x^2 + ....
अस्य बहुपदस्य अवकलजं तस्मिन्नेव रूपे प्रतिददातु।
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs என்பது ஒரு பல்லுறுப்புக் கோவையின் கெழுக்களைக் குறிக்கிறது.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
இந்த பல்லுறுப்புக் கோவையின் வகையீட்டை (derivative) அதே வடிவில் திருப்பியளிக்கவும்.
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2... |
def derivative(xs: list):
""" xs ఒక బహుపది యొక్క గుణకాలను సూచిస్తుంది.
xs[0] + xs[1] * x + xs[2] * x^2 + ....
ఈ బహుపది యొక్క derivative ను అదే రూపంలో తిరిగి ఇవ్వండి (return చేయండి).
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
def derivative(xs: list):
""" xs کسی کثیر رقمی (polynomial) کے coefficients کو ظاہر کرتا ہے۔
xs[0] + xs[1] * x + xs[2] * x^2 + ....
اسی شکل میں اس کثیر رقمی کا derivative واپس کریں۔
>>> derivative([3, 1, 2, 4, 5])
[1, 4, 12, 20]
>>> derivative([1, 2, 3])
[2, 6]
"""
|
HumanEval/63 |
def fibfib(n: int):
"""The FibFib number sequence is a sequence similar to the Fibbonacci sequnece that's defined as follows:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
Please write a function to efficiently compute the n-th element of th... | if n == 0:
return 0
if n == 1:
return 0
if n == 2:
return 1
return fibfib(n - 1) + fibfib(n - 2) + fibfib(n - 3)
|
METADATA = {}
def check(candidate):
assert candidate(2) == 1
assert candidate(1) == 0
assert candidate(5) == 4
assert candidate(8) == 24
assert candidate(10) == 81
assert candidate(12) == 274
assert candidate(14) == 927
| fibfib |
def fibfib(n: int):
"""FibFib সংখ্যা অনুক্ৰম হৈছে Fibbonacci অনুক্ৰমৰ দৰেই এক অনুক্ৰম যাক তলত দিয়া ধৰণে সংজ্ঞায়িত কৰা হৈছে:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3)।
অনুগ্ৰহ কৰি fibfib সংখ্যা অনুক্ৰমৰ n-তম উপাদানটো কাৰ্যক্ষমভাৱে গণনা ক... |
def fibfib(n: int):
"""FibFib সংখ্যা অনুক্রম হলো ফিবোনাচ্চি অনুক্রমের মতো একটি অনুক্রম যা নিম্নরূপ সংজ্ঞায়িত:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
অনুগ্রহ করে fibfib সংখ্যা অনুক্রমের n-তম উপাদানটি দক্ষতার সাথে গণনা করার জন্য একটি ফ... |
def fibfib(n: int):
"""FibFib નંબર ક્રમ એ Fibbonacci ક્રમ જેવો જ એક ક્રમ છે જે નીચે મુજબ વ્યાખ્યાયિત થયેલ છે:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib નંબર ક્રમના n-મા ઘટકની કાર્યક્ષમ રીતે ગણતરી કરવા માટે કૃપા કરીને એક ફંક્શન લખો... |
def fibfib(n: int):
"""FibFib संख्या अनुक्रम, Fibonacci अनुक्रम के समान एक अनुक्रम है जिसे निम्नानुसार परिभाषित किया गया है:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib संख्या अनुक्रम के n-वें तत्व की कुशलतापूर्वक गणना करने के लिए क... |
def fibfib(n: int):
"""FibFib ಸಂಖ್ಯಾ ಸರಣಿಯು Fibonacci ಸರಣಿಯಂತೆಯೇ ಇರುವ ಒಂದು ಸರಣಿಯಾಗಿದ್ದು, ಅದನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib ಸಂಖ್ಯಾ ಸರಣಿಯ n-ನೇ ಅಂಶವನ್ನು ದಕ್ಷವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ದಯವಿಟ್ಟು ... |
def fibfib(n: int):
"""Fibbonacci ശ്രേണിക്ക് സമാനമായ ഒരു സംഖ്യാ ശ്രേണിയാണ് FibFib സംഖ്യാ ശ്രേണി, അത് താഴെ പറയുന്ന രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib സംഖ്യാ ശ്രേണിയിലെ n-ാമത്തെ എലമെന്റ് കാര്യക്ഷ... |
def fibfib(n: int):
"""FibFib संख्या क्रम (number sequence) हा Fibbonacci क्रमासारखाच एक क्रम आहे, जो खालीलप्रमाणे परिभाषित केला आहे:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
कृपया fibfib संख्या क्रमाचा n-वा घटक कार्यक्षमतेने मोजण्यासाठ... |
def fibfib(n: int):
"""FibFib सङ्ख्या अनुक्रम Fibonacci अनुक्रम जस्तै एउटा अनुक्रम हो जसलाई निम्न अनुसार परिभाषित गरिएको छ:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
कृपया fibfib सङ्ख्या अनुक्रमको n-औँ तत्व कुशलतापूर्वक गणना गर्न एउटा fu... |
def fibfib(n: int):
"""FibFib ସଂଖ୍ୟା କ୍ରମ ହେଉଛି Fibonacci କ୍ରମ ସଦୃଶ ଏକ କ୍ରମ ଯାହା ନିମ୍ନ ପ୍ରକାରେ ପରିଭାଷିତ:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib ସଂଖ୍ୟା କ୍ରମର n-ତମ ଉପାଦାନକୁ ଦକ୍ଷତାର ସହିତ ଗଣନା କରିବା ପାଇଁ ଦୟାକରି ଏକ function ଲେଖନ୍ତୁ।... |
def fibfib(n: int):
"""FibFib ਸੰਖਿਆ ਲੜੀ Fibbonacci ਲੜੀ ਦੇ ਸਮਾਨ ਇੱਕ ਲੜੀ ਹੈ ਜੋ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਪਰਿਭਾਸ਼ਿਤ ਹੈ:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
ਕਿਰਪਾ ਕਰਕੇ fibfib ਸੰਖਿਆ ਲੜੀ ਦੇ n-ਵੇਂ ਤੱਤ ਦੀ ਕੁਸ਼ਲਤਾ ਨਾਲ ਗਣਨਾ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ।
... |
def fibfib(n: int):
"""FibFib सङ्ख्याश्रेणी Fibbonacci श्रेण्याः सदृशी एका श्रेणी वर्तते या निम्नरूपेण परिभाषिता अस्ति:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
कृपया fibfib सङ्ख्याश्रेण्याः n-तमं तत्त्वं कार्यक्षमतया गणयितुम् एकं फलनं ... |
def fibfib(n: int):
"""FibFib எண் வரிசை என்பது Fibbonacci வரிசையைப் போன்ற ஒரு வரிசையாகும், இது பின்வருமாறு வரையறுக்கப்படுகிறது:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib எண் வரிசையின் n-வது உறுப்பைத் திறமையாகக் கணக்கிட ஒரு functio... |
def fibfib(n: int):
"""FibFib సంఖ్యా శ్రేణి అనేది Fibbonacci శ్రేణిని పోలిన ఒక శ్రేణి, ఇది క్రింది విధంగా నిర్వచించబడింది:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
fibfib సంఖ్యా శ్రేణి యొక్క n-వ మూలకాన్ని సమర్థవంతంగా లెక్కించడానికి దయచే... |
def fibfib(n: int):
"""FibFib نمبروں کا تسلسل Fibonacci تسلسل کی طرح کا ایک تسلسل ہے جس کی تعریف درج ذیل طریقے سے کی گئی ہے:
fibfib(0) == 0
fibfib(1) == 0
fibfib(2) == 1
fibfib(n) == fibfib(n-1) + fibfib(n-2) + fibfib(n-3).
براہ کرم fibfib نمبر تسلسل کے n-ویں عنصر کا مؤثر طریقے سے حساب لگانے ک... |
HumanEval/64 |
FIX = """
Add more test cases.
"""
def vowels_count(s):
"""Write a function vowels_count which takes a string representing
a word as input and returns the number of vowels in the string.
Vowels in this case are 'a', 'e', 'i', 'o', 'u'. Here, 'y' is also a
vowel, but only when it is at the end of the g... | vowels = "aeiouAEIOU"
n_vowels = sum(c in vowels for c in s)
if s[-1] == 'y' or s[-1] == 'Y':
n_vowels += 1
return n_vowels
| def check(candidate):
# Check some simple cases
assert candidate("abcde") == 2, "Test 1"
assert candidate("Alone") == 3, "Test 2"
assert candidate("key") == 2, "Test 3"
assert candidate("bye") == 1, "Test 4"
assert candidate("keY") == 2, "Test 5"
assert candidate("bYe") == 1, "Test 6"
a... | vowels_count |
FIX = """
অধিক টেষ্ট কেছ যোগ কৰক।
"""
def vowels_count(s):
"""এটা শব্দক প্ৰতিনিধিত্ব কৰা এটা ষ্ট্ৰিং ইনপুট হিচাপে গ্ৰহণ কৰা আৰু ষ্ট্ৰিংটোত থকা স্বৰবৰ্ণ (vowels) ৰ সংখ্যা ঘূৰাই দিয়া vowels_count নামৰ এটা ফলন লিখক।
এই ক্ষেত্ৰত স্বৰবৰ্ণসমূহ হ'ল 'a', 'e', 'i', 'o', 'u'। ইয়াত, 'y' ও এটা
স্বৰবৰ্ণ, কিন্তু কেৱল... |
FIX = """
আরও টেস্ট কেস যোগ করুন।
"""
def vowels_count(s):
"""একটি ফাংশন vowels_count লিখুন যা একটি শব্দ নির্দেশকারী একটি string
ইনপুট হিসেবে গ্রহণ করে এবং string-টিতে থাকা vowel-এর সংখ্যা রিটার্ন করে।
এক্ষেত্রে vowel গুলি হলো 'a', 'e', 'i', 'o', 'u'। এখানে, 'y'-ও একটি
vowel, তবে শুধুমাত্র তখনই যখন এট... |
FIX = """
વધુ ટેસ્ટ કેસો ઉમેરો.
"""
def vowels_count(s):
"""એક ફંક્શન vowels_count લખો જે ઇનપુટ તરીકે એક શબ્દ દર્શાવતી સ્ટ્રિંગ લે છે અને સ્ટ્રિંગમાં રહેલા સ્વરોની સંખ્યા પાછી આપે છે.
આ કિસ્સામાં સ્વરો 'a', 'e', 'i', 'o', 'u' છે. અહીં, 'y' પણ એક
સ્વર છે, પરંતુ માત્ર ત્યારે જ જ્યારે તે આપેલા શબ્દના અંતમાં ... |
FIX = """
और अधिक टेस्ट केस जोड़ें।
"""
def vowels_count(s):
"""एक फ़ंक्शन vowels_count लिखें जो इनपुट के रूप में एक शब्द को दर्शाने वाली स्ट्रिंग
लेता है और स्ट्रिंग में स्वरों (vowels) की संख्या लौटाता है।
इस मामले में स्वर 'a', 'e', 'i', 'o', 'u' हैं। यहाँ, 'y' भी एक
स्वर है, लेकिन केवल तब जब यह दि... |
FIX = """
ಇನ್ನಷ್ಟು ಪರೀಕ್ಷಾ ಕೇಸ್ಗಳನ್ನು ಸೇರಿಸಿ.
"""
def vowels_count(s):
"""ಒಂದು ಪದವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಂಡು ಮತ್ತು ಆ ಸ್ಟ್ರಿಂಗ್ನಲ್ಲಿರುವ ಸ್ವರಗಳ (vowels) ಸಂಖ್ಯೆಯನ್ನು ರಿಟರ್ನ್ ಮಾಡುವ vowels_count ಎಂಬ ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ.
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ವರಗಳು 'a', 'e', 'i', 'o', 'u' ಆಗಿವೆ. ಇಲ್ಲಿ, 'y' ಕ... |
FIX = """
കൂടുതൽ ടെസ്റ്റ് കേസുകൾ ചേർക്കുക.
"""
def vowels_count(s):
"""ഒരു വാക്കിനെ പ്രതിനിധീകരിക്കുന്ന ഒരു സ്ട്രിംഗ് ഇൻപുട്ടായി സ്വീകരിക്കുകയും, ആ സ്ട്രിംഗിലെ
സ്വരാക്ഷരങ്ങളുടെ (vowels) എണ്ണം നൽകുകയും ചെയ്യുന്ന vowels_count എന്നൊരു ഫംഗ്ഷൻ എഴുതുക.
ഇവിടെ 'a', 'e', 'i', 'o', 'u' എന്നിവയാണ് സ്വരാക്ഷരങ്ങൾ. തന്... |
FIX = """
अधिक टेस्ट केसेस जोडा.
"""
def vowels_count(s):
"""vowels_count हे फंक्शन लिहा जे इनपुट म्हणून एका शब्दाचे प्रतिनिधित्व करणारी
स्ट्रिंग घेते आणि त्या स्ट्रिंगमधील स्वरांची संख्या परत करते.
या बाबतीत स्वर 'a', 'e', 'i', 'o', 'u' हे आहेत. येथे, 'y' देखील एक
स्वर आहे, परंतु केवळ तेव्हाच जेव्हा ... |
FIX = """
थप test case हरू थप्नुहोस्।
"""
def vowels_count(s):
"""एउटा प्रकार्य (function) vowels_count लेख्नुहोस् जसले एउटा शब्दलाई प्रतिनिधित्व गर्ने
string इनपुटको रूपमा लिन्छ र string मा रहेका vowel हरूको संख्या फर्काउँछ।
यस अवस्थामा vowel हरू 'a', 'e', 'i', 'o', 'u' हुन्। यहाँ, 'y' पनि एउटा
vowel... |
FIX = """
ଅଧିକ ଟେଷ୍ଟ କେସ୍ ଯୋଗ କରନ୍ତୁ।
"""
def vowels_count(s):
"""vowels_count ନାମକ ଏକ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ ଯାହା ଏକ ଶବ୍ଦକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ string କୁ
ଇନପୁଟ୍ ଭାବରେ ଗ୍ରହଣ କରେ ଏବଂ string ରେ ଥିବା vowels ର ସଂଖ୍ୟା ଫେରାଏ।
ଏହି କ୍ଷେତ୍ରରେ vowels ହେଉଛି 'a', 'e', 'i', 'o', 'u'। ଏଠାରେ, 'y' ମଧ୍ୟ ଏକ
vowel, କିନ୍ତୁ ... |
FIX = """
ਹੋਰ ਟੈਸਟ ਕੇਸ ਸ਼ਾਮਲ ਕਰੋ।
"""
def vowels_count(s):
"""ਇੱਕ ਫੰਕਸ਼ਨ vowels_count ਲਿਖੋ ਜੋ ਇੱਕ ਸ਼ਬਦ ਨੂੰ ਦਰਸਾਉਂਦੀ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇਨਪੁਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ
ਅਤੇ ਸਟ੍ਰਿੰਗ ਵਿੱਚ vowels ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਇਸ ਕੇਸ ਵਿੱਚ vowels 'a', 'e', 'i', 'o', 'u' ਹਨ। ਇੱਥੇ, 'y' ਵੀ ਇੱਕ
vowel ਹੈ, ਪਰ ਸਿਰਫ਼ ਉਦੋਂ ਜਦੋਂ ਇਹ ਦਿੱਤੇ ਗਏ ਸ਼... |
FIX = """
अधिकानि परीक्षणप्रकरणाणि योजयन्तु।
"""
def vowels_count(s):
"""vowels_count इति फलनं लिखन्तु यत् एकं पदं सूचयन्तीं string
निवेशरूपेण गृह्णाति तथा च string मध्ये विद्यमानानां स्वराणां सङ्ख्यां प्रतिददाति।
अस्मिन् सन्दर्भे स्वराः 'a', 'e', 'i', 'o', 'u' सन्ति। अत्र 'y' अपि
स्वरः अस्ति, किन्तु ... | FIX = """
கூடுதல் சோதனை வழக்குகளைச் சேர்க்கவும்.
"""
def vowels_count(s):
""" ஒரு வார்த்தையைக் குறிக்கும் சரத்தை உள்ளீடாகப் பெற்று, அந்த சரத்தில் உள்ள உயிரெழுத்துக்களின் எண்ணிக்கையைத் திருப்பியளிக்கும் vowels_count எனும் சார்பை எழுதவும்.
இந்த நிகழ்வில் உயிரெழுத்துகள் என்பவை 'a', 'e', 'i', 'o', 'u' ஆகும். இங்கே... |
FIX = """
మరిన్ని టెస్ట్ కేసులను జోడించండి.
"""
def vowels_count(s):
"""ఒక పదాన్ని సూచించే స్ట్రింగ్ను ఇన్పుట్గా తీసుకుని, ఆ స్ట్రింగ్లోని అచ్చుల (vowels) సంఖ్యను
తిరిగి ఇచ్చే vowels_count అనే ఫంక్షన్ను రాయండి.
ఈ సందర్భంలో అచ్చులు 'a', 'e', 'i', 'o', 'u'. ఇక్కడ, 'y' కూడా ఒక
అచ్చు అవుతుంది, కానీ అ... |
FIX = """
مزید ٹیسٹ کیسز شامل کریں۔
"""
def vowels_count(s):
"""ایک فنکشن vowels_count لکھیں جو ان پٹ کے طور پر ایک لفظ کی نمائندگی کرنے والی
سٹرنگ لیتا ہے اور سٹرنگ میں vowels کی تعداد واپس کرتا ہے۔
اس معاملے میں vowels 'a' ،'e' ،'i' ،'o' ،'u' ہیں۔ یہاں، 'y' بھی ایک
vowel ہے، لیکن صرف تب جب یہ دیے گئ... |
HumanEval/65 |
def circular_shift(x, shift):
"""Circular shift the digits of the integer x, shift the digits right by shift
and return the result as a string.
If shift > number of digits, return digits reversed.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
| s = str(x)
if shift > len(s):
return s[::-1]
else:
return s[len(s) - shift:] + s[:len(s) - shift]
| def check(candidate):
# Check some simple cases
assert candidate(100, 2) == "001"
assert candidate(12, 2) == "12"
assert candidate(97, 8) == "79"
assert candidate(12, 1) == "21", "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by han... | circular_shift |
def circular_shift(x, shift):
"""অখণ্ড সংখ্যা x-ৰ অংকসমূহ circular shift কৰক, অংকসমূহক shift পৰিমাণে সোঁফালে shift কৰক
আৰু ফলাফলটো এটা string হিচাপে ঘূৰাই দিয়ক।
যদি shift > অংকৰ সংখ্যা হয়, তেন্তে অংকসমূহ ওলোটা ক্ৰমত ঘূৰাই দিয়ক।
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12... |
def circular_shift(x, shift):
"""পূর্ণসংখ্যা x-এর অঙ্কগুলোকে সার্কুলার শিফট করুন, অঙ্কগুলোকে shift পরিমাণ ডানে শিফট করুন
এবং ফলাফলটি একটি স্ট্রিং হিসেবে রিটার্ন করুন।
যদি shift > অঙ্কের সংখ্যা হয়, তবে অঙ্কগুলো উল্টো করে (reversed) রিটার্ন করুন।
>>> circular_shift(12, 1)
"21"
>>> circular_shift(... |
def circular_shift(x, shift):
"""પૂર્ણાંક x ના અંકોને circular shift કરો, અંકોને shift જેટલા જમણી તરફ shift કરો
અને પરિણામ string તરીકે પરત કરો.
જો shift > અંકોની સંખ્યા હોય, તો અંકોને ઉલટાવીને પરત કરો.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
|
def circular_shift(x, shift):
"""पूर्णांक x के अंकों को सर्कुलर शिफ्ट करें, अंकों को shift के अनुसार दाईं ओर शिफ्ट करें
और परिणाम को एक स्ट्रिंग के रूप में लौटाएं।
यदि shift > अंकों की संख्या है, तो अंकों को उलट कर लौटाएं।
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
""... |
def circular_shift(x, shift):
"""ಪೂರ್ಣಾಂಕ x ನ ಅಂಕಿಗಳನ್ನು ವೃತ್ತಾಕಾರವಾಗಿ ಶಿಫ್ಟ್ (circular shift) ಮಾಡಿ, ಅಂಕಿಗಳನ್ನು shift ನಷ್ಟು ಬಲಕ್ಕೆ ಶಿಫ್ಟ್ ಮಾಡಿ
ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು string ರೂಪದಲ್ಲಿ ಹಿಂತಿರುಗಿಸಿ.
ಒಂದು ವೇಳೆ shift > ಅಂಕಿಗಳ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೆ, ಅಂಕಿಗಳನ್ನು ರಿವರ್ಸ್ (reversed) ಮಾಡಿ ಹಿಂತಿರುಗಿಸಿ.
>>> circular_shift(12,... |
def circular_shift(x, shift):
"""x എന്ന പൂർണ്ണസംഖ്യയിലെ അക്കങ്ങളെ സർക്കുലർ ഷിഫ്റ്റ് ചെയ്യുക (circular shift), അക്കങ്ങളെ shift തവണ വലത്തോട്ട് ഷിഫ്റ്റ് ചെയ്ത് ഫലം ഒരു string ആയി നൽകുക.
shift > അക്കങ്ങളുടെ എണ്ണം ആണെങ്കിൽ, അക്കങ്ങൾ തിരിച്ചിട്ട് (reversed) നൽകുക.
>>> circular_shift(12, 1)
"21"
>>> circu... |
def circular_shift(x, shift):
"""पूर्णांक x च्या अंकांचे चक्रीय शिफ्ट (circular shift) करा, अंकांना shift ने उजवीकडे शिफ्ट करा
आणि निकाल स्ट्रिंग म्हणून परत करा.
जर shift > अंकांची संख्या असेल, तर अंक उलट करून परत करा.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
|
def circular_shift(x, shift):
"""पूर्णाङ्क x का अङ्कहरूलाई circular shift गर्नुहोस्, अङ्कहरूलाई shift ले दायाँ सार्नुहोस्
र परिणामलाई string को रूपमा फिर्ता गर्नुहोस्।
यदि shift > अङ्कहरूको सङ्ख्या छ भने, उल्टाइएका अङ्कहरू फिर्ता गर्नुहोस्।
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, ... |
def circular_shift(x, shift):
"""ପୂର୍ଣ୍ଣସଂଖ୍ୟା x ର ଅଙ୍କଗୁଡ଼ିକୁ circular shift କରନ୍ତୁ, shift ଅନୁଯାୟୀ ଅଙ୍କଗୁଡ଼ିକୁ ଡାହାଣକୁ shift କରନ୍ତୁ
ଏବଂ ଫଳାଫଳକୁ ଏକ string ଭାବରେ ଫେରାନ୍ତୁ।
ଯଦି shift > ଅଙ୍କଗୁଡ଼ିକର ସଂଖ୍ୟା, ତେବେ ଅଙ୍କଗୁଡ଼ିକୁ ଓଲଟାଇ (reversed) ଫେରାନ୍ତୁ।
>>> circular_shift(12, 1)
"21"
>>> circular_shif... |
def circular_shift(x, shift):
"""ਪੂਰਨ ਅੰਕ x ਦੇ ਅੰਕਾਂ ਨੂੰ ਸਰਕੂਲਰ ਸ਼ਿਫਟ ਕਰੋ, ਅੰਕਾਂ ਨੂੰ shift ਦੁਆਰਾ ਸੱਜੇ ਪਾਸੇ ਸ਼ਿਫਟ ਕਰੋ
ਅਤੇ ਨਤੀਜਾ ਇੱਕ string ਵਜੋਂ ਵਾਪਸ ਕਰੋ।
ਜੇਕਰ shift > ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਹੈ, ਤਾਂ ਉਲਟਾਏ ਗਏ ਅੰਕ ਵਾਪਸ ਕਰੋ।
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
"""
|
def circular_shift(x, shift):
"""पूर्णाङ्कस्य x अङ्कानां वृत्तीयं विचालनं (circular shift) कुर्वन्तु, अङ्कान् shift परिमाणेन दक्षिणतः विचालयन्तु
तथा च परिणामं string रूपेण प्रतिददतु।
यदि shift > अङ्कानां सङ्ख्या, तर्हि अङ्कान् प्रतीपं (reversed) कृत्वा प्रतिददतु।
>>> circular_shift(12, 1)
"21"
... |
def circular_shift(x, shift):
"""முழு எண் x-இன் இலக்கங்களை வட்ட வடிவில் சுழற்றி (circular shift), இலக்கங்களை shift அளவிற்கு வலதுபுறமாக நகர்த்தி, அதன் முடிவை ஒரு string-ஆகத் திருப்பியளிக்கவும்.
shift > இலக்கங்களின் எண்ணிக்கை எனில், இலக்கங்களைப் பின்னோக்கி மாற்றி (reversed) திருப்பியளிக்கவும்.
>>> circular_s... |
def circular_shift(x, shift):
"""పూర్ణాంకం x యొక్క అంకెలను సర్క్యులర్ షిఫ్ట్ చేయండి, అంకెలను shift మేర కుడివైపుకి షిఫ్ట్ చేసి ఫలితాన్ని ఒక string గా రిటర్న్ చేయండి.
ఒకవేళ shift > అంకెల సంఖ్య అయితే, రివర్స్ చేసిన అంకెలను రిటర్న్ చేయండి.
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"1... |
def circular_shift(x, shift):
"""انٹیجر x کے ہندسوں کو سرکلر شفٹ (circular shift) کریں، ہندسوں کو shift کے مطابق دائیں طرف شفٹ کریں
اور نتیجہ بطور string واپس کریں۔
اگر shift > ہندسوں کی تعداد ہو، تو ہندسوں کو الٹ کر واپس کریں۔
>>> circular_shift(12, 1)
"21"
>>> circular_shift(12, 2)
"12"
... |
HumanEval/66 |
def digitSum(s):
"""Task
Write a function that takes a string as input and returns the sum of the upper characters only'
ASCII codes.
Examples:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
... | if s == "": return 0
return sum(ord(char) if char.isupper() else 0 for char in s)
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate("") == 0, "Error"
assert candidate("abAB") == 131, "Error"
assert candidate("abcCd") == 67, "Error"
assert candidate("helloE") == 69, "Error"
assert candi... | digitSum |
def digitSum(s):
"""কাৰ্য
এটা ফলন লিখক যিয়ে এটা string ইনপুট হিচাপে লয় আৰু কেৱল ডাঙৰ ফলাৰ আখৰবোৰৰ (upper characters)
ASCII ক'ডসমূহৰ যোগফল ঘূৰাই দিয়ে।
উদাহৰণসমূহ:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitS... |
def digitSum(s):
"""টাস্ক
এমন একটি ফাংশন লিখুন যা ইনপুট হিসেবে একটি স্ট্রিং গ্রহণ করে এবং শুধুমাত্র বড় হাতের অক্ষরগুলোর
ASCII কোডের যোগফল রিটার্ন করে।
Examples:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("... |
def digitSum(s):
"""કાર્ય
એક એવું ફંક્શન લખો જે ઇનપુટ તરીકે એક string લે છે અને ફક્ત upper characters ના
ASCII codes નો સરવાળો પરત કરે છે.
ઉદાહરણો:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => ... |
def digitSum(s):
"""कार्य
एक ऐसा फ़ंक्शन लिखें जो इनपुट के रूप में एक स्ट्रिंग लेता है और केवल बड़े अक्षरों (upper characters) के
ASCII कोड्स का योग लौटाता है।
उदाहरण:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
dig... |
def digitSum(s):
"""ಕಾರ್ಯ
ಒಂದು string ಅನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಂಡು, ಕೇವಲ uppercase ಅಕ್ಷರಗಳ ASCII ಕೋಡ್ಗಳ ಮೊತ್ತವನ್ನು ರಿಟರ್ನ್ ಮಾಡುವ ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ.
ಉದಾಹರಣೆಗಳು:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woAr... |
def digitSum(s):
"""ടാസ്ക്
ഒരു സ്ട്രിംഗ് ഇൻപുട്ടായി എടുക്കുകയും അതിലെ upper characters-ന്റെ മാത്രം ASCII കോഡുകളുടെ തുക തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
ഉദാഹരണങ്ങൾ:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
... |
def digitSum(s):
"""कार्य
एक स्ट्रिंग इनपुट म्हणून घेणारे आणि केवळ अप्पर (upper) अक्षरांच्या ASCII कोड्सची बेरीज परत करणारे फंक्शन लिहा.
उदाहरणे:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
... |
def digitSum(s):
"""कार्य
एउटा स्ट्रिङलाई इनपुटको रूपमा लिने र केवल ठूला अक्षरहरू (upper characters) को मात्र
ASCII कोडहरूको योगफल फर्काउने एउटा फङ्सन लेख्नुहोस्।
उदाहरणहरू:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
... |
def digitSum(s):
"""କାର୍ଯ୍ୟ
ଗୋଟିଏ function ଲେଖନ୍ତୁ ଯାହା ଏକ string କୁ input ଭାବରେ ନିଏ ଏବଂ କେବଳ upper characters ଗୁଡ଼ିକର
ASCII codes ର ଯୋଗଫଳ ଫେରସ୍ତ କରେ।
ଉଦାହରଣ:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("wo... |
def digitSum(s):
"""ਕਾਰਜ
ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇਨਪੁਟ ਵਜੋਂ ਇੱਕ string ਲੈਂਦਾ ਹੈ ਅਤੇ ਸਿਰਫ਼ upper characters ਦੇ ASCII ਕੋਡਾਂ ਦਾ ਜੋੜ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਉਦਾਹਰਨਾਂ:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSum("woArBld") => 131
... |
def digitSum(s):
"""कार्यम्
एकं फलनं लिखन्तु यत् निवेशरूपेण string स्वीकरोति तथा केवलं बृहदक्षराणाम् (upper characters)
ASCII-सङ्केतानां योगं प्रत्यर्पयति।
उदाहरणानि:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digi... |
def digitSum(s):
"""பணி
ஒரு string-ஐ உள்ளீடாக எடுத்துக்கொண்டு, பெரிய எழுத்துக்களின் (upper characters) ASCII
மதிப்புகளின் கூடுதலை மட்டுமே திருப்பியளிக்கும் ஒரு function-ஐ எழுதுக.
எடுத்துக்காட்டுகள்:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digit... |
def digitSum(s):
"""టాస్క్
ఒక స్ట్రింగ్ను ఇన్పుట్గా తీసుకుని, కేవలం అప్పర్ (upper) క్యారెక్టర్ల యొక్క ASCII కోడ్ల మొత్తాన్ని రిటర్న్ చేసే ఫంక్షన్ను రాయండి.
ఉదాహరణలు:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digi... |
def digitSum(s):
"""کام
ایک ایسا فنکشن لکھیں جو ان پٹ کے طور پر ایک سٹرنگ لیتا ہو اور صرف بڑے حروف (upper characters) کے
ASCII کوڈز کا مجموعہ واپس کرتا ہو۔
مثالیں:
digitSum("") => 0
digitSum("abAB") => 131
digitSum("abcCd") => 67
digitSum("helloE") => 69
digitSu... |
HumanEval/67 |
def fruit_distribution(s,n):
"""
In this task, you will be given a string that represents a number of apples and oranges
that are distributed in a basket of fruit this basket contains
apples, oranges, and mango fruits. Given the string that represents the total number of
the oranges and apples a... | lis = list()
for i in s.split(' '):
if i.isdigit():
lis.append(int(i))
return n - sum(lis)
| def check(candidate):
# Check some simple cases
assert candidate("5 apples and 6 oranges",19) == 8
assert candidate("5 apples and 6 oranges",21) == 10
assert candidate("0 apples and 1 oranges",3) == 2
assert candidate("1 apples and 0 oranges",3) == 2
assert candidate("2 apples and 3 oranges",10... | fruit_distribution |
def fruit_distribution(s,n):
"""
এই কাৰ্য্যত, আপোনাক এটা ষ্ট্ৰিং দিয়া হ'ব যিয়ে এখন ফলৰ পাচিত বিতৰণ কৰা আপেল আৰু কমলাৰ
সংখ্যা প্ৰতিনিধিত্ব কৰে। এই পাচিখনত আপেল, কমলা আৰু আম থাকে। কমলা আৰু আপেলৰ মুঠ সংখ্যা
প্ৰতিনিধিত্ব কৰা ষ্ট্ৰিংটো আৰু পাচিখনত থকা ফলৰ মুঠ সংখ্যা প্ৰতিনিধিত্ব কৰা এটা ইনটিজাৰ দিয়া থাকি... |
def fruit_distribution(s,n):
"""
এই টাস্কে, আপনাকে একটি স্ট্রিং দেওয়া হবে যা একটি ফলের ঝুড়িতে থাকা আপেল এবং কমলার সংখ্যা
প্রকাশ করে, এই ঝুড়িতে আপেল, কমলা এবং আম রয়েছে।
কমলা এবং আপেলের মোট সংখ্যা প্রকাশকারী স্ট্রিং এবং ঝুড়িতে থাকা মোট ফলের সংখ্যা
প্রকাশকারী একটি পূর্ণসংখ্যা (integer) দেওয়া থাকলে,... |
def fruit_distribution(s,n):
"""
આ કાર્યમાં, તમને એક સ્ટ્રિંગ આપવામાં આવશે જે ફળોની ટોપલીમાં વહેંચાયેલા apples અને oranges ની સંખ્યા દર્શાવે છે,
આ ટોપલીમાં apples, oranges, અને mango ફળો સમાવિષ્ટ છે. oranges અને apples ની કુલ સંખ્યા દર્શાવતી સ્ટ્રિંગ
અને ટોપલીમાં ફળોની કુલ સંખ્યા દર્શાવતો એક પૂર્ણાંક (... |
def fruit_distribution(s,n):
"""
इस कार्य में, आपको एक स्ट्रिंग दी जाएगी जो फलों की एक टोकरी में वितरित सेब और संतरों
की संख्या को दर्शाती है, इस टोकरी में
सेब, संतरे और आम शामिल हैं। संतरों और सेबों की कुल संख्या को
दर्शाने वाली स्ट्रिंग और टोकरी में फलों की कुल संख्या को दर्शाने वाला एक पूर्णा... |
def fruit_distribution(s,n):
"""
ಈ ಕಾರ್ಯದಲ್ಲಿ, ಹಣ್ಣಿನ ಬುಟ್ಟಿಯಲ್ಲಿ ಹಂಚಲಾದ ಸೇಬುಗಳು ಮತ್ತು ಕಿತ್ತಳೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ
ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಿಮಗೆ ನೀಡಲಾಗುತ್ತದೆ. ಈ ಬುಟ್ಟಿಯು ಸೇಬುಗಳು, ಕಿತ್ತಳೆಗಳು ಮತ್ತು ಮಾವಿನ ಹಣ್ಣುಗಳನ್ನು
ಹೊಂದಿರುತ್ತದೆ. ಕಿತ್ತಳೆ ಮತ್ತು ಸೇಬುಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಬುಟ... |
def fruit_distribution(s,n):
"""
ഈ ടാസ്കിൽ, ഒരു പഴക്കൂടയിൽ വിതരണം ചെയ്തിരിക്കുന്ന ആപ്പിളുകളുടെയും ഓറഞ്ചുകളുടെയും എണ്ണത്തെ
സൂചിപ്പിക്കുന്ന ഒരു സ്ട്രിംഗ് നിങ്ങൾക്ക് നൽകും. ഈ പഴക്കൂടയിൽ
ആപ്പിളുകൾ, ഓറഞ്ചുകൾ, മാങ്ങകൾ എന്നിവ അടങ്ങിയിരിക്കുന്നു. ഓറഞ്ചുകളുടെയും ആപ്പിളുകളുടെയും
ആകെ എണ്ണത്തെ പ്രതിനിധീകരിക്കു... |
def fruit_distribution(s,n):
"""
या टास्कमध्ये, तुम्हाला फळांच्या एका टोपलीत वाटप केलेल्या सफरचंद आणि संत्र्यांची संख्या दर्शवणारी
एक स्ट्रिंग दिली जाईल, या टोपलीमध्ये सफरचंद, संत्री आणि आंबे ही फळे आहेत. संत्री
आणि सफरचंदांची एकूण संख्या दर्शवणारी स्ट्रिंग आणि टोपलीतील फळांची एकूण संख्या दर्शवणारा
... |
def fruit_distribution(s,n):
"""
यस कार्यमा, तपाईंलाई फलफूलको टोकरीमा बाँडिएका स्याउ र सुन्तलाको सङ्ख्या
जनाउने एउटा स्ट्रिङ दिइनेछ, यस टोकरीमा स्याउ, सुन्तला, र आँपका फलहरू छन्।
सुन्तला र स्याउको कुल सङ्ख्या जनाउने स्ट्रिङ र टोकरीमा रहेका फलफूलहरूको कुल सङ्ख्या
जनाउने एउटा इन्टिजर दिइएको अवस्थामा,... |
def fruit_distribution(s,n):
"""
ଏହି କାର୍ଯ୍ୟରେ, ଆପଣଙ୍କୁ ଏକ string ଦିଆଯିବ ଯାହା ଏକ ଫଳ ଝୁଡ଼ିରେ ବଣ୍ଟନ କରାଯାଇଥିବା ସେଓ ଏବଂ କମଳାର
ସଂଖ୍ୟାକୁ ଦର୍ଶାଏ, ଏହି ଝୁଡ଼ିରେ ସେଓ, କମଳା, ଏବଂ ଆମ୍ବ ଫଳ ରହିଛି।
କମଳା ଏବଂ ସେଓର ମୋଟ ସଂଖ୍ୟାକୁ ଦର୍ଶାଉଥିବା string ଏବଂ ଝୁଡ଼ିରେ ଥିବା ମୋଟ ଫଳର ସଂଖ୍ୟାକୁ
ଦର୍ଶାଉଥିବା ଏକ integer ଦିଆଯାଇଥିବା ବେଳେ,... |
def fruit_distribution(s,n):
"""
ਇਸ ਕਾਰਜ ਵਿੱਚ, ਤੁਹਾਨੂੰ ਇੱਕ string ਦਿੱਤੀ ਜਾਵੇਗੀ ਜੋ ਫਲਾਂ ਦੀ ਇੱਕ ਟੋਕਰੀ ਵਿੱਚ ਵੰਡੇ ਗਏ apples ਅਤੇ oranges
ਦੀ ਗਿਣਤੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਇਸ ਟੋਕਰੀ ਵਿੱਚ
apples, oranges, ਅਤੇ mango ਫਲ ਹਨ। oranges ਅਤੇ apples ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਨੂੰ
ਦਰਸਾਉਣ ਵਾਲੀ string ਅਤੇ ਟੋਕਰੀ ਵਿੱਚ ਫਲਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ... |
def fruit_distribution(s,n):
"""
अस्मिन् कार्ये, भवते एकं string दास्यते यत् फलकरण्डके वितरितानां सेवितानां (apples)
नारङ्गफलानां (oranges) च सङ्ख्यां सूचयति। अस्मिन् करण्डके सेवितानि, नारङ्गफलानि, आम्रफलानि च सन्ति।
नारङ्गफलानां सेवितानां च कुलसङ्ख्यां सूचयन्तं string तथा करण्डके स्थितानां फलानां
... | def fruit_distribution(s,n):
"""
இந்தப் பணியில், ஒரு பழக் கூடையில் பகிர்ந்தளிக்கப்பட்டுள்ள ஆப்பிள்கள் மற்றும் ஆரஞ்சுகளின் எண்ணிக்கையைக் குறிக்கும் ஒரு சரம் உங்களுக்கு வழங்கப்படும், இந்தக் கூடையில் ஆப்பிள்கள், ஆரஞ்சுகள் மற்றும் மாம்பழங்கள் உள்ளன. ஆரஞ்சுகள் மற்றும் ஆப்பிள்களின் மொத்த எண்ணிக்கையைக் குறிக்கும் சரம்... |
def fruit_distribution(s,n):
"""
ఈ టాస్క్లో, పండ్ల బుట్టలో పంచబడిన ఆపిల్స్ మరియు ఆరంజ్ పండ్ల సంఖ్యను సూచించే
ఒక స్ట్రింగ్ మీకు ఇవ్వబడుతుంది. ఈ బుట్టలో ఆపిల్స్, ఆరంజ్ పండ్లు, మరియు మామిడి పండ్లు ఉంటాయి.
ఆరంజ్ పండ్లు మరియు ఆపిల్స్ మొత్తం సంఖ్యను సూచించే స్ట్రింగ్ మరియు బుట్టలోని మొత్తం పండ్ల సంఖ్యను
... |
def fruit_distribution(s,n):
"""
اس ٹاسک میں، آپ کو ایک سٹرنگ دی جائے گی جو پھلوں کی ایک ٹوکری میں تقسیم کیے گئے سیبوں اور مالٹوں کی تعداد کو ظاہر کرتی ہے،
اس ٹوکری میں سیب، مالٹے اور آم کے پھل شامل ہیں۔
مالٹوں اور سیبوں کی کل تعداد کو ظاہر کرنے والی سٹرنگ اور ٹوکری میں پھلوں کی کل تعداد کو ظاہر کرنے و... |
HumanEval/68 |
def pluck(arr):
"""
"Given an array representing a branch of a tree that has non-negative integer nodes
your task is to pluck one of the nodes and return it.
The plucked node should be the node with the smallest even value.
If multiple nodes with the same smallest even value are found return the no... | if(len(arr) == 0): return []
evens = list(filter(lambda x: x%2 == 0, arr))
if(evens == []): return []
return [min(evens), arr.index(min(evens))]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([4,2,3]) == [2, 1], "Error"
assert candidate([1,2,3]) == [2, 1], "Error"
assert candidate([]) == [], "Error"
assert candidate([5, 0, 3, 0, 4, 2]) == [0, 1], "... | pluck |
def pluck(arr):
"""
"অঋণাত্মক অখণ্ড সংখ্যাৰ (non-negative integer) node থকা গছৰ এটা ডাল প্ৰতিনিধিত্ব কৰা এটা array দিয়া হৈছে,
আপোনাৰ কাম হ'ল এটা node ছিঙি (pluck কৰি) আনি তাক ৰিটাৰ্ন কৰা।
ছিঙি অনা node-টো আটাইতকৈ সৰু যুগ্ম মান (smallest even value) থকা node হ'ব লাগিব।
যদি একেই আটাইতকৈ সৰু যুগ্ম মা... |
def pluck(arr):
"""
"একটি গাছের শাখা নির্দেশকারী একটি অ-ঋণাত্মক পূর্ণসংখ্যার নোডবিশিষ্ট অ্যারে দেওয়া থাকলে
আপনার কাজ হলো নোডগুলোর মধ্যে একটিকে বেছে নিয়ে (pluck করে) রিটার্ন করা।
বেছে নেওয়া নোডটি হবে সবচেয়ে ছোট জোড় (even) মানের নোড।
যদি একই ক্ষুদ্রতম জোড় মানবিশিষ্ট একাধিক নোড পাওয়া যায়, তবে যে নোডের... |
def pluck(arr):
"""
"બિન-ઋણ પૂર્ણાંક નોડ્સ ધરાવતી વૃક્ષની શાખા દર્શાવતો એક એરે આપેલ છે,
તમારું કાર્ય નોડ્સમાંથી એક નોડ પસંદ કરવાનું અને તેને રિટર્ન કરવાનું છે.
પસંદ કરેલ નોડ સૌથી નાની બેકી કિંમત ધરાવતો નોડ હોવો જોઈએ.
જો સમાન સૌથી નાની બેકી કિંમત ધરાવતા બહુવિધ નોડ્સ મળે, તો સૌથી નાનો ઇન્ડેક્સ ધરાવતો... |
def pluck(arr):
"""
"गैर-ऋणात्मक पूर्णांक (non-negative integer) नोड्स वाले पेड़ की एक शाखा को दर्शाने वाला एक array दिया गया है,
आपका काम इनमें से एक नोड को चुनना (pluck करना) और उसे वापस लौटाना है।
चुना गया नोड सबसे छोटे सम मान (smallest even value) वाला नोड होना चाहिए।
यदि समान सबसे छोटे सम मान ... |
def pluck(arr):
"""
"ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕ ನೋಡ್ಗಳನ್ನು ಹೊಂದಿರುವ ಮರದ ಒಂದು ಕೊಂಬೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅರೇಯನ್ನು ನೀಡಲಾಗಿದ್ದು,
ಅದರಲ್ಲಿರುವ ನೋಡ್ಗಳಲ್ಲಿ ಒಂದನ್ನು ಆರಿಸಿ (pluck ಮಾಡಿ) ಅದನ್ನು ರಿಟರ್ನ್ ಮಾಡುವುದು ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ.
ಆರಿಸಿದ ನೋಡ್ ಅತಿ ಸಣ್ಣ ಸರಿ (even) ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ನೋಡ್ ಆಗಿರಬೇಕು.
ಅದೇ ಅತಿ ಸಣ್ಣ ಸರಿ ಮೌಲ... |
def pluck(arr):
"""
"അന്യൂന പൂർണ്ണസംഖ്യാ (non-negative integer) നോഡുകളുള്ള ഒരു വൃക്ഷത്തിന്റെ ശാഖയെ പ്രതിനിധീകരിക്കുന്ന ഒരു അറേ നൽകിയാൽ,
അതിൽ നിന്ന് ഒരു നോഡ് അടർത്തിയെടുത്ത് (pluck ചെയ്ത്) നൽകുക എന്നതാണ് നിങ്ങളുടെ ചുമതല.
അടർത്തിയെടുക്കുന്ന നോഡ് ഏറ്റവും ചെറിയ ഇരട്ട സംഖ്യാ മൂല്യമുള്ള (smallest even value)... |
def pluck(arr):
"""
"ऋणेतर (non-negative) पूर्णांक नोड्स असलेल्या झाडाच्या फांदीचे प्रतिनिधित्व करणारा एक array दिला असता,
त्यातील एका नोडला तोडणे (pluck करणे) आणि ते परत करणे (return करणे) हे तुमचे काम आहे.
तोडलेला नोड हा सर्वात लहान सम (even) मूल्य असलेला नोड असावा.
सर्वात लहान सम मूल्य असलेले अन... |
def pluck(arr):
"""
"गैर-ऋणात्मक पूर्णाङ्क नोडहरू भएको रूखको एउटा हाँगालाई प्रतिनिधित्व गर्ने array दिइएको छ,
तपाईंको कार्य कुनै एउटा नोड टिप्नु र त्यसलाई return गर्नु हो।
टिपिएको नोड सबैभन्दा सानो जोड (even) मान भएको नोड हुनुपर्छ।
यदि उही सबैभन्दा सानो जोड मान भएका धेरै नोडहरू भेटिएमा सबैभन्दा सान... |
def pluck(arr):
"""
"ଅଣ-ଋଣାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟା (non-negative integer) ନୋଡ୍ ଥିବା ଏକ ବୃକ୍ଷର ଶାଖାକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ array ଦିଆଯାଇଛି,
ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି ଗୋଟିଏ ନୋଡ୍କୁ ବାଛି (pluck କରି) ତାହାକୁ ଫେରାଇବା।
ବାଛିଥିବା ନୋଡ୍ଟି ସର୍ବନିମ୍ନ ଯୁଗ୍ମ ମାନ (smallest even value) ବିଶିଷ୍ଟ ନୋଡ୍ ହେବା ଉଚିତ।
ଯଦି ସମାନ ସର୍... |
def pluck(arr):
"""
"ਇੱਕ ਟ੍ਰੀ ਦੀ ਸ਼ਾਖਾ ਨੂੰ ਦਰਸਾਉਂਦੀ ਇੱਕ ਐਰੇ ਦਿੱਤੀ ਗਈ ਹੈ ਜਿਸ ਵਿੱਚ ਗੈਰ-ਰਿਣਾਤਮਕ ਪੂਰਨ ਅੰਕ ਨੋਡਸ ਹਨ
ਤੁਹਾਡਾ ਕੰਮ ਨੋਡਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਚੁਣਨਾ ਅਤੇ ਇਸਨੂੰ ਵਾਪਸ ਕਰਨਾ ਹੈ।
ਚੁਣੀ ਗਈ ਨੋਡ ਸਭ ਤੋਂ ਛੋਟੇ ਜਿਸਤ ਮੁੱਲ ਵਾਲੀ ਨੋਡ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
ਜੇਕਰ ਇੱਕੋ ਜਿਹੇ ਸਭ ਤੋਂ ਛੋਟੇ ਜਿਸਤ ਮੁੱਲ ਵਾਲੀਆਂ ਕਈ ਨੋਡਾਂ ਮਿਲਦੀਆਂ ਹਨ ਤਾਂ ... |
def pluck(arr):
"""
"अऋणात्मकपूर्णाङ्कनोड्युक्तस्य वृक्षस्य शाखाम् उपस्थापयन् एकः व्यूहः (array) दत्तः अस्ति,
भवतः कार्यम् एकं नोड् (node) चित्वा (pluck कृत्वा) तत् प्रत्यावर्तयितुम् अस्ति।
चितं नोड् लघुतमसममूल्ययुक्तं (smallest even value) भवेत्।
यदि समानलघुतमसममूल्ययुक्तानि एकाधिकानि नोड् प्राप्य... |
def pluck(arr):
"""
"எதிர்மறையற்ற முழு எண் முனைகளைக் கொண்ட ஒரு மரத்தின் கிளையைக் குறிக்கும் array கொடுக்கப்பட்டால்,
முனைகளில் ஒன்றைப் பறித்து அதைத் திருப்புவதே உங்கள் பணியாகும்.
பறிக்கப்பட்ட முனை மிகச்சிறிய இரட்டைப்படை மதிப்பைக் கொண்ட முனையாக இருக்க வேண்டும்.
ஒரே மிகச்சிறிய இரட்டைப்படை மதிப்பைக் கொ... |
def pluck(arr):
"""
"రుణాత్మకం కాని పూర్ణాంక నోడ్లను కలిగి ఉన్న చెట్టు యొక్క ఒక కొమ్మను సూచించే అర్రే ఇవ్వబడింది,
ఆ నోడ్లలో ఒకదానిని తుంచి (pluck చేసి) దాన్ని తిరిగి ఇవ్వడం మీ పని.
తుంచిన నోడ్ అత్యంత చిన్న సరి విలువ (smallest even value) కలిగిన నోడ్ అయి ఉండాలి.
ఒకే అత్యంత చిన్న సరి విలువ కలిగిన బ... |
def pluck(arr):
"""
"ایک array دی گئی ہے جو درخت کی ایک شاخ کو ظاہر کرتی ہے جس میں غیر منفی صحیح اعداد (non-negative integer) والے نوڈز ہیں،
آپ کا کام نوڈز میں سے کسی ایک کو چننا (pluck کرنا) اور اسے واپس کرنا ہے۔
چنا ہوا نوڈ سب سے چھوٹی جفت (even) قیمت والا نوڈ ہونا چاہیے۔
اگر ایک جیسی سب سے چھوٹی... |
HumanEval/69 |
def search(lst):
'''
You are given a non-empty list of positive integers. Return the greatest integer that is greater than
zero, and has a frequency greater than or equal to the value of the integer itself.
The frequency of an integer is the number of times it appears in the list.
If no such a va... | frq = [0] * (max(lst) + 1)
for i in lst:
frq[i] += 1;
ans = -1
for i in range(1, len(frq)):
if frq[i] >= i:
ans = i
return ans
| def check(candidate):
# manually generated tests
assert candidate([5, 5, 5, 5, 1]) == 1
assert candidate([4, 1, 4, 1, 4, 4]) == 4
assert candidate([3, 3]) == -1
assert candidate([8, 8, 8, 8, 8, 8, 8, 8]) == 8
assert candidate([2, 3, 3, 2, 2]) == 2
# automatically generated tests
assert... | search |
def search(lst):
'''
আপোনাক ধনাত্মক অখণ্ড সংখ্যাৰ এটা অ-ৰিক্ত তালিকা দিয়া হৈছে। শূন্যতকৈ ডাঙৰ
আৰু যাৰ কম্পনাংক (frequency) অখণ্ড সংখ্যাটোৰ মানৰ সমান বা তাতকৈ বেছি, তেনে সৰ্বাধিক অখণ্ড সংখ্যাটো উভতাই দিয়ক।
এটা অখণ্ড সংখ্যাৰ কম্পনাংক হ'ল তালিকাত ই যিমান বাৰ উপস্থিত থাকে সেই সংখ্যা।
যদি এনে কোনো ম... |
def search(lst):
'''
আপনাকে ধনাত্মক পূর্ণসংখ্যার একটি অ-খালি তালিকা দেওয়া হয়েছে। শূন্যের চেয়ে বড় এমন বৃহত্তম পূর্ণসংখ্যাটি রিটার্ন করুন,
যার পুনরাবৃত্তির সংখ্যা (frequency) সংখ্যাটির নিজের মানের সমান বা তার চেয়ে বেশি।
একটি পূর্ণসংখ্যার frequency হলো তালিকায় এটি যতবার উপস্থিত রয়েছে সেই সংখ্যা।
যদি এ... |
def search(lst):
'''
તમને ધન પૂર્ણાંકોની એક ખાલી ન હોય તેવી list આપવામાં આવી છે. શૂન્ય કરતાં મોટો
અને જેની આવૃત્તિ (frequency) પૂર્ણાંકના પોતાના મૂલ્ય કરતાં મોટી અથવા તેના જેટલી હોય તેવો સૌથી મોટો પૂર્ણાંક પરત કરો.
કોઈ પૂર્ણાંકની આવૃત્તિ એટલે કે તે list માં કેટલી વાર આવે છે તેની સંખ્યા.
જો આવું ક... |
def search(lst):
'''
आपको धनात्मक पूर्णांकों (positive integers) की एक गैर-रिक्त सूची दी गई है। वह सबसे बड़ा पूर्णांक लौटाएं जो शून्य से
बड़ा हो, और जिसकी आवृत्ति (frequency) स्वयं पूर्णांक के मान से अधिक या उसके बराबर हो।
किसी पूर्णांक की आवृत्ति वह संख्या है जितनी बार वह सूची में आता है।
यदि ऐस... |
def search(lst):
'''
ನಿಮಗೆ ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳ ಖಾಲಿಯಲ್ಲದ ಪಟ್ಟಿಯನ್ನು ನೀಡಲಾಗಿದೆ. ಶೂನ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿರುವ ಮತ್ತು
ತನ್ನದೇ ಮೌಲ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಅಥವಾ ಸಮಾನವಾದ ಆವರ್ತನವನ್ನು ಹೊಂದಿರುವ ಅತ್ಯಂತ ದೊಡ್ಡ ಪೂರ್ಣಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಿ.
ಒಂದು ಪೂರ್ಣಾಂಕದ ಆವರ್ತನವೆಂದರೆ ಅದು ಪಟ್ಟಿಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುವ ಒಟ್ಟು ಬಾರಿಯ ಸಂಖ್ಯೆಯಾಗಿದೆ.
ಅಂತಹ ... |
def search(lst):
'''
നിങ്ങൾക്ക് പോസിറ്റീവ് പൂർണ്ണസംഖ്യകളുടെ (positive integers) ശൂന്യമല്ലാത്ത ഒരു ലിസ്റ്റ് നൽകിയിരിക്കുന്നു. പൂജ്യത്തേക്കാൾ വലുതും, സ്വന്തം മൂല്യത്തിന് തുല്യമോ അതിനേക്കാൾ കൂടുതലോ ഫ്രീക്വൻസി (frequency) ഉള്ളതുമായ ഏറ്റവും വലിയ പൂർണ്ണസംഖ്യ റിട്ടേൺ ചെയ്യുക.
ഒരു പൂർണ്ണസംഖ്യയുടെ ഫ്രീക്വൻസി എന്നത്... |
def search(lst):
'''
तुम्हाला धन पूर्णांकांची एक नॉन-एम्प्टी (non-empty) लिस्ट दिली आहे. शून्यापेक्षा मोठा असलेला आणि
ज्याची वारंवारता (frequency) ही त्या पूर्णांकाच्या स्वतःच्या मूल्यापेक्षा जास्त किंवा त्याच्या बरोबरीची आहे असा सर्वात मोठा पूर्णांक परत करा.
एखाद्या पूर्णांकाची वारंवारता म्हणजे तो ल... |
def search(lst):
'''
तपाईंलाई धनात्मक पूर्णाङ्कहरूको एउटा गैर-रिक्त सूची दिइएको छ। शून्यभन्दा ठूलो र
आफ्नो मान बराबर वा सोभन्दा बढी आवृत्ति भएको सबैभन्दा ठूलो पूर्णाङ्क फिर्ता गर्नुहोस्।
कुनै पूर्णाङ्कको आवृत्ति भनेको त्यो सूचीमा कति पटक देखा पर्छ भन्ने सङ्ख्या हो।
यदि त्यस्तो कुनै मान छैन भने, -1 ... |
def search(lst):
'''
ଆପଣଙ୍କୁ ଧନାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ଅଣ-ଖାଲି ତାଲିକା ଦିଆଯାଇଛି। ଶୂନଠାରୁ ବଡ଼ ଏବଂ
ନିଜ ମାନ ସହିତ ସମାନ କିମ୍ବା ଅଧିକ ଆବୃତ୍ତି (frequency) ଥିବା ସର୍ବବୃହତ ପୂର୍ଣ୍ଣସଂଖ୍ୟା ଫେରାନ୍ତୁ।
ଏକ ପୂର୍ଣ୍ଣସଂଖ୍ୟାର ଆବୃତ୍ତି ହେଉଛି ତାଲିକାରେ ଏହା କେତେ ଥର ଆସିଛି ସେହି ସଂଖ୍ୟା।
ଯଦି ଏପରି କୌଣସି ମାନ ନଥାଏ, ତେବେ -1 ଫେ... |
def search(lst):
'''
ਤੁਹਾਨੂੰ ਧਨਾਤਮਕ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਗੈਰ-ਖ਼ਾਲੀ ਸੂਚੀ ਦਿੱਤੀ ਗਈ ਹੈ। ਉਹ ਸਭ ਤੋਂ ਵੱਡਾ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰੋ ਜੋ ਜ਼ੀਰੋ ਤੋਂ
ਵੱਡਾ ਹੋਵੇ, ਅਤੇ ਜਿਸਦੀ ਬਾਰੰਬਾਰਤਾ ਉਸ ਪੂਰਨ ਅੰਕ ਦੇ ਆਪਣੇ ਮੁੱਲ ਤੋਂ ਵੱਧ ਜਾਂ ਬਰਾਬਰ ਹੋਵੇ।
ਕਿਸੇ ਪੂਰਨ ਅੰਕ ਦੀ ਬਾਰੰਬਾਰਤਾ ਉਹ ਗਿਣਤੀ ਹੈ ਜਿੰਨੀ ਵਾਰ ਇਹ ਸੂਚੀ ਵਿੱਚ ਆਉਂਦਾ ਹੈ।
ਜੇਕਰ ਅਜਿਹਾ ਕੋਈ ਮੁ... |
def search(lst):
'''
भवते धनात्मकपूर्णाङ्कानाम् एका अरिक्ता सूची दत्ता अस्ति। तादृशं महत्तमं पूर्णाङ्कं प्रत्यर्पयतु यः
शून्यात् बृहत्तरः अस्ति, तथा च यस्य आवृत्तिः स्वस्य पूर्णाङ्कस्य मूल्यात् अधिका वा समाना वा अस्ति।
पूर्णाङ्कस्य आवृत्तिः सा सङ्ख्या भवति यतिवारं सः सूचीयां दृश्यते।
यदि तादृशं क... |
def search(lst):
'''
உங்களுக்கு நேர்மறை முழு எண்களின் வெற்றில்லாத பட்டியல் ஒன்று கொடுக்கப்பட்டுள்ளது. பூஜ்ஜியத்தை விடப்
பெரியதாகவும், தனது மதிப்பிற்கு சமமான அல்லது அதைவிட அதிகமான நிகழ்வெண்ணைக் கொண்டுள்ள மிகப்பெரிய முழு எண்ணைத் திருப்பித் தரவும்.
ஒரு முழு எண்ணின் நிகழ்வெண் (frequency) என்பது அது பட்டி... |
def search(lst):
'''
మీకు ధన పూర్ణాంకాలతో కూడిన ఖాళీకాని (non-empty) లిస్ట్ ఇవ్వబడింది. సున్నా కంటే పెద్దదై ఉండి,
దాని విలువకు సమానమైన లేదా అంతకంటే ఎక్కువ ఫ్రీక్వెన్సీని కలిగిన అతిపెద్ద పూర్ణాంకాన్ని రిటర్న్ చేయండి.
ఒక పూర్ణాంకం యొక్క ఫ్రీక్వెన్సీ అంటే అది లిస్ట్లో కనిపించే సంఖ్య.
అటువంటి విలువ ఏద... |
def search(lst):
'''
آپ کو مثبت صحیح اعداد کی ایک غیر خالی فہرست دی گئی ہے۔ وہ سب سے بڑا صحیح عدد واپس کریں جو
صفر سے بڑا ہو، اور اس کی فریکوئنسی خود اس صحیح عدد کی قدر کے برابر یا اس سے زیادہ ہو۔
کسی صحیح عدد کی فریکوئنسی سے مراد فہرست میں اس کے ظاہر ہونے کی تعداد ہے۔
اگر ایسی کوئی قدر موجود نہ ہو... |
HumanEval/70 |
def strange_sort_list(lst):
'''
Given list of integers, return list in strange order.
Strange sorting, is when you start with the minimum value,
then maximum of the remaining integers, then minimum and so on.
Examples:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
strange_sort_list([5, 5... | res, switch = [], True
while lst:
res.append(min(lst) if switch else max(lst))
lst.remove(res[-1])
switch = not switch
return res
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4]) == [1, 4, 2, 3]
assert candidate([5, 6, 7, 8, 9]) == [5, 9, 6, 8, 7]
assert candidate([1, 2, 3, 4, 5]) == [1, 5, 2, 4, 3]
assert candidate([5, 6, 7, 8, 9, 1]) == [1, 9, 5, 8, 6, 7]
assert candidate([5, 5, 5, 5]) == [... | strange_sort_list |
def strange_sort_list(lst):
'''
এটা পূৰ্ণসংখ্যাৰ তালিকা দিয়া হৈছে, তালিকাখন এক অদ্ভুত ক্ৰমত ঘূৰাই দিয়ক।
অদ্ভুত ক্ৰমবদ্ধকৰণ হ'ল যেতিয়া আপুনি সৰ্বনিম্ন মানৰ সৈতে আৰম্ভ কৰে,
তাৰ পিছত বাকী থকা পূৰ্ণসংখ্যাসমূহৰ সৰ্বোচ্চ মান, তাৰ পিছত সৰ্বনিম্ন আৰু এইদৰে আগবাঢ়ে।
উদাহৰণ:
strange_sort_list([1, 2, ... |
def strange_sort_list(lst):
'''
পূর্ণসংখ্যার একটি তালিকা দেওয়া হলে, তালিকাটিকে অদ্ভুত ক্রমে (strange order) রিটার্ন করুন।
অদ্ভুতভাবে সাজানো হলো যখন আপনি সর্বনিম্ন মান দিয়ে শুরু করবেন,
তারপর অবশিষ্ট পূর্ণসংখ্যাগুলোর মধ্য থেকে সর্বোচ্চ মান, তারপর সর্বনিম্ন এবং এভাবে চলতে থাকবে।
Examples:
strange... |
def strange_sort_list(lst):
'''
પૂર્ણાંકોની આપેલી લિસ્ટ માટે, વિચિત્ર ક્રમમાં (strange order) લિસ્ટ પરત કરો.
Strange sorting એટલે કે જ્યારે તમે ન્યૂનતમ કિંમતથી શરૂ કરો,
પછી બાકીના પૂર્ણાંકોમાંથી મહત્તમ, પછી ન્યૂનતમ અને આ જ રીતે આગળ વધો.
ઉદાહરણો:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
... |
def strange_sort_list(lst):
'''
पूर्णांकों की एक सूची दिए जाने पर, सूची को अजीब क्रम (strange order) में लौटाएं।
अजीब सॉर्टिंग (Strange sorting) वह है, जब आप न्यूनतम (minimum) मान से शुरू करते हैं,
फिर शेष पूर्णांकों का अधिकतम (maximum) मान, फिर न्यूनतम और इसी तरह आगे बढ़ते हैं।
Examples:
stra... |
def strange_sort_list(lst):
'''
ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡಿದಾಗ, ಪಟ್ಟಿಯನ್ನು ವಿಚಿತ್ರ ಕ್ರಮದಲ್ಲಿ ರಿಟರ್ನ್ ಮಾಡಿ.
ವಿಚಿತ್ರ ವಿಂಗಡಣೆ ಎಂದರೆ, ನೀವು ಕನಿಷ್ಠ ಮೌಲ್ಯದಿಂದ ಪ್ರಾರಂಭಿಸಿ,
ನಂತರ ಉಳಿದ ಪೂರ್ಣಾಂಕಗಳಲ್ಲಿ ಗರಿಷ್ಠ ಮೌಲ್ಯ, ನಂತರ ಕನಿಷ್ಠ ಮೌಲ್ಯ ಹೀಗೆ ಮುಂದುವರಿಯುವುದು.
ಉದಾಹರಣೆಗಳು:
strange_sort_list([1, 2, 3, 4]) == [1, 4,... |
def strange_sort_list(lst):
'''
പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് നൽകിയാൽ, വിചിത്രമായ ക്രമത്തിൽ (strange order) ലിസ്റ്റ് റിട്ടേൺ ചെയ്യുക.
ഏറ്റവും ചെറിയ (minimum) മൂല്യത്തിൽ തുടങ്ങി, ബാക്കിയുള്ള പൂർണ്ണസംഖ്യകളിൽ ഏറ്റവും വലുത് (maximum), പിന്നീട് വീണ്ടും ഏറ്റവും ചെറുത് എന്നിങ്ങനെ മാറിമാറി വരുന്നതാണ് Strange sorti... |
def strange_sort_list(lst):
'''
पूर्णांकांची सूची दिली असता, विचित्र क्रमाने सूची परत करा.
विचित्र क्रमवारी म्हणजे अशी क्रमवारी, जिथे तुम्ही किमान मूल्यापासून सुरुवात करता,
नंतर उर्वरित पूर्णांकांमधील कमाल मूल्य, नंतर किमान आणि याचप्रमाणे पुढे.
उदाहरणे:
strange_sort_list([1, 2, 3, 4]) == [1, 4... |
def strange_sort_list(lst):
'''
पूर्णाङ्कहरूको सूची दिइएको अवस्थामा, अनौठो क्रममा (strange order) सूची फिर्ता गर्नुहोस्।
अनौठो क्रमबद्धता भनेको, जब तपाईं न्यूनतम मानबाट सुरु गर्नुहुन्छ,
त्यसपछि बाँकी पूर्णाङ्कहरूको अधिकतम मान, त्यसपछि न्यूनतम र यसै गरी अगाडि बढ्नुहुन्छ।
उदाहरणहरू:
strange_sort... |
def strange_sort_list(lst):
'''
ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ list ଦିଆଯାଇଛି, ତାହାକୁ strange order ରେ ଫେରାନ୍ତୁ।
Strange sorting ହେଉଛି ଯେତେବେଳେ ଆପଣ ସର୍ବନିମ୍ନ ମାନରୁ ଆରମ୍ଭ କରନ୍ତି,
ତା’ପରେ ବାକି ଥିବା ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ସର୍ବାଧିକ ମାନ, ତା’ପରେ ସର୍ବନିମ୍ନ ଏବଂ ଏହିପରି ଆଗକୁ ଚାଲେ।
ଉଦାହରଣ:
strange_sort_list([1, 2, ... |
def strange_sort_list(lst):
'''
ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਦਿੱਤੀ ਗਈ ਸੂਚੀ ਲਈ, ਸੂਚੀ ਨੂੰ ਅਜੀਬ ਕ੍ਰਮ ਵਿੱਚ ਵਾਪਸ ਕਰੋ।
ਅਜੀਬ ਕ੍ਰਮਬੱਧਤਾ (Strange sorting) ਉਹ ਹੁੰਦੀ ਹੈ, ਜਦੋਂ ਤੁਸੀਂ ਸਭ ਤੋਂ ਛੋਟੇ ਮੁੱਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ,
ਫਿਰ ਬਾਕੀ ਬਚੇ ਪੂਰਨ ਅੰਕਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵੱਡਾ ਮੁੱਲ, ਫਿਰ ਸਭ ਤੋਂ ਛੋਟਾ ਅਤੇ ਇਸੇ ਤਰ੍ਹਾਂ ਅੱਗੇ।
ਉਦਾਹਰਨਾਂ:
strange... |
def strange_sort_list(lst):
'''
पूर्णाङ्कानां सूचौ दत्तायां, विचित्रक्रमे सूचीं प्रत्यायच्छतु।
विचित्रक्रमणं तत् अस्ति यत्र भवान् न्यूनतममूल्येन आरभते,
ततः अवशिष्टपूर्णाङ्कानां महत्तममूल्येन, ततः न्यूनतममूल्येन, एवमेव अग्रे च।
उदाहरणानि:
strange_sort_list([1, 2, 3, 4]) == [1, 4, 2, 3]
stra... |
def strange_sort_list(lst):
'''
முழு எண்களின் பட்டியல் கொடுக்கப்பட்டால், விசித்திரமான வரிசையில் பட்டியலைத் திருப்பியளிக்கவும்.
விசித்திரமான வரிசைப்படுத்துதல் என்பது, நீங்கள் மிகச்சிறிய மதிப்பில் தொடங்கி,
பின்னர் மீதமுள்ள முழு எண்களில் மிகப்பெரிய மதிப்பு, பின்னர் மிகச்சிறிய மதிப்பு எனத் தொடர்ந்து செய்வத... |
def strange_sort_list(lst):
'''
పూర్ణాంకాల జాబితా ఇవ్వబడినప్పుడు, జాబితాను విచిత్రమైన క్రమంలో తిరిగి ఇవ్వండి.
విచిత్రమైన క్రమబద్ధీకరణ అంటే, మీరు కనిష్ట విలువతో ప్రారంభించి,
ఆపై మిగిలిన పూర్ణాంకాలలోని గరిష్ట విలువను, ఆపై కనిష్ట విలువను మరియు ఆ విధంగా కొనసాగించడం.
ఉదాహరణలు:
strange_sort_list([1,... |
def strange_sort_list(lst):
'''
انٹیجرز کی دی گئی فہرست کے لیے، فہرست کو عجیب ترتیب میں واپس کریں۔
عجیب ترتیب (Strange sorting) یہ ہے کہ آپ کم ترین قدر سے شروع کرتے ہیں،
پھر باقی ماندہ انٹیجرز میں سے زیادہ سے زیادہ قدر، پھر کم ترین اور اسی طرح آگے بڑھتے ہیں۔
مثالیں:
strange_sort_list([1, 2, 3,... |
HumanEval/71 |
def triangle_area(a, b, c):
'''
Given the lengths of the three sides of a triangle. Return the area of
the triangle rounded to 2 decimal points if the three sides form a valid triangle.
Otherwise return -1
Three sides make a valid triangle when the sum of any two sides is greater
than the thi... | if a + b <= c or a + c <= b or b + c <= a:
return -1
s = (a + b + c)/2
area = (s * (s - a) * (s - b) * (s - c)) ** 0.5
area = round(area, 2)
return area
| def check(candidate):
# Check some simple cases
assert candidate(3, 4, 5) == 6.00, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1, 2, 10) == -1
assert candidate(4, 8, 5) == 8.18
assert candidate(2, 2, 2) == 1.73
assert candidate(1, 2, 3) == -1
assert candidate... | triangle_area |
def triangle_area(a, b, c):
'''
এটা ত্ৰিভুজৰ তিনিটা বাহুৰ দৈৰ্ঘ্য দিয়া হৈছে। যদি তিনিটা বাহুৱে এটা বৈধ ত্ৰিভুজ গঠন কৰে,
তেন্তে দশমিকৰ পিছত 2 ঘৰলৈ ৰাউণ্ড কৰি ত্ৰিভুজটোৰ কালি ওভতাই দিয়ক।
অন্যথা -1 ওভতাই দিয়ক
যিকোনো দুটা বাহুৰ সমষ্টি তৃতীয় বাহুতকৈ ডাঙৰ হ'লেহে তিনিটা বাহুৱে এটা বৈধ ত্ৰিভুজ গঠন কৰে... |
def triangle_area(a, b, c):
'''
একটি ত্রিভুজের তিনটি বাহুর দৈর্ঘ্য দেওয়া রয়েছে। যদি তিনটি বাহু একটি বৈধ ত্রিভুজ গঠন করে, তবে ত্রিভুজটির ক্ষেত্রফল 2 দশমিক স্থান পর্যন্ত round করে রিটার্ন করুন।
অন্যথায় -1 রিটার্ন করুন
তিনটি বাহু একটি বৈধ ত্রিভুজ গঠন করে যখন যেকোনো দুটি বাহুর যোগফল তৃতীয় বাহুর চেয়ে বৃহত্ত... |
def triangle_area(a, b, c):
'''
ત્રિકોણની ત્રણ બાજુઓની લંબાઈ આપેલ છે. જો ત્રણેય બાજુઓ એક માન્ય ત્રિકોણ બનાવતી હોય, તો
2 દશાંશ સ્થાન સુધી રાઉન્ડ કરેલ ત્રિકોણનું ક્ષેત્રફળ રીટર્ન કરો.
અન્યથા -1 રીટર્ન કરો
ત્રણ બાજુઓ ત્યારે માન્ય ત્રિકોણ બનાવે છે જ્યારે કોઈપણ બે બાજુઓનો સરવાળો ત્રીજી બાજુ કરતાં
... |
def triangle_area(a, b, c):
'''
एक त्रिभुज की तीनों भुजाओं की लंबाइयाँ दी गई हैं। यदि तीनों भुजाएँ एक मान्य त्रिभुज बनाती हैं,
तो त्रिभुज का क्षेत्रफल 2 दशमलव स्थानों तक राउंड करके लौटाएं।
अन्यथा -1 लौटाएं
तीन भुजाएँ तब एक मान्य त्रिभुज बनाती हैं जब किन्हीं भी दो भुजाओं का योग
तीसरी भुजा से ब... |
def triangle_area(a, b, c):
'''
ತ್ರಿಕೋನದ ಮೂರು ಬಾಹುಗಳ ಉದ್ದಗಳನ್ನು ನೀಡಲಾಗಿದೆ. ಮೂರು ಬಾಹುಗಳು ಮಾನ್ಯವಾದ ತ್ರಿಕೋನವನ್ನು ರೂಪಿಸಿದರೆ,
2 ದಶಮಾಂಶ ಸ್ಥಾನಗಳಿಗೆ ಪೂರ್ಣಾಂಕಗೊಳಿಸಲಾದ ತ್ರಿಕೋನದ ವಿಸ್ತೀರ್ಣವನ್ನು ಹಿಂತಿರುಗಿಸಿ.
ಇಲ್ಲದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
ಯಾವುದೇ ಎರಡು ಬಾಹುಗಳ ಮೊತ್ತವು ಮೂರನೇ ಬಾಹುವಿಗಿಂತ ಹೆಚ್ಚಾಗಿದ್ದಾಗ ಮಾತ್ರ ಮೂರು ಬ... |
def triangle_area(a, b, c):
'''
ഒരു ത്രികോണത്തിന്റെ മൂന്ന് വശങ്ങളുടെ നീളങ്ങൾ നൽകിയിരിക്കുന്നു. മൂന്ന് വശങ്ങളും ചേർന്ന്
ഒരു സാധുവായ ത്രികോണം രൂപപ്പെടുത്തുന്നുവെങ്കിൽ, ത്രികോണത്തിന്റെ വിസ്തീർണ്ണം 2 ദശാംശ സ്ഥാനങ്ങളിലേക്ക്
റൗണ്ട് ചെയ്ത് റിട്ടേൺ ചെയ്യുക.
അല്ലെങ്കിൽ -1 റിട്ടേൺ ചെയ്യുക
ഏതെങ്കിലും രണ്... |
def triangle_area(a, b, c):
'''
एका त्रिकोणाच्या तीन बाजूंची लांबी दिलेली आहे. जर या तीन बाजू एक वैध त्रिकोण तयार करत असतील, तर त्रिकोणाचे क्षेत्रफळ 2 दशांश स्थळांपर्यंत round करून परत करा.
अन्यथा -1 परत करा
जेव्हा कोणत्याही दोन बाजूंची बेरीज तिसऱ्या बाजूपेक्षा जास्त असते, तेव्हा तीन बाजू एक वैध त्रिक... |
def triangle_area(a, b, c):
'''
त्रिभुजका तीन भुजाहरूको लम्बाइ दिइएको छ। यदि ती तीन भुजाहरूले एउटा मान्य त्रिभुज बनाउँछन् भने
2 दशमलव स्थानमा राउन्ड गरिएको त्रिभुजको क्षेत्रफल फिर्ता गर्नुहोस्।
अन्यथा -1 फिर्ता गर्नुहोस्
कुनै पनि दुई भुजाहरूको योगफल तेस्रो भुजाभन्दा बढी हुँदा
तीन भुजाहरूले एउटा... |
def triangle_area(a, b, c):
'''
ଏକ ତ୍ରିଭୁଜର ତିନୋଟି ବାହୁର ଦୈର୍ଘ୍ୟ ଦିଆଯାଇଛି। ଯଦି ତିନୋଟି ବାହୁ ଏକ ବୈଧ ତ୍ରିଭୁଜ ଗଠନ କରନ୍ତି,
ତେବେ 2 ଦଶମିକ ସ୍ଥାନ ପର୍ଯ୍ୟନ୍ତ round କରାଯାଇଥିବା ତ୍ରିଭୁଜର କ୍ଷେତ୍ରଫଳ ଫେରାନ୍ତୁ।
ଅନ୍ୟଥା -1 ଫେରାନ୍ତୁ
ଯେତେବେଳେ ଯେକୌଣସି ଦୁଇଟି ବାହୁର ସମଷ୍ଟି ତୃତୀୟ ବାହୁଠାରୁ ବଡ଼ ହୁଏ,
ସେତେବେଳେ ତିନୋଟି ବାହୁ... |
def triangle_area(a, b, c):
'''
ਇੱਕ ਤਿਕੋਣ ਦੀਆਂ ਤਿੰਨ ਭੁਜਾਵਾਂ ਦੀਆਂ ਲੰਬਾਈਆਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ। ਜੇਕਰ ਤਿੰਨ ਭੁਜਾਵਾਂ ਇੱਕ ਵੈਧ ਤਿਕੋਣ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਤਾਂ
ਤਿਕੋਣ ਦਾ ਖੇਤਰਫਲ 2 ਦਸ਼ਮਲਵ ਅੰਕਾਂ ਤੱਕ ਰਾਊਂਡ ਕਰਕੇ ਵਾਪਸ ਕਰੋ।
ਨਹੀਂ ਤਾਂ -1 ਵਾਪਸ ਕਰੋ
ਤਿੰਨ ਭੁਜਾਵਾਂ ਇੱਕ ਵੈਧ ਤਿਕੋਣ ਉਦੋਂ ਬਣਾਉਂਦੀਆਂ ਹਨ ਜਦੋਂ ਕਿਸੇ ਵੀ ਦੋ ਭੁਜਾਵਾਂ ਦਾ ਜੋੜ
... |
def triangle_area(a, b, c):
'''
त्रिकोणस्य त्रयाणां भुजानां दैर्घ्यं दत्तम् अस्ति। यदि तिस्रः भुजाः मान्यं त्रिकोणं
रचयन्ति, तर्हि 2 दशांशस्थानपर्यन्तं सन्निकटीकृतं त्रिकोणस्य क्षेत्रफलम् प्रत्यायच्छतु।
अन्यथा -1 प्रत्यायच्छतु।
तिस्रः भुजाः मान्यं त्रिकोणं तदा रचयन्ति यदा कयोश्चिदपि द्वयोः भुजयोः य... |
def triangle_area(a, b, c):
'''
ஒரு முக்கோணத்தின் மூன்று பக்கங்களின் நீளங்கள் கொடுக்கப்பட்டுள்ளன. அந்த மூன்று பக்கங்களும்
ஒரு செல்லுபடியாகும் முக்கோணத்தை உருவாக்கினால், முக்கோணத்தின் பரப்பளவை 2 தசம இடங்களுக்குத்
திருத்தமாக (rounded) திருப்பியளிக்கவும்.
இல்லையெனில் -1 என்பதைத் திருப்பியளிக்கவும்.
... |
def triangle_area(a, b, c):
'''
ఒక త్రిభుజం యొక్క మూడు భుజాల పొడవులు ఇవ్వబడ్డాయి. ఆ మూడు భుజాలు ఒక చెల్లుబాటు అయ్యే త్రిభుజాన్ని
ఏర్పరిస్తే, 2 దశాంశ స్థానాలకు రౌండ్ చేసిన త్రిభుజ వైశాల్యాన్ని రిటర్న్ చేయండి.
లేకపోతే -1 రిటర్న్ చేయండి
ఏవైనా రెండు భుజాల మొత్తం మూడవ భుజం కంటే ఎక్కువగా ఉన్నప్పుడు ఆ మూ... |
def triangle_area(a, b, c):
'''
ایک مثلث کے تینوں اضلاع کی لمبائیاں دی گئی ہیں۔ اگر تینوں اضلاع ایک درست مثلث بناتے ہیں
تو مثلث کا رقبہ 2 اعشاریائی مقامات تک راؤنڈ کر کے واپس کریں۔
ورنہ -1 واپس کریں
تین اضلاع اس وقت ایک درست مثلث بناتے ہیں جب کسی بھی دو اضلاع کا مجموعہ
تیسرے ضلع سے بڑا ہو۔
... |
HumanEval/72 |
def will_it_fly(q,w):
'''
Write a function that returns True if the object q will fly, and False otherwise.
The object q will fly if it's balanced (it is a palindromic list) and the sum of its elements is less than or equal the maximum possible weight w.
Example:
will_it_fly([1, 2], 5) ➞ False
... | if sum(q) > w:
return False
i, j = 0, len(q)-1
while i<j:
if q[i] != q[j]:
return False
i+=1
j-=1
return True
| def check(candidate):
# Check some simple cases
assert candidate([3, 2, 3], 9) is True
assert candidate([1, 2], 5) is False
assert candidate([3], 5) is True
assert candidate([3, 2, 3], 1) is False
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3], 6) is... | will_it_fly |
def will_it_fly(q,w):
'''
এটা ফাংচন লিখক যিয়ে বস্তু q উৰিব পাৰিলে True, আৰু অন্যথা False ঘূৰাই দিয়ে।
বস্তু q উৰিব যদিহে ই সন্তুলিত হয় (ই এটা palindromic তালিকা) আৰু ইয়াৰ উপাদানসমূহৰ যোগফল সৰ্বাধিক সম্ভৱ ওজন w-ৰ সমান বা তাতকৈ কম হয়।
উদাহৰণ:
will_it_fly([1, 2], 5) ➞ False
# 1+2 সৰ্বাধিক সম... |
def will_it_fly(q,w):
'''
একটি ফাংশন লিখুন যা q বস্তুটি উড়তে পারলে True এবং অন্যথায় False রিটার্ন করে।
q বস্তুটি উড়বে যদি এটি ভারসাম্যপূর্ণ হয় (এটি একটি প্যালিন্ড্রোমিক লিস্ট) এবং এর উপাদানগুলোর যোগফল সর্বোচ্চ সম্ভাব্য ওজন w-এর চেয়ে কম বা সমান হয়।
উদাহরণ:
will_it_fly([1, 2], 5) ➞ False
# 1+2 ... |
def will_it_fly(q,w):
'''
એક એવું ફંક્શન લખો જે જો ઑબ્જેક્ટ q ઉડશે તો True રિટર્ન કરે, અને અન્યથા False રિટર્ન કરે.
ઑબ્જેક્ટ q ત્યારે જ ઉડશે જો તે સંતુલિત હોય (તે એક પેલિન્ડ્રોમિક લિસ્ટ હોય) અને તેના ઘટકોનો સરવાળો મહત્તમ શક્ય વજન w કરતાં ઓછો અથવા તેના જેટલો હોય.
ઉદાહરણ:
will_it_fly([1, 2], 5) ➞ Fa... |
def will_it_fly(q,w):
'''
एक फ़ंक्शन लिखें जो ऑब्जेक्ट q के उड़ने पर True लौटाए, और अन्यथा False।
ऑब्जेक्ट q उड़ेगा यदि यह संतुलित है (यह एक पैलिंड्रोमिक सूची है) और इसके तत्वों का योग अधिकतम संभव भार w से कम या उसके बराबर है।
उदाहरण:
will_it_fly([1, 2], 5) ➞ False
# 1+2 अधिकतम संभव भार से कम... |
def will_it_fly(q,w):
'''
ವಸ್ತು q ಹಾರುವುದಾದರೆ True, ಇಲ್ಲದಿದ್ದರೆ False ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ.
ವಸ್ತು q ಯು ಸಮತೋಲನದಲ್ಲಿದ್ದರೆ (ಅದು ಪ್ಯಾಲಿಂಡ್ರೊಮಿಕ್ (palindromic) ಲಿಸ್ಟ್ ಆಗಿದ್ದರೆ) ಮತ್ತು ಅದರ ಅಂಶಗಳ ಮೊತ್ತವು ಗರಿಷ್ಠ ಸಂಭಾವ್ಯ ತೂಕ w ಗಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿದ್ದರೆ ಅದು ಹಾರುತ್ತದೆ.
ಉದಾಹರಣೆ:
will_it_fl... |
def will_it_fly(q,w):
'''
q എന്ന ഒബ്ജക്റ്റ് പറക്കുമെങ്കിൽ True എന്നും, അല്ലാത്തപക്ഷം False എന്നും റിട്ടേൺ ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
q സന്തുലിതമാണെങ്കിൽ (അതായത് അതൊരു പാലിൻഡ്രോമിക് ലിസ്റ്റ് ആണ്), അതിലെ എലമെന്റുകളുടെ തുക പരമാവധി സാധ്യമായ ഭാരമായ w-നേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ q എന്ന ഒബ്ജക്റ്റ് പറക്കും.... |
def will_it_fly(q,w):
'''
जर q ही वस्तू उडू शकत असेल तर True आणि अन्यथा False परत करणारे फंक्शन लिहा.
q ही वस्तू उडेल जर ती संतुलित असेल (ती एक पॅलिंड्रोमिक लिस्ट आहे) आणि तिच्या घटकांची बेरीज कमाल संभाव्य वजन w पेक्षा कमी किंवा त्याच्या बरोबरीची असेल.
उदाहरण:
will_it_fly([1, 2], 5) ➞ False
#... |
def will_it_fly(q,w):
'''
वस्तु q उड्छ भने True, र अन्यथा False फर्काउने एउटा function लेख्नुहोस्।
वस्तु q उड्नेछ यदि यो सन्तुलित छ (यो एउटा palindromic सूची हो) र यसका तत्वहरूको योग अधिकतम सम्भावित तौल w भन्दा कम वा बराबर छ।
Example:
will_it_fly([1, 2], 5) ➞ False
# 1+2 अधिकतम सम्भावित तौल भ... |
def will_it_fly(q,w):
'''
ଗୋଟିଏ ଫଙ୍କସନ ଲେଖନ୍ତୁ ଯାହା ଯଦି ଅବଜେକ୍ଟ q ଉଡ଼ିବ ତେବେ True, ଏବଂ ଅନ୍ୟଥା False ଫେରାଇବ।
ଅବଜେକ୍ଟ q ଉଡ଼ିବ ଯଦି ଏହା ସନ୍ତୁଳିତ (ଏହା ଏକ palindromic ତାଲିକା) ଏବଂ ଏହାର ଉପାଦାନଗୁଡ଼ିକର ଯୋଗଫଳ ସର୍ବାଧିକ ସମ୍ଭାବ୍ୟ ଓଜନ w ଠାରୁ କମ୍ କିମ୍ବା ସମାନ ହୋଇଥିବ।
ଉଦାହରଣ:
will_it_fly([1, 2], 5) ➞ False
# 1... |
def will_it_fly(q,w):
'''
ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ True ਵਾਪਸ ਕਰੇ ਜੇਕਰ ਆਬਜੈਕਟ q ਉੱਡੇਗਾ, ਅਤੇ ਨਹੀਂ ਤਾਂ False।
ਆਬਜੈਕਟ q ਉੱਡੇਗਾ ਜੇਕਰ ਇਹ ਸੰਤੁਲਿਤ ਹੈ (ਇਹ ਇੱਕ palindromic ਸੂਚੀ ਹੈ) ਅਤੇ ਇਸਦੇ ਤੱਤਾਂ ਦਾ ਜੋੜ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਭਵ ਭਾਰ w ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ ਹੈ।
ਉਦਾਹਰਨ:
will_it_fly([1, 2], 5) ➞ False
# 1+2 ਵੱਧ ਤੋਂ ਵੱ... |
def will_it_fly(q,w):
'''
तादृशं फलनं लिखन्तु यत् यदि q इति वस्तु उत्पतति तर्हि True, अन्यथा False इति प्रतिददाति।
q इति वस्तु तदैव उत्पत्स्यते यदि तत् सन्तुलितं भवति (सा palindromic सूचिः अस्ति) तथा च तस्य अवयवानां योगः अधिकतमसम्भाव्यभारात् w न्यूनः अथवा समानः भवति।
उदाहरणम्:
will_it_fly([1, 2], ... |
def will_it_fly(q,w):
'''
பொருள் q பறக்கும் என்றால் True என்றும், இல்லையெனில் False என்றும் வழங்கும் ஒரு சார்பை எழுதுக.
பொருள் q சமநிலையில் இருந்தால் (அது ஒரு palindrome பட்டியல்) மற்றும் அதன் உறுப்புகளின் கூடுதல் அதிகபட்ச சாத்தியமான எடை w-க்கு குறைவாகவோ அல்லது சமமாகவோ இருந்தால் அது பறக்கும்.
எடுத்துக... |
def will_it_fly(q,w):
'''
ఆబ్జెక్ట్ q ఎగిరితే True ని, లేకపోతే False ని రిటర్న్ చేసే ఫంక్షన్ను రాయండి.
ఆబ్జెక్ట్ q సమతుల్యంగా ఉండి (అది ఒక పాలిండ్రోమిక్ లిస్ట్ అయి ఉండి) మరియు దాని ఎలిమెంట్ల మొత్తం గరిష్ట సాధ్యమైన బరువు w కంటే తక్కువ లేదా సమానంగా ఉంటే అది ఎగురుతుంది.
ఉదాహరణ:
will_it_fly([1, 2], 5... |
def will_it_fly(q,w):
'''
ایک ایسا فنکشن لکھیں جو True واپس کرے اگر آبجیکٹ q اڑ سکے، اور بصورت دیگر False۔
آبجیکٹ q اڑ سکے گا اگر یہ متوازن ہو (یعنی یہ ایک palindromic لسٹ ہو) اور اس کے عناصر کا مجموعہ زیادہ سے زیادہ ممکنہ وزن w سے کم یا اس کے برابر ہو۔
مثال:
will_it_fly([1, 2], 5) ➞ False
# ... |
HumanEval/73 |
def smallest_change(arr):
"""
Given an array arr of integers, find the minimum number of elements that
need to be changed to make the array palindromic. A palindromic array is an array that
is read the same backwards and forwards. In one change, you can change one element to any other element.
For... | ans = 0
for i in range(len(arr) // 2):
if arr[i] != arr[len(arr) - i - 1]:
ans += 1
return ans
| def check(candidate):
# Check some simple cases
assert candidate([1,2,3,5,4,7,9,6]) == 4
assert candidate([1, 2, 3, 4, 3, 2, 2]) == 1
assert candidate([1, 4, 2]) == 1
assert candidate([1, 4, 4, 2]) == 1
# Check some edge cases that are easy to work out by hand.
assert candidate([1, 2, 3, 2... | smallest_change |
def smallest_change(arr):
"""
অখণ্ড সংখ্যাৰ এটা array arr দিয়া থাকিলে, array-টোক palindromic কৰিবলৈ সলনি কৰিবলগা
উপাদানৰ সৰ্বনিম্ন সংখ্যা নিৰ্ণয় কৰক। এটা palindromic array হৈছে এনে এটা array যাক
আগফালৰ পৰা আৰু পিছফালৰ পৰা পঢ়িলে একে হয়। এটা পৰিৱৰ্তনত, আপুনি এটা উপাদানক আন যিকোনো উপাদানলৈ সলনি কৰিব প... |
def smallest_change(arr):
"""
পূর্ণসংখ্যার একটি অ্যারে arr দেওয়া হলে, অ্যারেটিকে প্যালিন্ড্রোমিক করতে সর্বনিম্ন কতটি উপাদান
পরিবর্তন করতে হবে তা নির্ণয় করুন। একটি প্যালিন্ড্রোমিক অ্যারে হলো এমন একটি অ্যারে যা
সামনে এবং পেছন থেকে একইভাবে পড়া যায়। একটি পরিবর্তনে, আপনি যেকোনো একটি উপাদানকে অন্য যেকোনো উ... |
def smallest_change(arr):
"""
પૂર્ણાંકોનો એક એરે arr આપેલ છે, એરેને પેલિન્ડ્રોમિક બનાવવા માટે બદલવા પડતા
ઘટકોની ન્યૂનતમ સંખ્યા શોધો. પેલિન્ડ્રોમિક એરે એવો એરે છે જેને
આગળ અને પાછળ બંને બાજુથી એકસરખી રીતે વાંચી શકાય છે. એક ફેરફારમાં, તમે કોઈપણ એક ઘટકને અન્ય કોઈપણ ઘટકમાં બદલી શકો છો.
ઉદાહરણ તરીકે:
... |
def smallest_change(arr):
"""
पूर्णांकों का एक array arr दिए जाने पर, array को palindromic बनाने के लिए
बदले जाने वाले elements की न्यूनतम संख्या ज्ञात कीजिए। एक palindromic array वह array है जिसे
आगे और पीछे से समान पढ़ा जाता है। एक बदलाव में, आप किसी एक element को किसी भी अन्य element में बदल सकते है... |
def smallest_change(arr):
"""
ಪೂರ್ಣಾಂಕಗಳ ಒಂದು array arr ಅನ್ನು ನೀಡಿದಾಗ, ಆ array ಅನ್ನು palindromic ಮಾಡಲು ಬದಲಾಯಿಸಬೇಕಾದ
ಅಂಶಗಳ ಕನಿಷ್ಠ ಸಂಖ್ಯೆಯನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ. Palindromic array ಎಂದರೆ ಮುಂದಿನಿಂದ
ಮತ್ತು ಹಿಂದಿನಿಂದ ಒಂದೇ ರೀತಿಯಾಗಿ ಓದಲ್ಪಡುವ array ಆಗಿದೆ. ಒಂದು ಬದಲಾವಣೆಯಲ್ಲಿ, ನೀವು ಯಾವುದೇ ಒಂದು ಅಂಶವನ್ನು ಬೇರೆ ಯಾವುದೇ ಅಂಶಕ್... |
def smallest_change(arr):
"""
പൂർണ്ണസംഖ്യകളുടെ ഒരു അറേ arr നൽകിയാൽ, അറേയെ പാലിൻഡ്രോമിക് (palindromic) ആക്കാൻ മാറ്റേണ്ട ഏറ്റവും കുറഞ്ഞ എലമെന്റുകളുടെ എണ്ണം കണ്ടെത്തുക. മുന്നിൽ നിന്നും പിന്നിൽ നിന്നും ഒരേപോലെ വായിക്കാൻ കഴിയുന്ന അറേയാണ് പാലിൻഡ്രോമിക് അറേ. ഒരു മാറ്റത്തിൽ, നിങ്ങൾക്ക് ഒരു എലമെന്റിനെ മറ്റേതെങ്കിലും എല... |
def smallest_change(arr):
"""
पूर्णांकांचा एक array arr दिला असता, array पॅलिंड्रोमिक (palindromic) बनवण्यासाठी बदलणे आवश्यक असलेल्या घटकांची किमान संख्या शोधा. पॅलिंड्रोमिक array असा array असतो जो पुढे आणि मागे दोन्ही बाजूंनी समान वाचला जातो. एका बदलामध्ये, तुम्ही एका घटकाला इतर कोणत्याही घटकामध्ये बदलू शकता.... |
def smallest_change(arr):
"""
पूर्णाङ्कहरूको एउटा array arr दिइएको अवस्थामा, उक्त array लाई palindromic बनाउन परिवर्तन गर्नुपर्ने
तत्वहरूको न्यूनतम संख्या पत्ता लगाउनुहोस्। Palindromic array भनेको त्यस्तो array हो जुन
अगाडि र पछाडिबाट पढ्दा उस्तै हुन्छ। एक परिवर्तनमा, तपाईंले कुनै पनि एउटा तत्वलाई अर्क... |
def smallest_change(arr):
"""
ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ array arr ଦିଆଯାଇଛି, array କୁ palindromic କରିବା ପାଇଁ ପରିବର୍ତ୍ତନ କରାଯିବାକୁ ଥିବା
ଉପାଦାନଗୁଡ଼ିକର ସର୍ବନିମ୍ନ ସଂଖ୍ୟା ନିର୍ଣ୍ଣୟ କରନ୍ତୁ। ଏକ palindromic array ହେଉଛି ଏକ array ଯାହା
ଆଗରୁ ଏବଂ ପଛରୁ ସମାନ ଭାବରେ ପଢ଼ାଯାଏ। ଗୋଟିଏ ପରିବର୍ତ୍ତନରେ, ଆପଣ ଗୋଟିଏ ଉପାଦାନକୁ ଅନ୍ୟ ଯେକୌ... |
def smallest_change(arr):
"""
ਪੂਰਨ ਅੰਕਾਂ ਦਾ ਇੱਕ ਐਰੇ arr ਦਿੱਤਾ ਗਿਆ ਹੈ, ਐਰੇ ਨੂੰ ਪੈਲਿੰਡ੍ਰੋਮਿਕ ਬਣਾਉਣ ਲਈ ਬਦਲੇ ਜਾਣ ਵਾਲੇ ਐਲੀਮੈਂਟਾਂ ਦੀ
ਘੱਟੋ-ਘੱਟ ਗਿਣਤੀ ਲੱਭੋ। ਇੱਕ ਪੈਲਿੰਡ੍ਰੋਮਿਕ ਐਰੇ ਉਹ ਐਰੇ ਹੁੰਦੀ ਹੈ ਜੋ
ਅੱਗੇ ਅਤੇ ਪਿੱਛੇ ਦੋਵਾਂ ਪਾਸਿਆਂ ਤੋਂ ਇੱਕੋ ਜਿਹੀ ਪੜ੍ਹੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਬਦਲਾਅ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਐਲੀਮੈਂਟ ਨੂੰ ਕਿਸੇ ਵੀ ਹੋਰ ਐਲੀਮੈਂਟ... |
def smallest_change(arr):
"""
पूर्णाङ्कानाम् एकम् array arr दत्तम् अस्ति, array इत्येतत् palindromic कर्तुं परिवर्तनीयानाम् तत्त्वानां न्यूनतमसङ्ख्यां प्राप्नुवन्तु। palindromic array तादृशम् array अस्ति यत् पुरतः पश्चात् च सममेव पठ्यते। एकेन परिवर्तनेन, भवान् एकं तत्त्वम् अन्यस्मिन् कस्मिंश्चित् तत्त्वे परिवर... |
def smallest_change(arr):
"""
முழு எண்களைக் கொண்ட ஒரு அணி arr கொடுக்கப்பட்டால், அந்த அணியை பேலிண்ட்ரோம் (palindromic) ஆக மாற்றுவதற்கு மாற்றப்பட வேண்டிய கூறுகளின் குறைந்தபட்ச எண்ணிக்கையைக் கண்டறியவும். ஒரு பேலிண்ட்ரோமிக் அணி என்பது முன்னிருந்தும் பின்னிருந்தும் ஒரே மாதிரியாக வாசிக்கப்படும் ஓர் அணியாகும். ஒரு மா... |
def smallest_change(arr):
"""
పూర్ణాంకాల అర్రే arr ఇవ్వబడినప్పుడు, ఆ అర్రేను పాలిండ్రోమిక్ (palindromic) గా మార్చడానికి మార్చాల్సిన
మూలకాల కనీస సంఖ్యను కనుగొనండి. పాలిండ్రోమిక్ అర్రే అంటే ముందుకు మరియు వెనుకకు
ఒకే విధంగా చదవబడే అర్రే. ఒక మార్పులో, మీరు ఒక మూలకాన్ని ఏదైనా ఇతర మూలకంగా మార్చవచ్చు.
ఉద... |
def smallest_change(arr):
"""
انٹیجرز کا ایک array arr دیا گیا ہے، عناصر کی وہ کم از کم تعداد معلوم کریں جنہیں
array کو palindromic بنانے کے لیے تبدیل کرنے کی ضرورت ہے۔ ایک palindromic array وہ array ہوتی ہے جسے
آگے اور پیچھے سے ایک جیسا پڑھا جاتا ہے۔ ایک تبدیلی میں، آپ کسی ایک عنصر کو کسی بھی دوسرے عن... |
HumanEval/74 |
def total_match(lst1, lst2):
'''
Write a function that accepts two lists of strings and returns the list that has
total number of chars in the all strings of the list less than the other list.
if the two lists have the same number of chars, return the first list.
Examples
total_match([], [])... | l1 = 0
for st in lst1:
l1 += len(st)
l2 = 0
for st in lst2:
l2 += len(st)
if l1 <= l2:
return lst1
else:
return lst2
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([], []) == []
assert candidate(['hi', 'admin'], ['hi', 'hi']) == ['hi', 'hi']
assert candidate(['hi', 'admin'], ['hi', 'hi', 'admin', 'project']) == ['hi', 'admin... | total_match |
def total_match(lst1, lst2):
'''
এটা ফলন লিখক যিয়ে দুটা string-ৰ list গ্ৰহণ কৰে আৰু সেইখন list ঘূৰাই দিয়ে যাৰ
সকলোবোৰ string-ৰ মুঠ বৰ্ণৰ (chars) সংখ্যা আনখন list-তকৈ কম।
যদি দুয়োখন list-ত সমান সংখ্যক বৰ্ণ থাকে, তেন্তে প্ৰথমখন list ঘূৰাই দিয়ক।
Examples
total_match([], []) ➞ []
total_ma... |
def total_match(lst1, lst2):
'''
এমন একটি ফাংশন লিখুন যা দুটি স্ট্রিংয়ের তালিকা গ্রহণ করে এবং এমন তালিকাটি রিটার্ন করে যার
সমস্ত স্ট্রিংয়ে মোট অক্ষরের সংখ্যা অপর তালিকার চেয়ে কম।
যদি দুটি তালিকায় মোট অক্ষরের সংখ্যা সমান হয়, তবে প্রথম তালিকাটি রিটার্ন করুন।
Examples
total_match([], []) ➞ []
... |
def total_match(lst1, lst2):
'''
એવું ફંક્શન લખો જે સ્ટ્રિંગ્સની બે લિસ્ટ સ્વીકારે અને તે લિસ્ટ રિટર્ન કરે જેમાં
લિસ્ટની બધી સ્ટ્રિંગ્સના અક્ષરો (chars) ની કુલ સંખ્યા બીજી લિસ્ટ કરતાં ઓછી હોય.
જો બંને લિસ્ટમાં અક્ષરોની સંખ્યા સમાન હોય, તો પહેલી લિસ્ટ રિટર્ન કરો.
Examples
total_match([], []) ... |
def total_match(lst1, lst2):
'''
एक ऐसा फ़ंक्शन लिखें जो स्ट्रिंग्स की दो सूचियों को स्वीकार करता है और वह सूची लौटाता है जिसके
सभी स्ट्रिंग्स में वर्णों (chars) की कुल संख्या दूसरी सूची से कम हो।
यदि दोनों सूचियों में वर्णों की संख्या समान है, तो पहली सूची लौटाएं।
उदाहरण
total_match([], [])... |
def total_match(lst1, lst2):
'''
ಸ್ಟ್ರಿಂಗ್ಗಳ ಎರಡು ಲಿಸ್ಟ್ಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಮತ್ತು ಎಲ್ಲಾ ಸ್ಟ್ರಿಂಗ್ಗಳ ಒಟ್ಟು ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆಯು
ಇನ್ನೊಂದು ಲಿಸ್ಟ್ಗಿಂತ ಕಡಿಮೆಯಿರುವ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಒಂದನ್ನು ಬರೆಯಿರಿ.
ಒಂದು ವೇಳೆ ಎರಡೂ ಲಿಸ್ಟ್ಗಳು ಒಂದೇ ಸಂಖ್ಯೆಯ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಮೊದಲ ಲಿಸ್ಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
... |
def total_match(lst1, lst2):
'''
സ്ട്രിംഗുകളുടെ രണ്ട് ലിസ്റ്റുകൾ സ്വീകരിക്കുകയും, അതിലെ എല്ലാ സ്ട്രിംഗുകളിലുമുള്ള ആകെ അക്ഷരങ്ങളുടെ എണ്ണം മറ്റേ ലിസ്റ്റിനേക്കാൾ കുറവുള്ള ലിസ്റ്റ് റിട്ടേൺ ചെയ്യുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
രണ്ട് ലിസ്റ്റുകളിലും ഒരേ എണ്ണം അക്ഷരങ്ങളാണെങ്കിൽ, ആദ്യത്തെ ലിസ്റ്റ് തിരികെ നൽകുക.... |
def total_match(lst1, lst2):
'''
दोन strings च्या lists स्वीकारणारे एक फंक्शन लिहा आणि ज्या list मधील सर्व strings च्या अक्षरांची (chars) एकूण संख्या दुसऱ्या list पेक्षा कमी असेल, ती list परत करा.
जर दोन्ही lists मध्ये अक्षरांची संख्या समान असेल, तर पहिली list परत करा.
उदाहरणे
total_match([], [])... |
def total_match(lst1, lst2):
'''
दुईवटा स्ट्रिङहरूको सूची स्वीकार गर्ने र अर्को सूचीको तुलनामा आफ्ना सबै स्ट्रिङहरूमा कुल क्यारेक्टरहरूको सङ्ख्या कम भएको सूची फिर्ता गर्ने एउटा प्रकार्य लेख्नुहोस्।
यदि दुई सूचीहरूमा क्यारेक्टरहरूको सङ्ख्या बराबर छ भने, पहिलो सूची फिर्ता गर्नुहोस्।
उदाहरणहरू
total... |
def total_match(lst1, lst2):
'''
ଏପରି ଏକ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ ଯାହା ଷ୍ଟ୍ରିଙ୍ଗଗୁଡ଼ିକର ଦୁଇଟି ଲିଷ୍ଟ୍ ଗ୍ରହଣ କରେ ଏବଂ ସେହି ଲିଷ୍ଟକୁ ଫେରସ୍ତ କରେ ଯାହାର
ସମସ୍ତ ଷ୍ଟ୍ରିଙ୍ଗରେ ଥିବା ମୋଟ ଅକ୍ଷର ସଂଖ୍ୟା ଅନ୍ୟ ଲିଷ୍ଟ ତୁଳନାରେ କମ୍ ଅଟେ।
ଯଦି ଦୁଇଟି ଲିଷ୍ଟରେ ସମାନ ସଂଖ୍ୟକ ଅକ୍ଷର ଥାଏ, ତେବେ ପ୍ରଥମ ଲିଷ୍ଟଟିକୁ ଫେରସ୍ତ କରନ୍ତୁ।
ଉଦାହରଣ
total... |
def total_match(lst1, lst2):
'''
ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਸਟ੍ਰਿੰਗਾਂ ਦੀਆਂ ਦੋ ਸੂਚੀਆਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸਦੀਆਂ
ਸਾਰੀਆਂ ਸਟ੍ਰਿੰਗਾਂ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਦੂਜੀ ਸੂਚੀ ਨਾਲੋਂ ਘੱਟ ਹੋਵੇ।
ਜੇਕਰ ਦੋਵਾਂ ਸੂਚੀਆਂ ਵਿੱਚ ਅੱਖਰਾਂ ਦੀ ਗਿਣਤੀ ਬਰਾਬਰ ਹੈ, ਤਾਂ ਪਹਿਲੀ ਸੂਚੀ ਵਾਪਸ ਕਰੋ।
ਉਦਾਹਰਨਾਂ
total_match... |
def total_match(lst1, lst2):
'''
एतादृशं फलनं लिखतु यत् string-सूच्योः द्वयं स्वीकरोति तथा तां सूचीं प्रत्यानयति यस्याः
सर्वेषु strings मध्ये वर्णानां कुलसंख्या अपरसूच्याः अपेक्षया न्यूना अस्ति।
यदि द्वयोः सूच्योः वर्णानां संख्या समाना भवेत्, तर्हि प्रथमां सूचीं प्रत्यानयतु।
उदाहरणानि
total_... |
def total_match(lst1, lst2):
'''
சரங்களின் இரண்டு பட்டியல்களை ஏற்றுக்கொண்டு, மற்றொரு பட்டியலை விடத் தனது அனைத்துச் சரங்களிலும் உள்ள மொத்த எழுத்துகளின் எண்ணிக்கை குறைவாக உள்ள பட்டியலைத் திருப்பி அனுப்பும் ஒரு சார்பை எழுதுக.
இரண்டு பட்டியல்களிலும் ஒரே எண்ணிக்கையிலான எழுத்துகள் இருந்தால், முதல் பட்டியலைத் தி... |
def total_match(lst1, lst2):
'''
రెండు స్ట్రింగ్స్ లిస్ట్లను స్వీకరించి, మరొక లిస్ట్ కంటే తనలోని అన్ని స్ట్రింగ్స్లలోని మొత్తం అక్షరాల సంఖ్య తక్కువగా ఉన్న లిస్ట్ను రిటర్న్ చేసే ఫంక్షన్ను రాయండి.
రెండు లిస్ట్లలోనూ సమాన సంఖ్యలో అక్షరాలు ఉంటే, మొదటి లిస్ట్ను రిటర్న్ చేయండి.
ఉదాహరణలు
total_matc... |
def total_match(lst1, lst2):
'''
ایک ایسا فنکشن لکھیں جو اسٹرنگز کی دو لسٹس قبول کرتا ہو اور وہ لسٹ واپس کرتا ہو جس کی
تمام اسٹرنگز میں موجود کل کیریکٹرز (chars) کی تعداد دوسری لسٹ سے کم ہو۔
اگر دونوں لسٹس میں کیریکٹرز کی تعداد برابر ہو، تو پہلی لسٹ واپس کریں۔
مثالیں
total_match([], []) ➞ []
... |
HumanEval/75 |
def is_multiply_prime(a):
"""Write a function that returns true if the given number is the multiplication of 3 prime numbers
and false otherwise.
Knowing that (a) is less then 100.
Example:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
| def is_prime(n):
for j in range(2,n):
if n%j == 0:
return False
return True
for i in range(2,101):
if not is_prime(i): continue
for j in range(2,101):
if not is_prime(j): continue
for k in range(2,101):
if not i... | def check(candidate):
assert candidate(5) == False
assert candidate(30) == True
assert candidate(8) == True
assert candidate(10) == False
assert candidate(125) == True
assert candidate(3 * 5 * 7) == True
assert candidate(3 * 6 * 7) == False
assert candidate(9 * 9 * 9) == False
asser... | is_multiply_prime |
def is_multiply_prime(a):
"""এটা ফাংচন লিখক যিয়ে প্ৰদত্ত সংখ্যাটো 3 টা মৌলিক সংখ্যাৰ গুণফল হ'লে true
আৰু অন্যথা false ঘূৰাই দিয়ে।
জনা আছে যে (a) 100 তকৈ সৰু।
উদাহৰণ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""একটি ফাংশন লিখুন যা true রিটার্ন করে যদি প্রদত্ত সংখ্যাটি 3টি মৌলিক সংখ্যার গুণফল হয়
এবং অন্যথায় false রিটার্ন করে।
জানা আছে যে (a) 100 এর চেয়ে কম।
উদাহরণ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""એક એવું ફંક્શન લખો જે જો આપેલી સંખ્યા 3 અવિભાજ્ય સંખ્યાઓનો ગુણાકાર હોય તો true
અને અન્યથા false પરત કરે.
ધ્યાનમાં રાખો કે (a) એ 100 કરતાં ઓછી છે.
ઉદાહરણ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""एक ऐसा फ़ंक्शन लिखें जो true लौटाता है यदि दी गई संख्या 3 अभाज्य संख्याओं (prime numbers) का गुणनफल है
और अन्यथा false।
यह जानते हुए कि (a) 100 से कम है।
उदाहरण:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""ಕೊಟ್ಟಿರುವ ಸಂಖ್ಯೆಯು 3 ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಗಳ ಗುಣಲಬ್ಧವಾಗಿದ್ದರೆ true ಮತ್ತು ಇಲ್ಲದಿದ್ದರೆ false ಎಂದು ರಿಟರ್ನ್ ಮಾಡುವ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ.
(a) ಯು 100 ಕ್ಕಿಂತ ಕಡಿಮೆ ಇದೆ ಎಂದು ತಿಳಿದಿದೆ.
ಉದಾಹರಣೆ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""നൽകിയിരിക്കുന്ന സംഖ്യ 3 അഭാജ്യസംഖ്യകളുടെ (prime numbers) ഗുണനഫലമാണെങ്കിൽ true എന്നും
അല്ലെങ്കിൽ false എന്നും റിട്ടേൺ ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
(a) എന്നത് 100-ൽ കുറവാണെന്ന് അറിയുക.
Example:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""दिलेली संख्या 3 मूळ संख्यांचा गुणाकार असल्यास true आणि अन्यथा false परत करणारे एक फंक्शन लिहा.
(a) हे 100 पेक्षा कमी आहे हे लक्षात घेऊन.
उदाहरण:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""एउटा function लेख्नुहोस् जसले दिइएको सङ्ख्या 3 वटा prime सङ्ख्याहरूको गुणनफल हो भने true र अन्यथा false रिटर्न गर्दछ।
यो थाहा छ कि (a) 100 भन्दा कम छ।
उदाहरण:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""ଗୋଟିଏ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ ଯାହା ଦିଆଯାଇଥିବା ସଂଖ୍ୟାଟି 3 ଟି ମୌଳିକ ସଂଖ୍ୟାର ଗୁଣନଫଳ ହୋଇଥିଲେ true
ଏବଂ ଅନ୍ୟଥା false ଫେରାଇବ।
ଜାଣିରଖନ୍ତୁ ଯେ (a) 100 ରୁ କମ୍ ଅଟେ।
ଉଦାହରଣ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ true ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਦਿੱਤੀ ਗਈ ਸੰਖਿਆ 3 ਅਭਾਜ ਸੰਖਿਆਵਾਂ (prime numbers) ਦਾ ਗੁਣਨਫਲ ਹੈ
ਅਤੇ ਨਹੀਂ ਤਾਂ false।
ਇਹ ਜਾਣਦੇ ਹੋਏ ਕਿ (a), 100 ਤੋਂ ਘੱਟ ਹੈ।
ਉਦਾਹਰਨ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""एकं फलनं लिखन्तु यत् यदि दत्ता सङ्ख्या ३ अभाज्यसङ्ख्यानां गुणनफलम् अस्ति तर्हि true
अन्यथा च false प्रत्यर्पयति।
ज्ञातव्यं यत् (a) १०० तः न्यूनम् अस्ति।
उदाहरणम्:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""கொடுக்கப்பட்ட எண் 3 பகா எண்களின் பெருக்கலாக இருந்தால் true என்றும்,
இல்லையெனில் false என்றும் திருப்பி அனுப்பும் ஒரு சார்பை எழுதுக.
(a) என்பது 100-ஐ விடக் குறைவானது என அறிக.
எடுத்துக்காட்டு:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""ఇచ్చిన సంఖ్య 3 ప్రధాన సంఖ్యల గుణకారం అయితే true అని, లేకపోతే false అని రిటర్న్ చేసే ఫంక్షన్ను రాయండి.
(a) అనేది 100 కంటే తక్కువ అని ఇవ్వబడింది.
ఉదాహరణ:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
def is_multiply_prime(a):
"""ایک ایسا فنکشن لکھیں جو true واپس کرے اگر دیا گیا عدد 3 مفرد اعداد (prime numbers) کا حاصل ضرب ہو
اور بصورت دیگر false۔
یہ جانتے ہوئے کہ (a) 100 سے کم ہے۔
مثال:
is_multiply_prime(30) == True
30 = 2 * 3 * 5
"""
|
HumanEval/76 |
def is_simple_power(x, n):
"""Your task is to write a function that returns true if a number x is a simple
power of n and false in other cases.
x is a simple power of n if n**int=x
For example:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => true
is_... | if (n == 1):
return (x == 1)
power = 1
while (power < x):
power = power * n
return (power == x)
| def check(candidate):
# Check some simple cases
assert candidate(16, 2)== True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(143214, 16)== False, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(4, 2)==True, "This prints if this assert fails 1 (... | is_simple_power |
def is_simple_power(x, n):
"""আপোনাৰ কাম হ'ল এটা ফাংচন লিখা যিয়ে সংখ্যা x, n-ৰ এটা সৰল ঘাত (simple power) হ'লে true আৰু অন্য ক্ষেত্ৰত false ঘূৰাই দিয়ে।
x হ'ল n-ৰ এটা সৰল ঘাত যদিহে n**int=x হয়
উদাহৰণস্বৰূপে:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) => ... |
def is_simple_power(x, n):
"""আপনার কাজ হলো এমন একটি ফাংশন লেখা যা true রিটার্ন করবে যদি একটি সংখ্যা x, n এর একটি simple
power হয় এবং অন্যান্য ক্ষেত্রে false রিটার্ন করবে।
x হলো n এর একটি simple power যদি n**int=x হয়
উদাহরণস্বরূপ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
... |
def is_simple_power(x, n):
"""તમારું કાર્ય એક એવું ફંક્શન લખવાનું છે જે જો સંખ્યા x એ n નો simple
power હોય તો true આપે અને અન્ય કિસ્સાઓમાં false આપે.
જો n**int=x હોય તો x એ n નો simple power છે
ઉદાહરણ તરીકે:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8, 2) ... |
def is_simple_power(x, n):
"""आपका कार्य एक ऐसा फ़ंक्शन लिखना है जो true लौटाता है यदि कोई संख्या x, n की एक सरल
घात (simple power) है और अन्य मामलों में false लौटाता है।
x, n की एक सरल घात है यदि n**int=x
उदाहरण के लिए:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_... |
def is_simple_power(x, n):
"""x ಎಂಬ ಸಂಖ್ಯೆಯು n ನ ಸರಳ ಘಾತವಾಗಿದ್ದರೆ true ಮತ್ತು ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ false ಅನ್ನು
ಹಿಂತಿರುಗಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಬರೆಯುವುದು ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ.
n**int=x ಆಗಿದ್ದರೆ x ಯು n ನ ಸರಳ ಘಾತವಾಗಿರುತ್ತದೆ
ಉದಾಹರಣೆಗೆ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simp... |
def is_simple_power(x, n):
"""x എന്ന സംഖ്യ n-ന്റെ ഒരു simple power ആണെങ്കിൽ true എന്നും മറ്റ് സന്ദർഭങ്ങളിൽ
false എന്നും നൽകുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക എന്നതാണ് നിങ്ങളുടെ ചുമതല.
n**int=x ആണെങ്കിൽ x എന്നത് n-ന്റെ ഒരു simple power ആണ്
ഉദാഹരണത്തിന്:
is_simple_power(1, 4) => true
is_simple_power(2, 2) =>... |
def is_simple_power(x, n):
"""तुमचे काम असे एक फंक्शन लिहिणे आहे जे जर x ही संख्या n चा साधा घात (simple power) असेल तर true आणि इतर प्रकरणांमध्ये false परत (return) करेल.
जर n**int=x असेल तर x हा n चा साधा घात आहे
उदाहरणाार्थ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simp... |
def is_simple_power(x, n):
"""तपाईंको कार्य एउटा यस्तो function लेख्नु हो जसले यदि कुनै संख्या x, n को simple
power हो भने true र अन्य अवस्थामा false फिर्ता गर्दछ।
यदि n**int=x हुन्छ भने x, n को simple power हो
उदाहरणका लागि:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_si... |
def is_simple_power(x, n):
"""ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି ଏପରି ଏକ ଫଙ୍କସନ୍ ଲେଖିବା ଯାହା ଯଦି ଏକ ସଂଖ୍ୟା x, n ର ଏକ simple
power ଅଟେ ତେବେ true ଏବଂ ଅନ୍ୟ କ୍ଷେତ୍ରରେ false ଫେରାଇଥାଏ।
x ହେଉଛି n ର ଏକ simple power ଯଦି n**int=x
ଉଦାହରଣ ସ୍ୱରୂପ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_... |
def is_simple_power(x, n):
"""ਤੁਹਾਡਾ ਕੰਮ ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਹੈ ਜੋ true ਵਾਪਸ ਕਰੇ ਜੇਕਰ ਕੋਈ ਸੰਖਿਆ x, n ਦੀ ਇੱਕ simple
power ਹੈ ਅਤੇ ਹੋਰ ਮਾਮਲਿਆਂ ਵਿੱਚ false ਵਾਪਸ ਕਰੇ।
x, n ਦੀ ਇੱਕ simple power ਹੈ ਜੇਕਰ n**int=x
ਉਦਾਹਰਨ ਲਈ:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_powe... |
def is_simple_power(x, n):
"""भवतः कार्यम् एकं फलनं लेखितुं वर्तते यत् यदि काचित् सङ्ख्या x, n इत्यस्य सरला
घातसङ्ख्या (simple power) अस्ति तर्हि true प्रत्यर्पयेत्, अन्येषु सन्दर्भेषु च false प्रत्यर्पयेत्।
x, n इत्यस्य सरला घातसङ्ख्या भवति यदि n**int=x
उदाहरणार्थम्:
is_simple_power(1, 4) => true
... |
def is_simple_power(x, n):
"""ஒரு எண் x ஆனது n-இன் எளிய அடுக்காக (simple power) இருந்தால் true எனவும், மற்ற
நிலைகளில் false எனவும் திருப்பியளிக்கும் ஒரு சார்பை எழுதுவதே உங்கள் பணியாகும்.
n**int=x எனில், x என்பது n-இன் எளிய அடுக்காகும்
எடுத்துக்காட்டாக:
is_simple_power(1, 4) => true
is_simple_po... |
def is_simple_power(x, n):
"""ఒక సంఖ్య x అనేది n యొక్క సాధారణ ఘాతం (simple power) అయితే true మరియు ఇతర సందర్భాలలో false రిటర్న్ చేసే ఫంక్షన్ను రాయడం మీ పని.
n**int=x అయితే x అనేది n యొక్క సాధారణ ఘాతం అవుతుంది
ఉదాహరణకు:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power... |
def is_simple_power(x, n):
"""آپ کا کام ایک ایسا فنکشن لکھنا ہے جو true واپس کرے اگر عدد x، n کی ایک سادہ پاور (simple power) ہو اور دیگر صورتوں میں false واپس کرے۔
x، n کی سادہ پاور ہے اگر n**int=x ہو
مثال کے طور پر:
is_simple_power(1, 4) => true
is_simple_power(2, 2) => true
is_simple_power(8... |
HumanEval/77 |
def iscube(a):
'''
Write a function that takes an integer a and returns True
if this ingeger is a cube of some integer number.
Note: you may assume the input is always valid.
Examples:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> ... | a = abs(a)
return int(round(a ** (1. / 3))) ** 3 == a
| def check(candidate):
# Check some simple cases
assert candidate(1) == True, "First test error: " + str(candidate(1))
assert candidate(2) == False, "Second test error: " + str(candidate(2))
assert candidate(-1) == True, "Third test error: " + str(candidate(-1))
assert candidate(64) == True, "Fourth... | iscube |
def iscube(a):
'''
এটা ফলন লিখক যিয়ে এটা integer a লয় আৰু যদি এই integer-টো
কোনো এটা integer সংখ্যাৰ cube হয় তেন্তে True ঘূৰাই দিয়ে।
টোকা: আপুনি ধৰি ল'ব পাৰে যে ইনপুট সদায় বৈধ।
উদাহৰণ:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0)... |
def iscube(a):
'''
একটি ফাংশন লিখুন যা একটি পূর্ণসংখ্যা a গ্রহণ করে এবং True রিটার্ন করে
যদি এই পূর্ণসংখ্যাটি কোনো পূর্ণসংখ্যার ঘন (cube) হয়।
দ্রষ্টব্য: আপনি ধরে নিতে পারেন যে ইনপুট সর্বদা বৈধ।
উদাহরণ:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
... |
def iscube(a):
'''
એક ફંક્શન લખો જે એક પૂર્ણાંક a લે છે અને જો આ પૂર્ણાંક કોઈ પૂર્ણાંક સંખ્યાનો ઘન હોય તો True રિટર્ન કરે છે.
નોંધ: તમે માની શકો છો કે ઇનપુટ હંમેશા માન્ય છે.
ઉદાહરણો:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) ==> True
... |
def iscube(a):
'''
एक फ़ंक्शन लिखें जो एक integer a लेता है और यदि यह integer किसी
integer संख्या का घन (cube) है, तो True लौटाता है।
नोट: आप मान सकते हैं कि इनपुट हमेशा मान्य है।
उदाहरण:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscube(0) =... |
def iscube(a):
'''
ಪೂರ್ಣಾಂಕ a ಅನ್ನು ಸ್ವೀಕರಿಸುವ ಮತ್ತು ಈ ಪೂರ್ಣಾಂಕವು ಯಾವುದಾದರೂ ಪೂರ್ಣಾಂಕ ಸಂಖ್ಯೆಯ ಘನವಾಗಿದ್ದರೆ (cube) True ಅನ್ನು ಹಿಂದಿರುಗಿಸುವ
ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ.
ಗಮನಿಸಿ: ಇನ್ಪುಟ್ ಯಾವಾಗಲೂ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ ಎಂದು ನೀವು ಊಹಿಸಬಹುದು.
ಉದಾಹರಣೆಗಳು:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
... |
def iscube(a):
'''
ഒരു പൂർണ്ണസംഖ്യ a സ്വീകരിക്കുകയും, ഈ പൂർണ്ണസംഖ്യ ഏതെങ്കിലും ഒരു പൂർണ്ണസംഖ്യയുടെ
ക്യൂബ് ആണെങ്കിൽ True നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
കുറിപ്പ്: നൽകുന്ന ഇൻപുട്ട് എല്ലായ്പ്പോഴും സാധുവാണെന്ന് നിങ്ങൾക്ക് അനുമാനിക്കാം.
ഉദാഹരണങ്ങൾ:
iscube(1) ==> True
iscube(2) ==> False
... |
def iscube(a):
'''
एक फंक्शन लिहा जे एक पूर्णांक a घेते आणि जर हा पूर्णांक
कुठल्यातरी पूर्णांक संख्येचा घन (cube) असेल तर True परत करते.
टीप: तुम्ही गृहीत धरू शकता की इनपुट नेहमी वैध (valid) आहे.
उदाहरणे:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True... |
def iscube(a):
'''
एउटा integer a लिने र यदि यो integer कुनै integer संख्याको घन (cube) हो भने True
फर्काउने एउटा function लेख्नुहोस्।
द्रष्टव्य: तपाईं इनपुट सधैं मान्य हुन्छ भनी मान्न सक्नुहुन्छ।
उदाहरणहरू:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> ... |
def iscube(a):
'''
ଏପରି ଏକ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ ଯାହା ଏକ integer a ଗ୍ରହଣ କରେ ଏବଂ ଯଦି ଏହି integer କୌଣସି integer ସଂଖ୍ୟାର ଏକ ଘନ (cube) ହୋଇଥାଏ ତେବେ True ଫେରାଏ।
ଧ୍ୟାନ ଦିଅନ୍ତୁ: ଆପଣ ଧରି ନେଇପାରନ୍ତି ଯେ ଇନପୁଟ୍ ସର୍ବଦା ବୈଧ ଅଟେ।
ଉଦାହରଣ:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64)... |
def iscube(a):
'''
ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇੱਕ ਪੂਰਨ ਅੰਕ a ਲੈਂਦਾ ਹੈ ਅਤੇ ਜੇਕਰ ਇਹ ਪੂਰਨ ਅੰਕ ਕਿਸੇ ਪੂਰਨ ਅੰਕ ਦਾ ਘਣ (cube) ਹੈ ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਨੋਟ: ਤੁਸੀਂ ਮੰਨ ਸਕਦੇ ਹੋ ਕਿ ਇਨਪੁਟ ਹਮੇਸ਼ਾ ਵੈਧ ਹੈ।
ਉਦਾਹਰਨਾਂ:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
iscub... |
def iscube(a):
'''
एकं फलनं लिखन्तु यत् पूर्णाङ्कं a स्वीकरोति तथा च यदि अयम् पूर्णाङ्कः
कस्यचित् पूर्णाङ्कस्य घनः भवति तर्हि True प्रत्यानयति।
टिप्पणी: भवन्तः कल्पयितुं शक्नुवन्ति यत् निवेशः सर्वदा मान्यः अस्ति।
उदाहरणानि:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
... |
def iscube(a):
'''
ஒரு முழு எண் a-ஐ எடுத்துக்கொண்டு, இந்த முழு எண் ஏதேனும் ஒரு முழு எண்ணின் கனமாக (cube) இருந்தால் True என்பதைத் திருப்பியளிக்கும் ஒரு சார்பை எழுதுங்கள்.
குறிப்பு: உள்ளீடு எப்போதும் செல்லுபடியானது என நீங்கள் எடுத்துக்கொள்ளலாம்.
எடுத்துக்காட்டுகள்:
iscube(1) ==> True
iscube(2) ==... |
def iscube(a):
'''
ఒక పూర్ణాంకం a ని తీసుకుని, ఈ పూర్ణాంకం ఏదైనా ఒక పూర్ణాంకం యొక్క ఘనం (cube) అయితే True ని రిటర్న్ చేసే
ఫంక్షన్ను రాయండి.
గమనిక: ఇన్పుట్ ఎల్లప్పుడూ చెల్లుబాటు అయ్యేదిగా మీరు భావించవచ్చు.
ఉదాహరణలు:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube... |
def iscube(a):
'''
ایک ایسا فنکشن لکھیں جو ایک integer a لیتا ہے اور اگر یہ integer
کسی integer نمبر کا مکعب (cube) ہو تو True واپس کرتا ہے۔
نوٹ: آپ فرض کر سکتے ہیں کہ ان پٹ ہمیشہ درست ہے۔
مثالیں:
iscube(1) ==> True
iscube(2) ==> False
iscube(-1) ==> True
iscube(64) ==> True
isc... |
HumanEval/78 |
def hex_key(num):
"""You have been tasked to write a function that receives
a hexadecimal number as a string and counts the number of hexadecimal
digits that are primes (prime number, or a prime, is a natural number
greater than 1 that is not a product of two smaller natural numbers).
Hexadecima... | primes = ('2', '3', '5', '7', 'B', 'D')
total = 0
for i in range(0, len(num)):
if num[i] in primes:
total += 1
return total
| def check(candidate):
# Check some simple cases
assert candidate("AB") == 1, "First test error: " + str(candidate("AB"))
assert candidate("1077E") == 2, "Second test error: " + str(candidate("1077E"))
assert candidate("ABED1A33") == 4, "Third test error: " + str(candidate("ABED1A33"))
... | hex_key |
def hex_key(num):
"""আপোনাক এটা ফলন লিখিবলৈ দিয়া হৈছে যিয়ে এটা hexadecimal
সংখ্যাক string হিচাপে গ্ৰহণ কৰে আৰু মৌলিক সংখ্যা হোৱা hexadecimal
অংকসমূহৰ সংখ্যা গণনা কৰে (মৌলিক সংখ্যা, বা prime, হ'ল 1-তকৈ ডাঙৰ এটা
স্বাভাৱিক সংখ্যা যি দুটা সৰু স্বাভাৱিক সংখ্যাৰ গুণফল নহয়)।
Hexadecimal অংকসমূহ হ'ল ... |
def hex_key(num):
"""আপনাকে এমন একটি ফাংশন লেখার দায়িত্ব দেওয়া হয়েছে যা একটি স্ট্রিং হিসেবে
একটি হেক্সাডেসিমেল সংখ্যা গ্রহণ করে এবং মৌলিক সংখ্যা এমন হেক্সাডেসিমেল
অঙ্কের সংখ্যা গণনা করে (মৌলিক সংখ্যা হলো 1-এর চেয়ে বড় একটি স্বাভাবিক সংখ্যা
যা দুটি ছোট স্বাভাবিক সংখ্যার গুণফল নয়)।
হেক্সাডেসি... |
def hex_key(num):
"""તમારે એક એવું ફંક્શન લખવાનું છે જે હેક્સાડેસિમલ નંબરને સ્ટ્રિંગ તરીકે
મેળવે છે અને અવિભાજ્ય (prime) હોય તેવા હેક્સાડેસિમલ અંકોની સંખ્યા ગણે છે
(અવિભાજ્ય સંખ્યા, અથવા પ્રાઇમ, એ 1 કરતાં મોટી પ્રાકૃતિક સંખ્યા છે જે બે નાની
પ્રાકૃતિક સંખ્યાઓનો ગુણાકાર નથી).
હેક્સાડેસિમલ અંકો 0, 1, ... |
def hex_key(num):
"""आपको एक ऐसा फ़ंक्शन लिखने का कार्य दिया गया है जो स्ट्रिंग के रूप में एक
हेक्साडेसिमल संख्या प्राप्त करता है और उन हेक्साडेसिमल अंकों की संख्या गिनता है
जो अभाज्य (prime) हैं (अभाज्य संख्या, या एक प्राइम, 1 से बड़ी वह प्राकृतिक संख्या
है जो दो छोटी प्राकृतिक संख्याओं का गुणनफल न... |
def hex_key(num):
"""hexadecimal ಸಂಖ್ಯೆಯನ್ನು string ಆಗಿ ಸ್ವೀಕರಿಸುವ ಮತ್ತು ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಗಳಾಗಿರುವ
hexadecimal ಅಂಕೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸುವ ಫಂಕ್ಷನ್ ಬರೆಯುವ ಕಾರ್ಯವನ್ನು ನಿಮಗೆ ನೀಡಲಾಗಿದೆ
(ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆ, ಅಥವಾ prime, ಎಂಬುದು 1ಕ್ಕಿಂತ ದೊಡ್ಡದಾದ ಹಾಗೂ ಎರಡು ಸಣ್ಣ ಸ್ವಾಭಾವಿಕ ಸಂಖ್ಯೆಗಳ
ಗುಣಲಬ್ಧವಲ್ಲದ ಸ್ವಾಭಾವಿಕ ಸಂಖ್ಯೆಯಾಗಿದೆ).
... |
def hex_key(num):
"""ഒരു സ്ട്രിംഗ് ആയി ഒരു ഹെക്സാഡെസിമൽ സംഖ്യ സ്വീകരിക്കുകയും അതിൽ പ്രൈം
നമ്പറുകൾ (പ്രൈം നമ്പർ, അഥവാ അഭാജ്യ സംഖ്യ, എന്നാൽ 1-നേക്കാൾ വലിയതും രണ്ട് ചെറിയ സ്വാഭാവിക
സംഖ്യകളുടെ ഗുണനഫലമല്ലാത്തതുമായ ഒരു സ്വാഭാവിക സംഖ്യയാണ്) ആയ ഹെക്സാഡെസിമൽ
അക്കങ്ങളുടെ എണ്ണം കണക്കാക്കുകയും ചെയ്യുന്ന ഒരു ഫംഗ... |
def hex_key(num):
"""तुम्हाला एक असे फंक्शन लिहायचे आहे जे स्ट्रिंग म्हणून हेक्साडेसिमल (hexadecimal)
संख्या स्वीकारते आणि मूळ संख्या (prime numbers) असणाऱ्या हेक्साडेसिमल अंकांचे प्रमाण
मोजते (मूळ संख्या, किंवा प्राइम, ही 1 पेक्षा मोठी नैसर्गिक संख्या असते जी दोन लहान
नैसर्गिक संख्यांचा गुणाकार नसते).... |
def hex_key(num):
"""तपाईंलाई एउटा यस्तो function लेख्ने जिम्मेवारी दिइएको छ जसले एउटा hexadecimal
सङ्ख्या string को रूपमा लिन्छ र prime (अभाज्य) रहेका hexadecimal digit हरूको
सङ्ख्या गणना गर्छ (prime number वा prime, 1 भन्दा ठूलो यस्तो प्राकृतिक सङ्ख्या
हो जुन दुईवटा साना प्राकृतिक सङ्ख्याहरूको गुण... |
def hex_key(num):
"""ଆପଣଙ୍କୁ ଏପରି ଏକ ଫଙ୍କସନ୍ ଲେଖିବାକୁ କୁହାଯାଇଛି ଯାହା ଏକ hexadecimal
ସଂଖ୍ୟାକୁ string ଭାବରେ ଗ୍ରହଣ କରେ ଏବଂ ମୌଳିକ (prime) ହୋଇଥିବା hexadecimal
digit ଗୁଡ଼ିକର ସଂଖ୍ୟା ଗଣନା କରେ (ମୌଳିକ ସଂଖ୍ୟା ବା prime number ହେଉଛି 1
ଠାରୁ ବଡ଼ ଏକ ପ୍ରାକୃତିକ ସଂଖ୍ୟା ଯାହା ଦୁଇଟି ଛୋଟ ପ୍ରାକୃତିକ ସଂଖ୍ୟାର ଗୁଣଫଳ ନୁହେଁ)।
... |
def hex_key(num):
"""ਤੁਹਾਨੂੰ ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖਣ ਦਾ ਕੰਮ ਸੌਂਪਿਆ ਗਿਆ ਹੈ ਜੋ ਇੱਕ ਹੈਕਸਾਡੈਸੀਮਲ
ਸੰਖਿਆ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਜੋਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਹੈਕਸਾਡੈਸੀਮਲ
ਅੰਕਾਂ ਦੀ ਗਿਣਤੀ ਕਰਦਾ ਹੈ ਜੋ ਅਭਾਜ (prime) ਹਨ (ਅਭਾਜ ਸੰਖਿਆ, ਜਾਂ ਇੱਕ ਪ੍ਰਾਈਮ, 1
ਤੋਂ ਵੱਡੀ ਅਜਿਹੀ ਪ੍ਰਾਕਿਰਤਿਕ ਸੰਖਿਆ ਹੁੰਦੀ ਹੈ ਜੋ ਦੋ ਛੋਟੀਆਂ ਪ੍ਰਾਕਿਰਤਿਕ ਸੰਖਿਆਵਾ... |
def hex_key(num):
"""भवता एकं फलनं (function) लेखनीयं यत् षोडशाधारीयसङ्ख्यां सूत्ररूपेण (string)
स्वीकरोति तथा च अभाज्यसङ्ख्यारूपेण वर्तमानानां षोडशाधारीयाङ्कानां
सङ्ख्यां गणयति (अभाज्यसङ्ख्या, अर्थात् prime, 1 तः अधिका सा प्राकृतसङ्ख्या
अस्ति या द्वयोः लघुतरयोः प्राकृतसङ्ख्ययोः गुणनफलं न भवति)।
... |
def hex_key(num):
"""ஒரு பதினாறும எண்ணை (hexadecimal number) string வடிவில் பெற்று,
பகா எண்களாக (primes) இருக்கும் பதினாறும இலக்கங்களின் எண்ணிக்கையைக் கணக்கிடும்
ஒரு செயற்கூறை எழுதுவது உங்கள் பணியாகும் (பகா எண் என்பது 1-ஐ விடப் பெரிய,
இரண்டு சிறிய இயல் எண்களின் பெருக்கற்பலனாக அமையாத ஓர் இயல் எண் ஆகு... |
def hex_key(num):
"""ఒక హెక్సాడెసిమల్ సంఖ్యను స్ట్రింగ్ రూపంలో స్వీకరించి, ప్రధాన సంఖ్యలైన
(ప్రధాన సంఖ్య లేదా ప్రైమ్ అనేది 1 కంటే పెద్దదైన సహజ సంఖ్య మరియు
రెండు చిన్న సహజ సంఖ్యల లబ్దం కాదు) హెక్సాడెసిమల్ అంకెల సంఖ్యను లెక్కించే
ఒక ఫంక్షన్ను మీరు రాయాలి.
హెక్సాడెసిమల్ అంకెలు: 0, 1, 2, 3, 4, 5, 6... |
def hex_key(num):
"""آپ کو ایک ایسا فنکشن لکھنے کا کام سونپا گیا ہے جو ایک ہیکساڈیسیمل نمبر
بطور اسٹرنگ وصول کرتا ہے اور ایسے ہیکساڈیسیمل ہندسوں کی تعداد شمار کرتا ہے جو مفرد اعداد (prime numbers) ہیں
(مفرد عدد، یا prime، 1 سے بڑا وہ قدرتی عدد ہوتا ہے جو دو چھوٹے قدرتی اعداد کا حاصل ضرب نہ ہو)۔
ہیکساڈی... |
HumanEval/79 |
def decimal_to_binary(decimal):
"""You will be given a number in decimal form and your task is to convert it to
binary format. The function should return a string, with each character representing a binary
number. Each character in the string will be '0' or '1'.
There will be an extra couple of charac... | return "db" + bin(decimal)[2:] + "db"
| def check(candidate):
# Check some simple cases
assert candidate(0) == "db0db"
assert candidate(32) == "db100000db"
assert candidate(103) == "db1100111db"
assert candidate(15) == "db1111db", "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to wor... | decimal_to_binary |
def decimal_to_binary(decimal):
"""আপোনাক দশমিক ৰূপত এটা সংখ্যা দিয়া হ'ব আৰু আপোনাৰ কাম হ'ল ইয়াক
বাইনাৰী ফৰ্মেটলৈ ৰূপান্তৰ কৰা। ফাংচনটোৱে এটা ষ্ট্ৰিং ৰিটাৰ্ন কৰিব লাগে, য'ত প্ৰতিটো আখৰে এটা বাইনাৰী
সংখ্যা প্ৰতিনিধিত্ব কৰে। ষ্ট্ৰিংটোৰ প্ৰতিটো আখৰ '0' বা '1' হ'ব।
ষ্ট্ৰিংটোৰ আৰম্ভণিতে আৰু শেষত 'db' নাম... |
def decimal_to_binary(decimal):
"""আপনাকে দশমিক (decimal) আকারে একটি সংখ্যা দেওয়া হবে এবং আপনার কাজ হলো এটিকে
বাইনারি ফরম্যাটে রূপান্তর করা। ফাংশনটির একটি স্ট্রিং রিটার্ন করা উচিত, যেখানে প্রতিটি ক্যারেক্টার একটি বাইনারি
সংখ্যা উপস্থাপন করবে। স্ট্রিংটির প্রতিটি ক্যারেক্টার হবে '0' অথবা '1'।
স্ট্রিংটি... |
def decimal_to_binary(decimal):
"""તમને દશાંશ (decimal) સ્વરૂપમાં એક સંખ્યા આપવામાં આવશે અને તમારું કાર્ય તેને બાઈનરી
(binary) સ્વરૂપમાં રૂપાંતરિત કરવાનું છે. વિધેયે એક string પરત કરવી જોઈએ, જેમાં દરેક અક્ષર એક બાઈનરી
સંખ્યા દર્શાવે છે. string માંનો દરેક અક્ષર '0' અથવા '1' હશે.
string ની શરૂઆતમાં અને ... |
def decimal_to_binary(decimal):
"""आपको दशमलव (decimal) रूप में एक संख्या दी जाएगी और आपका कार्य इसे
बाइनरी प्रारूप में बदलना है। फ़ंक्शन को एक स्ट्रिंग लौटानी चाहिए, जिसमें प्रत्येक वर्ण एक बाइनरी
संख्या का प्रतिनिधित्व करता हो। स्ट्रिंग में प्रत्येक वर्ण '0' या '1' होगा।
स्ट्रिंग की शुरुआत और अंत मे... |
def decimal_to_binary(decimal):
"""ನಿಮಗೆ decimal ರೂಪದಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ನೀಡಲಾಗುತ್ತದೆ ಮತ್ತು ಅದನ್ನು binary ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುವುದು ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ. ಫಂಕ್ಷನ್ ಒಂದು string ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡಬೇಕು, ಇದರಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವು binary ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. string ನಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರವು '0' ಅಥವಾ '1' ಆಗಿರುತ್ತದೆ.
... |
def decimal_to_binary(decimal):
"""നിങ്ങൾക്ക് decimal രൂപത്തിലുള്ള ഒരു സംഖ്യ നൽകും, അതിനെ binary ഫോർമാറ്റിലേക്ക്
മാറ്റുക എന്നതാണ് നിങ്ങളുടെ ചുമതല. ഫംഗ്ഷൻ ഒരു string റിട്ടേൺ ചെയ്യണം, അതിലെ ഓരോ ക്യാരക്ടറും ഒരു binary
സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു. string-ലെ ഓരോ ക്യാരക്ടറും '0' അല്ലെങ്കിൽ '1' ആയിരിക്കും.
... |
def decimal_to_binary(decimal):
"""तुम्हाला decimal स्वरूपातील एक संख्या दिली जाईल आणि तुमचे कार्य तिचे
binary स्वरूपात रूपांतर करणे हे आहे. या फंक्शनने एक string परत केली पाहिजे, ज्यातील प्रत्येक कॅरेक्टर binary
संख्या दर्शवेल. string मधील प्रत्येक कॅरेक्टर '0' किंवा '1' असेल.
string च्या सुरुवातीला ... |
def decimal_to_binary(decimal):
"""तपाईंलाई decimal रूपमा एउटा सङ्ख्या दिइनेछ र तपाईंको काम यसलाई binary ढाँचामा
रूपान्तरण गर्नु हो। यो function ले एउटा string फिर्ता गर्नुपर्छ, जसमा प्रत्येक character ले binary
सङ्ख्यालाई प्रतिनिधित्व गर्दछ। string को प्रत्येक character '0' वा '1' हुनेछ।
string को सु... |
def decimal_to_binary(decimal):
"""ଆପଣଙ୍କୁ ଦଶମିକ (decimal) ରୂପରେ ଏକ ସଂଖ୍ୟା ଦିଆଯିବ ଏବଂ ଆପଣଙ୍କର କାର୍ଯ୍ୟ ହେଉଛି ଏହାକୁ
ବାଇନାରୀ (binary) ଫର୍ମାଟ୍ରେ ପରିବର୍ତ୍ତନ କରିବା। ଫଙ୍କସନ୍ଟି ଏକ string ଫେରାଇବା ଉଚିତ୍, ଯେଉଁଥିରେ ପ୍ରତ୍ୟେକ character ଏକ ବାଇନାରୀ
ସଂଖ୍ୟାକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବ। String ରେ ଥିବା ପ୍ରତ୍ୟେକ character '0' କିମ୍... |
def decimal_to_binary(decimal):
"""ਤੁਹਾਨੂੰ ਦਸ਼ਮਲਵ (decimal) ਰੂਪ ਵਿੱਚ ਇੱਕ ਸੰਖਿਆ ਦਿੱਤੀ ਜਾਵੇਗੀ ਅਤੇ ਤੁਹਾਡਾ ਕੰਮ ਇਸਨੂੰ ਬਾਈਨਰੀ (binary) ਫਾਰਮੈਟ ਵਿੱਚ ਬਦਲਣਾ ਹੈ। ਫੰਕਸ਼ਨ ਨੂੰ ਇੱਕ string ਵਾਪਸ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਹਰੇਕ character ਇੱਕ ਬਾਈਨਰੀ ਨੰਬਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੋਵੇ। string ਵਿਚਲਾ ਹਰੇਕ character '0' ਜਾਂ '1' ਹੋਵੇਗਾ।
string ਦੇ... |
def decimal_to_binary(decimal):
"""भवते दशमलवस्वरूपे एका सङ्ख्या दीयते तथा च भवतः कार्यं तां द्वयाधारीस्वरूपे
परिवर्तयितुम् अस्ति। फलनम् एकां string प्रतिदद्यात्, यस्याः प्रत्येकं वर्णः द्वयाधारीसङ्ख्यां
निरूपयति। string मध्ये प्रत्येकं वर्णः '0' वा '1' वा भविष्यति।
string इत्यस्याः आरम्भे अन्ते च 'db... |
def decimal_to_binary(decimal):
"""பதின்ம (decimal) வடிவில் ஒரு எண் உங்களுக்கு வழங்கப்படும், அதை பைனரி வடிவத்திற்கு மாற்றுவதே உங்கள் பணி. இந்த function ஒரு string-ஐத் திருப்பியளிக்க வேண்டும், அதில் உள்ள ஒவ்வொரு character-உம் ஒரு பைனரி எண்ணைக் குறிக்கும். string-இல் உள்ள ஒவ்வொரு character-உம் '0' அல்லது '1' ஆக இருக... |
def decimal_to_binary(decimal):
"""మీకు దశాంశ (decimal) రూపంలో ఒక సంఖ్య ఇవ్వబడుతుంది మరియు దానిని బైనరీ (binary) ఫార్మాట్లోకి
మార్చడం మీ పని. ఈ ఫంక్షన్ ప్రతి క్యారెక్టర్ ఒక బైనరీ సంఖ్యను సూచించేలా ఒక స్ట్రింగ్ను రిటర్న్ చేయాలి.
స్ట్రింగ్లోని ప్రతి క్యారెక్టర్ '0' లేదా '1' అయి ఉంటుంది.
స్ట్రింగ్ ప్ర... |
def decimal_to_binary(decimal):
"""آپ کو اعشاری (decimal) شکل میں ایک عدد دیا جائے گا اور آپ کا کام اسے بائنری (binary)
فارمیٹ میں تبدیل کرنا ہے۔ فنکشن کو ایک string واپس کرنی چاہیے، جس کا ہر کریکٹر ایک بائنری
نمبر کی نمائندگی کرتا ہو۔ string کا ہر کریکٹر '0' یا '1' ہوگا۔
string کے شروع اور آخر میں اض... |
HumanEval/80 |
def is_happy(s):
"""You are given a string s.
Your task is to check if the string is happy or not.
A string is happy if its length is at least 3 and every 3 consecutive letters are distinct
For example:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => ... | if len(s) < 3:
return False
for i in range(len(s) - 2):
if s[i] == s[i+1] or s[i+1] == s[i+2] or s[i] == s[i+2]:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate("a") == False , "a"
assert candidate("aa") == False , "aa"
assert candidate("abcd") == True , "abcd"
assert candidate("aabb") == False , "aabb"
assert candidate("adb") == True , "adb"
assert candidate("xyy") == False , "xyy"
... | is_happy |
def is_happy(s):
"""আপোনাক এটা ষ্ট্ৰিং s দিয়া হৈছে।
আপোনাৰ কাম হ'ল ষ্ট্ৰিংটো happy হয় নে নহয় সেয়া পৰীক্ষা কৰা।
এটা ষ্ট্ৰিং happy হয় যদিহে ইয়াৰ দৈৰ্ঘ্য কমেও 3 হয় আৰু প্ৰতিটো 3 টা ক্ৰমিক বৰ্ণ পৃথক হয়
উদাহৰণস্বৰূপ:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
i... |
def is_happy(s):
"""আপনাকে একটি স্ট্রিং s দেওয়া হয়েছে।
আপনার কাজ হলো স্ট্রিংটি happy কি না তা পরীক্ষা করা।
একটি স্ট্রিং happy হবে যদি এর দৈর্ঘ্য কমপক্ষে 3 হয় এবং প্রতি 3টি ধারাবাহিক অক্ষর ভিন্ন হয়
উদাহরণস্বরূপ:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_hap... |
def is_happy(s):
"""તમને એક string s આપવામાં આવેલ છે.
તમારું કાર્ય એ તપાસવાનું છે કે string happy છે કે નહીં.
એક string ત્યારે happy ગણાય જો તેની લંબાઈ ઓછામાં ઓછી 3 હોય અને દરેક 3 સતત અક્ષરો અલગ (distinct) હોય
ઉદાહરણ તરીકે:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
... |
def is_happy(s):
"""आपको एक स्ट्रिंग s दी गई है।
आपका कार्य यह जांचना है कि स्ट्रिंग happy है या नहीं।
एक स्ट्रिंग happy तब होती है यदि उसकी लंबाई कम से कम 3 हो और प्रत्येक 3 लगातार अक्षर भिन्न हों
उदाहरण के लिए:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy... |
def is_happy(s):
"""ನಿಮಗೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ s ಅನ್ನು ನೀಡಲಾಗಿದೆ.
ಸ್ಟ್ರಿಂಗ್ happy ಆಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುವುದು ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ.
ಒಂದು ಸ್ಟ್ರಿಂಗ್ನ ಉದ್ದವು ಕನಿಷ್ಠ 3 ಆಗಿದ್ದರೆ ಮತ್ತು ಪ್ರತಿ 3 ಅನುಕ್ರಮ ಅಕ್ಷರಗಳು ವಿಭಿನ್ನವಾಗಿದ್ದರೆ ಆ ಸ್ಟ್ರಿಂಗ್ happy ಆಗಿರುತ್ತದೆ
ಉದಾಹರಣೆಗೆ:
is_happy(a) => False
is_ha... |
def is_happy(s):
"""നിങ്ങൾക്ക് s എന്നൊരു സ്ട്രിംഗ് നൽകിയിരിക്കുന്നു.
ഈ സ്ട്രിംഗ് happy ആണോ അല്ലയോ എന്ന് പരിശോധിക്കുകയാണ് നിങ്ങളുടെ ദൗത്യം.
ഒരു സ്ട്രിംഗിന്റെ നീളം കുറഞ്ഞത് 3 ആയിരിക്കുകയും തുടർച്ചയായുള്ള ഓരോ 3 അക്ഷരങ്ങളും വ്യത്യസ്തമായിരിക്കുകയും ചെയ്താൽ ആ സ്ട്രിംഗ് happy ആണ്
ഉദാഹരണത്തിന്:
is_happy(a)... |
def is_happy(s):
"""तुम्हाला एक स्ट्रिंग s दिली आहे.
स्ट्रिंग happy आहे की नाही हे तपासणे हे तुमचे कार्य आहे.
जर स्ट्रिंगची लांबी किमान 3 असेल आणि प्रत्येक 3 सलग अक्षरे भिन्न असतील, तर ती स्ट्रिंग happy मानली जाते
उदाहरणार्थ:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True... |
def is_happy(s):
"""तपाईंलाई एउटा string s दिइएको छ।
तपाईंको काम उक्त string happy छ कि छैन जाँच गर्नु हो।
एउटा string happy हुन्छ यदि यसको लम्बाइ कम्तीमा 3 छ र प्रत्येक 3 लगातार अक्षरहरू फरक छन्
उदाहरणका लागि:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(a... |
def is_happy(s):
"""ଆପଣଙ୍କୁ ଏକ string s ଦିଆଯାଇଛି।
ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି string ଟି happy କି ନୁହେଁ ତାହା ଯାଞ୍ଚ କରିବା।
ଗୋଟିଏ string happy ହେବ ଯଦି ଏହାର ଲମ୍ବ ଅତିକମରେ 3 ହୋଇଥିବ ଏବଂ ପ୍ରତ୍ୟେକ 3 ଟି କ୍ରମାଗତ ଅକ୍ଷର ପରସ୍ପରଠାରୁ ଭିନ୍ନ (distinct) ହୋଇଥିବ
ଉଦାହରଣ ସ୍ୱରୂପ:
is_happy(a) => False
is_happy(aa) => False
... |
def is_happy(s):
"""ਤੁਹਾਨੂੰ ਇੱਕ string s ਦਿੱਤੀ ਗਈ ਹੈ।
ਤੁਹਾਡਾ ਕੰਮ ਇਹ ਜਾਂਚਣਾ ਹੈ ਕਿ string happy ਹੈ ਜਾਂ ਨਹੀਂ।
ਇੱਕ string happy ਹੁੰਦੀ ਹੈ ਜੇਕਰ ਇਸਦੀ ਲੰਬਾਈ ਘੱਟੋ-ਘੱਟ 3 ਹੋਵੇ ਅਤੇ ਹਰੇਕ ਲਗਾਤਾਰ 3 ਅੱਖਰ ਵੱਖਰੇ (distinct) ਹੋਣ
ਉਦਾਹਰਣ ਵਜੋਂ:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
... |
def is_happy(s):
"""भवते एकं string s दत्तम् अस्ति।
भवतः कार्यम् एतत् परीक्षितुम् अस्ति यत् string happy अस्ति वा न वा।
एकं string तदा happy भवति यदि अस्य दैर्घ्यं न्यूनतमेन 3 भवति तथा च प्रत्येकं 3 क्रमिक-अक्षराणि परस्परं भिन्नानि भवन्ति
यथा:
is_happy(a) => False
is_happy(aa) => False
is_h... |
def is_happy(s):
"""உங்களுக்கு ஒரு சரம் s கொடுக்கப்பட்டுள்ளது.
அந்தச் சரம் மகிழ்ச்சியானதா (happy) இல்லையா என்பதைச் சரிபார்ப்பதே உங்கள் பணியாகும்.
ஒரு சரத்தின் நீளம் குறைந்தபட்சம் 3 ஆகவும், அடுத்தடுத்து வரும் ஒவ்வொரு 3 எழுத்துகளும் தனித்துவமானவையாகவும் இருந்தால், அந்தச் சரம் மகிழ்ச்சியானது (happy) ஆகும்
... |
def is_happy(s):
"""మీకు ఒక స్ట్రింగ్ s ఇవ్వబడింది.
ఆ స్ట్రింగ్ happy అవునో కాదో తనిఖీ చేయడం మీ పని.
ఒక స్ట్రింగ్ యొక్క పొడవు కనీసం 3 ఉండి, ప్రతి 3 వరుస అక్షరాలు విభిన్నంగా ఉంటే అది happy అవుతుంది
ఉదాహరణకు:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb)... |
def is_happy(s):
"""آپ کو ایک سٹرنگ s دی گئی ہے۔
آپ کا کام یہ چیک کرنا ہے کہ سٹرنگ happy ہے یا نہیں۔
ایک سٹرنگ happy ہوتی ہے اگر اس کی لمبائی کم از کم 3 ہو اور ہر 3 مسلسل حروف مختلف ہوں
مثال کے طور پر:
is_happy(a) => False
is_happy(aa) => False
is_happy(abcd) => True
is_happy(aabb) => F... |
HumanEval/81 |
def numerical_letter_grade(grades):
"""It is the last week of the semester and the teacher has to give the grades
to students. The teacher has been making her own algorithm for grading.
The only problem is, she has lost the code she used for grading.
She has given you a list of GPAs for some students a... |
letter_grade = []
for gpa in grades:
if gpa == 4.0:
letter_grade.append("A+")
elif gpa > 3.7:
letter_grade.append("A")
elif gpa > 3.3:
letter_grade.append("A-")
elif gpa > 3.0:
letter_grade.append("B+")
elif gpa > 2.7:
... | def check(candidate):
# Check some simple cases
assert candidate([4.0, 3, 1.7, 2, 3.5]) == ['A+', 'B', 'C-', 'C', 'A-']
assert candidate([1.2]) == ['D+']
assert candidate([0.5]) == ['D-']
assert candidate([0.0]) == ['E']
assert candidate([1, 0.3, 1.5, 2.8, 3.3]) == ['D', 'D-', 'C-', 'B', 'B+']
... | numerical_letter_grade |
def numerical_letter_grade(grades):
"""এইটো ছেমিষ্টাৰৰ অন্তিম সপ্তাহ আৰু শিক্ষকে ছাত্ৰ-ছাত্ৰীসকলক গ্ৰেডসমূহ দিব লাগিব।
শিক্ষকে গ্ৰেডিঙৰ বাবে নিজাকৈ এটা এলগৰিথম প্ৰস্তুত কৰি আছিল।
একমাত্ৰ সমস্যাটো হ'ল, তেওঁ গ্ৰেডিঙৰ বাবে ব্যৱহাৰ কৰা ক'ডটো হেৰুৱাই পেলাইছে।
তেওঁ আপোনাক কিছুমান ছাত্ৰ-ছাত্ৰীৰ GPA-ৰ এখন তালি... |
def numerical_letter_grade(grades):
"""এটি সেমিস্টারের শেষ সপ্তাহ এবং শিক্ষককে শিক্ষার্থীদের গ্রেড প্রদান করতে হবে।
শিক্ষক গ্রেডিংয়ের জন্য নিজের একটি অ্যালগরিদম তৈরি করছিলেন।
একমাত্র সমস্যা হলো, তিনি গ্রেডিংয়ের জন্য যে কোডটি ব্যবহার করেছিলেন তা হারিয়ে ফেলেছেন।
তিনি আপনাকে কিছু শিক্ষার্থীর GPA-এর একট... |
def numerical_letter_grade(grades):
"""આ સેમેસ્ટરનું છેલ્લું અઠવાડિયું છે અને શિક્ષકે વિદ્યાર્થીઓને ગ્રેડ
આપવાના છે. શિક્ષક ગ્રેડિંગ માટે પોતાનું અલ્ગોરિધમ બનાવી રહ્યા હતા.
એકમાત્ર સમસ્યા એ છે કે, તેઓએ ગ્રેડિંગ માટે વાપરેલો કોડ ખોવાઈ ગયો છે.
તેઓએ તમને કેટલાક વિદ્યાર્થીઓના GPA ની યાદી આપી છે અને તમારે ન... |
def numerical_letter_grade(grades):
"""यह सेमेस्टर का अंतिम सप्ताह है और शिक्षिका को छात्रों को ग्रेड देने हैं।
शिक्षिका ग्रेडिंग के लिए अपना खुद का एल्गोरिदम बना रही थीं।
एकमात्र समस्या यह है कि उन्होंने वह कोड खो दिया है जिसका उपयोग वह ग्रेडिंग के लिए करती थीं।
उन्होंने आपको कुछ छात्रों के GPA की एक ... |
def numerical_letter_grade(grades):
"""ಇದು ಸೆಮಿಸ್ಟರ್ನ ಕೊನೆಯ ವಾರ ಮತ್ತು ಶಿಕ್ಷಕರು ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಗ್ರೇಡ್ಗಳನ್ನು ನೀಡಬೇಕಾಗಿದೆ. ಶಿಕ್ಷಕರು ಗ್ರೇಡಿಂಗ್ಗಾಗಿ ತಮ್ಮದೇ ಆದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ರಚಿಸುತ್ತಿದ್ದರು.
ಏಕೈಕ ಸಮಸ್ಯೆಯೆಂದರೆ, ಗ್ರೇಡಿಂಗ್ ಮಾಡಲು ಬಳಸಿದ ಕೋಡ್ ಅನ್ನು ಅವರು ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ.
ಅವರು ನಿಮಗೆ ಕೆಲವು ವಿದ್ಯಾರ್ಥಿಗಳ GPA ಗಳ ಪಟ್ಟಿ... |
def numerical_letter_grade(grades):
"""ഇത് സെമസ്റ്ററിന്റെ അവസാന ആഴ്ചയാണ്, അധ്യാപിക വിദ്യാർത്ഥികൾക്ക് ഗ്രേഡുകൾ
നൽകേണ്ടതുണ്ട്. ഗ്രേഡിംഗിനായി അധ്യാപിക സ്വന്തമായി ഒരു അൽഗോരിതം ഉണ്ടാക്കുകയായിരുന്നു.
ഒരേയൊരു പ്രശ്നം, ഗ്രേഡിംഗിനായി അവർ ഉപയോഗിച്ചിരുന്ന കോഡ് നഷ്ടപ്പെട്ടു എന്നതാണ്.
അവർ നിങ്ങൾക്ക് ചില വിദ്യാർത്ഥി... |
def numerical_letter_grade(grades):
"""सत्राचा (semester) हा शेवटचा आठवडा आहे आणि शिक्षिकेला विद्यार्थ्यांना श्रेणी (grades)
द्यायच्या आहेत. शिक्षिका श्रेणी देण्यासाठी स्वतःचा अल्गोरिदम तयार करत होती.
फक्त अडचण अशी आहे की, तिने श्रेणी देण्यासाठी वापरलेला कोड गमावला आहे.
तिने तुम्हाला काही विद्यार्थ्यां... |
def numerical_letter_grade(grades):
"""यो सेमेस्टरको अन्तिम हप्ता हो र शिक्षकले विद्यार्थीहरूलाई ग्रेडहरू दिनुपर्नेछ। शिक्षकले ग्रेडिङको लागि आफ्नै एल्गोरिदम बनाउँदै आउनुभएको थियो।
एकमात्र समस्या के छ भने, उहाँले ग्रेडिङको लागि प्रयोग गर्नुभएको कोड हराउनुभएको छ।
उहाँले तपाईंलाई केही विद्यार्थीहरूको GPA को ... |
def numerical_letter_grade(grades):
"""ଏହା ସେମିଷ୍ଟାରର ଶେଷ ସପ୍ତାହ ଏବଂ ଶିକ୍ଷକଙ୍କୁ ଛାତ୍ରଛାତ୍ରୀମାନଙ୍କୁ ଗ୍ରେଡ୍ ଦେବାକୁ ପଡ଼ିବ।
ଶିକ୍ଷକ ଗ୍ରେଡିଂ ପାଇଁ ନିଜର ଏକ ଆଲଗୋରିଦମ ତିଆରି କରୁଥିଲେ।
କେବଳ ସମସ୍ୟା ହେଉଛି, ସେ ଗ୍ରେଡିଂ ପାଇଁ ବ୍ୟବହାର କରୁଥିବା କୋଡ୍ ହରାଇ ଦେଇଛନ୍ତି।
ସେ ଆପଣଙ୍କୁ କିଛି ଛାତ୍ରଛାତ୍ରୀଙ୍କ GPA ର ଏକ ତାଲିକା ଦେଇଛନ୍ତି ଏବଂ ... |
def numerical_letter_grade(grades):
"""ਇਹ ਸਮੈਸਟਰ ਦਾ ਆਖ਼ਰੀ ਹਫ਼ਤਾ ਹੈ ਅਤੇ ਅਧਿਆਪਕ ਨੇ ਵਿਦਿਆਰਥੀਆਂ ਨੂੰ ਗ੍ਰੇਡ ਦੇਣੇ ਹਨ। ਅਧਿਆਪਕ
ਗ੍ਰੇਡਿੰਗ ਲਈ ਆਪਣਾ ਐਲਗੋਰਿਦਮ ਬਣਾ ਰਹੀ ਸੀ।
ਸਿਰਫ਼ ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ ਉਸਦਾ ਉਹ ਕੋਡ ਗੁਆਚ ਗਿਆ ਹੈ ਜੋ ਉਹ ਗ੍ਰੇਡਿੰਗ ਲਈ ਵਰਤਦੀ ਸੀ।
ਉਸਨੇ ਤੁਹਾਨੂੰ ਕੁਝ ਵਿਦਿਆਰਥੀਆਂ ਦੇ GPA ਦੀ ਇੱਕ ਸੂਚੀ ਦਿੱਤੀ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਹੇਠਾਂ... |
def numerical_letter_grade(grades):
"""सत्रस्य अन्तिमः सप्ताहः वर्तते तथा च शिक्षिकया छात्रेभ्यः श्रेणीः (grades) दातव्याः सन्ति।
शिक्षिका श्रेणीकरणार्थं स्वकीयं कलनविधिं (algorithm) रचयन्ती आसीत्।
केवलं समस्या इयं यत् सा श्रेणीकरणाय प्रयुक्तं कूटं (code) विस्मृतवती/नाशितवती।
तया भवते केषाञ्चन छात्राणा... |
def numerical_letter_grade(grades):
"""இது பருவத்தின் (semester) கடைசி வாரம், ஆசிரியர் மாணவர்களுக்கு கிரேடுகளை வழங்க வேண்டும்.
ஆசிரியர் கிரேடு வழங்குவதற்காகத் தனது சொந்த அல்காரிதத்தை உருவாக்கி வந்தார்.
ஒரே பிரச்சனை என்னவென்றால், அவர் கிரேடு வழங்கப் பயன்படுத்திய நிரலைத் தொலைத்துவிட்டார்.
அவர் சில மாணவர்... |
def numerical_letter_grade(grades):
"""ఇది సెమిస్టర్ చివరి వారం మరియు ఉపాధ్యాయురాలు విద్యార్థులకు గ్రేడ్లను ఇవ్వవలసి ఉంది. ఉపాధ్యాయురాలు గ్రేడింగ్ కోసం తన స్వంత అల్గారిథమ్ను రూపొందిస్తున్నారు.
ఒకే సమస్య ఏమిటంటే, ఆమె గ్రేడింగ్ కోసం ఉపయోగించిన కోడ్ను పోగొట్టుకున్నారు.
ఆమె మీకు కొంతమంది విద్యార్థుల GPAల జా... |
def numerical_letter_grade(grades):
"""یہ سمسٹر کا آخری ہفتہ ہے اور استانی کو طلباء کو گریڈز دینے ہیں۔
استانی گریڈنگ کے لیے اپنا الگورتھم بنا رہی تھی۔
صرف مسئلہ یہ ہے کہ اس کا وہ کوڈ گم ہو گیا ہے جو وہ گریڈنگ کے لیے استعمال کرتی تھی۔
اس نے آپ کو کچھ طلباء کے GPAs کی ایک لسٹ دی ہے اور آپ کو ایک ایسا
... |
HumanEval/82 |
def prime_length(string):
"""Write a function that takes a string and returns True if the string
length is a prime number or False otherwise
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
| l = len(string)
if l == 0 or l == 1:
return False
for i in range(2, l):
if l % i == 0:
return False
return True
| def check(candidate):
# Check some simple cases
assert candidate('Hello') == True
assert candidate('abcdcba') == True
assert candidate('kittens') == True
assert candidate('orange') == False
assert candidate('wow') == True
assert candidate('world') == True
assert candidate('MadaM') == Tr... | prime_length |
def prime_length(string):
"""এটা ফাংচন লিখক যিয়ে এটা string গ্ৰহণ কৰে আৰু stringটোৰ
দৈৰ্ঘ্য এটা মৌলিক সংখ্যা হ'লে True অথবা অন্যথা False ঘূৰাই দিয়ে
উদাহৰণ
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
|
def prime_length(string):
"""একটি ফাংশন লিখুন যা একটি string গ্রহণ করে এবং string-এর দৈর্ঘ্য একটি মৌলিক সংখ্যা হলে True অথবা অন্যথায় False রিটার্ন করে
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
|
def prime_length(string):
"""એવું ફંક્શન લખો જે એક string લે છે અને જો string ની લંબાઈ
અવિભાજ્ય સંખ્યા હોય તો True અથવા અન્યથા False પરત કરે છે
ઉદાહરણો
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
|
def prime_length(string):
"""एक ऐसा फ़ंक्शन लिखें जो एक स्ट्रिंग लेता है और यदि स्ट्रिंग की
लंबाई एक अभाज्य संख्या (prime number) है तो True लौटाता है अन्यथा False
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') =... |
def prime_length(string):
"""ಒಂದು string ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು string ನ ಉದ್ದವು ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೆ (prime number) True ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ False ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡುವ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಿರಿ
ಉದಾಹರಣೆಗಳು
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
... |
def prime_length(string):
"""ഒരു string സ്വീകരിച്ച്, string-ന്റെ നീളം ഒരു prime number ആണെങ്കിൽ True എന്നും
അല്ലെങ്കിൽ False എന്നും നൽകുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == Fals... |
def prime_length(string):
"""असे फंक्शन लिहा जे एक स्ट्रिंग घेते आणि स्ट्रिंगची लांबी मूळ संख्या (prime number)
असल्यास True किंवा अन्यथा False परत करते
उदाहरणे
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
... |
def prime_length(string):
"""एउटा function लेख्नुहोस् जसले एउटा string लिन्छ र यदि string को
लम्बाइ prime number हो भने True वा अन्यथा False फर्काउँछ
Examples
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
""... |
def prime_length(string):
"""ଗୋଟିଏ function ଲେଖନ୍ତୁ ଯାହା ଏକ string ଗ୍ରହଣ କରେ ଏବଂ ଯଦି string ର
length ଏକ prime number ହୋଇଥାଏ ତେବେ True କିମ୍ବା ଅନ୍ୟଥା False ଫେରାଏ
ଉଦାହରଣ
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == Fals... |
def prime_length(string):
"""ਇੱਕ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇੱਕ string ਲੈਂਦਾ ਹੈ ਅਤੇ ਜੇਕਰ string ਦੀ
ਲੰਬਾਈ ਇੱਕ prime number ਹੈ ਤਾਂ True ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਾਂ ਨਹੀਂ ਤਾਂ False
ਉਦਾਹਰਨਾਂ
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
... |
def prime_length(string):
"""एतादृशं फलनं लिखन्तु यत् string स्वीकरोति तथा यदि string-दैर्घ्यम् एका
अभाज्यसंख्या अस्ति तर्हि True अन्यथा False प्रत्यर्पयति
उदाहरणानि
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False... |
def prime_length(string):
"""ஒரு string-ஐப் பெற்று, string-இன் நீளம் ஒரு பகா எண்ணாக (prime number)
இருந்தால் True என்றும், இல்லையெனில் False என்றும் திருப்பியளிக்கும் ஒரு function-ஐ எழுதுக
எடுத்துக்காட்டுகள்
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') =... |
def prime_length(string):
"""ఒక స్ట్రింగ్ను తీసుకుని, స్ట్రింగ్ పొడవు ప్రధాన సంఖ్య అయితే True లేదా కాకపోతే False ని రిటర్న్ చేసే ఒక ఫంక్షన్ను రాయండి
ఉదాహరణలు
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
"""
|
def prime_length(string):
"""ایک ایسا فنکشن لکھیں جو ایک string لیتا ہے اور اگر string کی لمبائی
ایک prime number ہو تو True لوٹاتا ہے بصورت دیگر False
مثالیں
prime_length('Hello') == True
prime_length('abcdcba') == True
prime_length('kittens') == True
prime_length('orange') == False
""... |
HumanEval/83 |
def starts_one_ends(n):
"""
Given a positive integer n, return the count of the numbers of n-digit
positive integers that start or end with 1.
"""
| if n == 1: return 1
return 18 * (10 ** (n - 2))
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1) == 1
assert candidate(2) == 18
assert candidate(3) == 180
assert candidate(4) == 1800
assert candidate(5) == 18000
# Check some edge cases that ar... | starts_one_ends |
def starts_one_ends(n):
"""
এটা ধনাত্মক অখণ্ড সংখ্যা n দিয়া থাকিলে, 1 ৰে আৰম্ভ হোৱা বা 1 ৰে শেষ হোৱা n-অংকৰ
ধনাত্মক অখণ্ড সংখ্যাবোৰৰ গণনা ঘূৰাই দিয়ক।
"""
|
def starts_one_ends(n):
"""
একটি ধনাত্মক পূর্ণসংখ্যা n দেওয়া হলে, 1 দিয়ে শুরু অথবা শেষ হওয়া n-অঙ্কের
ধনাত্মক পূর্ণসংখ্যার মোট সংখ্যা রিটার্ন করুন।
"""
|
def starts_one_ends(n):
"""
ધન પૂર્ણાંક n આપેલ હોય, 1 થી શરૂ થતા અથવા 1 પર સમાપ્ત થતા n-અંકના
ધન પૂર્ણાંકોની સંખ્યા પરત કરો.
"""
|
def starts_one_ends(n):
"""
एक धनात्मक पूर्णांक n दिए जाने पर, 1 से शुरू होने वाले या 1 पर समाप्त होने वाले n-अंकों के धनात्मक पूर्णांकों की संख्या लौटाएं।
"""
|
def starts_one_ends(n):
"""
ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ n ಅನ್ನು ನೀಡಿದಾಗ, 1 ರಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಅಥವಾ ಕೊನೆಗೊಳ್ಳುವ n-ಅಂಕಿಯ
ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕಗಳ ಎಣಿಕೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ.
"""
|
def starts_one_ends(n):
"""
ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യ n നൽകിയാൽ, 1-ൽ ആരംഭിക്കുകയോ അവസാനിക്കുകയോ ചെയ്യുന്ന
n-അക്ക പോസിറ്റീവ് പൂർണ്ണസംഖ്യകളുടെ എണ്ണം റിട്ടേൺ ചെയ്യുക.
"""
|
def starts_one_ends(n):
"""
एक धन पूर्णांक n दिला असता, 1 ने सुरू होणाऱ्या किंवा 1 ने संपणाऱ्या
n-अंकी धन पूर्णांकांची संख्या परत करा.
"""
|
def starts_one_ends(n):
"""
एउटा धनात्मक पूर्णाङ्क n दिइएको अवस्थामा, 1 बाट सुरु हुने वा 1 मा अन्त्य हुने n-अङ्कका
धनात्मक पूर्णाङ्कहरूको सङ्ख्या फर्काउनुहोस्।
"""
|
def starts_one_ends(n):
"""
ଗୋଟିଏ ଧନାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟା n ଦିଆଗଲେ, 1 ରେ ଆରମ୍ଭ କିମ୍ବା ଶେଷ ହେଉଥିବା n-ଅଙ୍କ ବିଶିଷ୍ଟ
ଧନାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ସଂଖ୍ୟା (count) ଫେରାନ୍ତୁ।
"""
|
def starts_one_ends(n):
"""
ਇੱਕ ਧਨਾਤਮਕ ਪੂਰਨ ਅੰਕ n ਦਿੱਤੇ ਜਾਣ 'ਤੇ, n-ਅੰਕਾਂ ਵਾਲੇ ਉਹਨਾਂ ਧਨਾਤਮਕ ਪੂਰਨ ਅੰਕਾਂ
ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰੋ ਜੋ 1 ਨਾਲ ਸ਼ੁਰੂ ਜਾਂ ਖ਼ਤਮ ਹੁੰਦੇ ਹਨ।
"""
|
def starts_one_ends(n):
"""
दत्ते धनात्मकपूर्णाङ्के n, 1 इत्यनेन आरभ्यमाणानां वा समाप्यमानानां वा
n-अङ्कीयानां धनात्मकपूर्णाङ्कानां सङ्ख्यां प्रत्यर्पयतु।
"""
|
def starts_one_ends(n):
"""
ஒரு நேர்மறை முழு எண் n கொடுக்கப்பட்டால், 1-ல் தொடங்கும் அல்லது 1-ல் முடியும்
n-இலக்க நேர்மறை முழு எண்களின் எண்ணிக்கையைத் திருப்பியளிக்கவும்.
"""
|
def starts_one_ends(n):
"""
ఒక ధన పూర్ణాంకం n ఇచ్చినప్పుడు, 1 తో ప్రారంభమయ్యే లేదా 1 తో ముగిసే n-అంకెల
ధన పూర్ణాంకాల సంఖ్యను తిరిగి ఇవ్వండి.
"""
|
def starts_one_ends(n):
"""
ایک مثبت صحیح عدد n دیے جانے پر، n-ہندسوں والے ایسے مثبت صحیح اعداد کی تعداد
واپس کریں جو 1 سے شروع یا 1 پر ختم ہوتے ہیں۔
"""
|
HumanEval/84 |
def solve(N):
"""Given a positive integer N, return the total sum of its digits in binary.
Example
For N = 1000, the sum of digits will be 1 the output should be "1".
For N = 150, the sum of digits will be 6 the output should be "110".
For N = 147, the sum of digits will be 12 the ... | return bin(sum(int(i) for i in str(N)))[2:]
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(1000) == "1", "Error"
assert candidate(150) == "110", "Error"
assert candidate(147) == "1100", "Error"
# Check some edge cases that are easy to work out by h... | solve |
def solve(N):
"""এটা ধনাত্মক অখণ্ড সংখ্যা N দিয়া থাকিলে, ইয়াৰ অংকসমূহৰ মুঠ যোগফল বাইনেৰীত ৰিটাৰ্ণ কৰক।
উদাহৰণ
N = 1000 ৰ বাবে, অংকসমূহৰ যোগফল হ'ব 1 আউটপুট হ'ব লাগে "1"।
N = 150 ৰ বাবে, অংকসমূহৰ যোগফল হ'ব 6 আউটপুট হ'ব লাগে "110"।
N = 147 ৰ বাবে, অংকসমূহৰ যোগফল হ'ব 12 আউটপুট হ'ব লা... |
def solve(N):
"""একটি ধনাত্মক পূর্ণসংখ্যা N দেওয়া থাকলে, এর অঙ্কগুলোর মোট যোগফল বাইনারিতে রিটার্ন করুন।
উদাহরণ
N = 1000 এর জন্য, অঙ্কগুলোর যোগফল হবে 1 এবং আউটপুট হওয়া উচিত "1"।
N = 150 এর জন্য, অঙ্কগুলোর যোগফল হবে 6 এবং আউটপুট হওয়া উচিত "110"।
N = 147 এর জন্য, অঙ্কগুলোর যোগফল হব... |
def solve(N):
"""ધન પૂર્ણાંક N આપેલ હોય, તેના અંકોના કુલ સરવાળાને બાઈનરી (binary) માં પરત કરો.
ઉદાહરણ
N = 1000 માટે, અંકોનો સરવાળો 1 થશે અને આઉટપુટ "1" હોવું જોઈએ.
N = 150 માટે, અંકોનો સરવાળો 6 થશે અને આઉટપુટ "110" હોવું જોઈએ.
N = 147 માટે, અંકોનો સરવાળો 12 થશે અને આઉટપુટ "1100" હો... |
def solve(N):
"""एक धनात्मक पूर्णांक N दिए जाने पर, इसके अंकों के कुल योग को बाइनरी में लौटाएं।
Example
N = 1000 के लिए, अंकों का योग 1 होगा और आउटपुट "1" होना चाहिए।
N = 150 के लिए, अंकों का योग 6 होगा और आउटपुट "110" होना चाहिए।
N = 147 के लिए, अंकों का योग 12 होगा और आउटपुट "110... |
def solve(N):
"""ಒಂದು ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ N ಅನ್ನು ನೀಡಲಾಗಿದ್ದು, ಅದರ ಅಂಕಿಗಳ ಒಟ್ಟು ಮೊತ್ತವನ್ನು ಬೈನರಿಯಲ್ಲಿ (binary) ಹಿಂತಿರುಗಿಸಿ.
ಉದಾಹರಣೆ
N = 1000 ಗೆ, ಅಂಕಿಗಳ ಮೊತ್ತವು 1 ಆಗಿರುತ್ತದೆ ಔಟ್ಪುಟ್ "1" ಆಗಿರಬೇಕು.
N = 150 ಗೆ, ಅಂಕಿಗಳ ಮೊತ್ತವು 6 ಆಗಿರುತ್ತದೆ ಔಟ್ಪುಟ್ "110" ಆಗಿರಬೇಕು.
N = 147 ಗೆ, ಅಂಕಿಗಳ ಮೊತ್ತ... |
def solve(N):
"""ഒരു പോസിറ്റീവ് പൂർണ്ണസംഖ്യ N നൽകിയാൽ, അതിലെ അക്കങ്ങളുടെ ആകെ തുക ബൈനറിയിൽ നൽകുക.
ഉദാഹരണം
N = 1000 ആകുമ്പോൾ, അക്കങ്ങളുടെ തുക 1 ആയിരിക്കും ഔട്ട്പുട്ട് "1" ആയിരിക്കണം.
N = 150 ആകുമ്പോൾ, അക്കങ്ങളുടെ തുക 6 ആയിരിക്കും ഔട്ട്പുട്ട് "110" ആയിരിക്കണം.
N = 147 ആകുമ്പോൾ, അക്കങ്... |
def solve(N):
"""एक धन पूर्णांक N दिला असता, त्याच्या अंकांची एकूण बेरीज बायनरीमध्ये (binary) परत करा.
उदाहरण
N = 1000 साठी, अंकांची बेरीज 1 असेल आउटपुट "1" असावे.
N = 150 साठी, अंकांची बेरीज 6 असेल आउटपुट "110" असावे.
N = 147 साठी, अंकांची बेरीज 12 असेल आउटपुट "1100" असावे.
... |
def solve(N):
"""एउटा धनात्मक पूर्णाङ्क N दिइएको अवस्थामा, यसका अङ्कहरूको कुल योगलाई binary मा फर्काउनुहोस्।
उदाहरण
N = 1000 को लागि, अङ्कहरूको योग 1 हुनेछ र आउटपुट "1" हुनुपर्छ।
N = 150 को लागि, अङ्कहरूको योग 6 हुनेछ र आउटपुट "110" हुनुपर्छ।
N = 147 को लागि, अङ्कहरूको योग 12 हुनेछ... |
def solve(N):
"""ଗୋଟିଏ ଧନାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟା N ଦିଆଗଲେ, ଏହାର ଅଙ୍କଗୁଡ଼ିକର ମୋଟ ଯୋଗଫଳକୁ binary ରେ ଫେରାନ୍ତୁ।
ଉଦାହରଣ
N = 1000 ପାଇଁ, ଅଙ୍କଗୁଡ଼ିକର ଯୋଗଫଳ 1 ହେବ ଏବଂ ଆଉଟପୁଟ୍ "1" ହେବା ଉଚିତ।
N = 150 ପାଇଁ, ଅଙ୍କଗୁଡ଼ିକର ଯୋଗଫଳ 6 ହେବ ଏବଂ ଆଉଟପୁଟ୍ "110" ହେବା ଉଚିତ।
N = 147 ପାଇଁ, ଅଙ୍କଗୁଡ଼ିକର ଯୋଗଫଳ 12 ହେବ... |
def solve(N):
"""ਇੱਕ ਧਨਾਤਮਕ ਪੂਰਨ ਅੰਕ N ਦਿੱਤੇ ਜਾਣ 'ਤੇ, ਇਸਦੇ ਅੰਕਾਂ ਦੇ ਕੁੱਲ ਜੋੜ ਨੂੰ ਬਾਈਨਰੀ ਵਿੱਚ ਵਾਪਸ ਕਰੋ।
ਉਦਾਹਰਨ
N = 1000 ਲਈ, ਅੰਕਾਂ ਦਾ ਜੋੜ 1 ਹੋਵੇਗਾ ਆਉਟਪੁੱਟ "1" ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
N = 150 ਲਈ, ਅੰਕਾਂ ਦਾ ਜੋੜ 6 ਹੋਵੇਗਾ ਆਉਟਪੁੱਟ "110" ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।
N = 147 ਲਈ, ਅੰਕਾਂ ਦਾ ਜੋੜ 12 ਹੋਵੇਗਾ ਆਉਟਪੁੱਟ "1... |
def solve(N):
"""एकं धनात्मकं पूर्णाङ्कं N प्राप्य, तस्य अङ्कानां योगफलं द्व्याधारी (binary) रूपेण प्रत्यर्पयत।
उदाहरणम्
N = 1000 कृते, अङ्कानां योगः 1 भविष्यति तथा च निर्गमः "1" भवेत्।
N = 150 कृते, अङ्कानां योगः 6 भविष्यति तथा च निर्गमः "110" भवेत्।
N = 147 कृते, अङ्कानां योगः 12... |
def solve(N):
"""ஒரு நேர்ம முழு எண் N கொடுக்கப்பட்டால், அதன் இலக்கங்களின் மொத்தக் கூடுதலை பைனரி (binary) வடிவில் திருப்பித்தரவும்.
எடுத்துக்காட்டு
N = 1000 எனில், இலக்கங்களின் கூடுதல் 1 ஆக இருக்கும், வெளியீடு "1" ஆக இருக்க வேண்டும்.
N = 150 எனில், இலக்கங்களின் கூடுதல் 6 ஆக இருக்கும், வெளிய... |
def solve(N):
"""ఒక ధన పూర్ణాంకం N ఇవ్వబడినప్పుడు, దాని అంకెల మొత్తాన్ని బైనరీ (binary) లో రిటర్న్ చేయండి.
ఉదాహరణ
N = 1000 కి, అంకెల మొత్తం 1 అవుతుంది మరియు అవుట్పుట్ "1" కావాలి.
N = 150 కి, అంకెల మొత్తం 6 అవుతుంది మరియు అవుట్పుట్ "110" కావాలి.
N = 147 కి, అంకెల మొత్తం 12 అవుతుంద... |
def solve(N):
"""ایک مثبت صحیح عدد N دیے جانے پر، اس کے ہندسوں کا کل مجموعہ binary میں واپس کریں۔
مثال
N = 1000 کے لیے، ہندسوں کا مجموعہ 1 ہوگا آؤٹ پٹ "1" ہونی چاہیے۔
N = 150 کے لیے، ہندسوں کا مجموعہ 6 ہوگا آؤٹ پٹ "110" ہونی چاہیے۔
N = 147 کے لیے، ہندسوں کا مجموعہ 12 ہوگا آؤٹ پٹ "1... |
HumanEval/85 |
def add(lst):
"""Given a non-empty list of integers lst. add the even elements that are at odd indices..
Examples:
add([4, 2, 6, 7]) ==> 2
"""
| return sum([lst[i] for i in range(1, len(lst), 2) if lst[i]%2 == 0])
| def check(candidate):
# Check some simple cases
assert candidate([4, 88]) == 88
assert candidate([4, 5, 6, 7, 2, 122]) == 122
assert candidate([4, 0, 6, 7]) == 0
assert candidate([4, 4, 6, 8]) == 12
# Check some edge cases that are easy to work out by hand.
| add |
def add(lst):
"""এটা অনা-খালী পূৰ্ণসংখ্যাৰ তালিকা lst দিয়া হৈছে। বিজোৰ সূচীত থকা যুগ্ম উপাদানসমূহ যোগ কৰক।..
উদাহৰণ:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""একটি পূর্ণসংখ্যার অ-খালি তালিকা lst দেওয়া রয়েছে। বিজোড় ইনডেক্সে থাকা জোড় উপাদানগুলো যোগ করুন..
উদাহরণ:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""પૂર્ણાંકોની એક બિન-ખાલી લિસ્ટ lst આપેલ છે. એકી ઇન્ડેક્સ પર રહેલા બેકી ઘટકોનો સરવાળો કરો..
ઉદાહરણો:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""पूर्णांकों की एक गैर-रिक्त सूची lst दी गई है। विषम इंडेक्स पर स्थित सम तत्वों को जोड़ें..
उदाहरण:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""ಪೂರ್ಣಾಂಕಗಳ ಖಾಲಿಯಲ್ಲದ ಪಟ್ಟಿ lst ಅನ್ನು ನೀಡಲಾಗಿದೆ. ಬೆಸ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿರುವ ಸಮ ಅಂಶಗಳನ್ನು ಕೂಡಿ..
ಉದಾಹರಣೆಗಳು:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""പൂർണ്ണസംഖ്യകളുടെ ശൂന്യമല്ലാത്ത ഒരു ലിസ്റ്റ് lst നൽകിയിരിക്കുന്നു. ഒറ്റയായ ഇൻഡക്സുകളിൽ വരുന്ന ഇരട്ട സംഖ്യകൾ കൂട്ടുക..
ഉദാഹരണങ്ങൾ:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""पूर्णांकांची एक गैर-रिकामी सूची lst दिलेली आहे. विषम इंडेक्सवर (odd indices) असलेले सम घटक जोडा..
उदाहरणे:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""पूर्णाङ्कहरूको एउटा गैर-खाली सूची lst दिइएको छ। बिजोर इन्डेक्सहरूमा रहेका जोर तत्वहरूलाई जोड्नुहोस्..
उदाहरणहरू:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ ଅଣ-ଖାଲି ତାଲିକା lst ଦିଆଯାଇଛି। ବିଷମ ଇଣ୍ଡେକ୍ସରେ ଥିବା ଯୁଗ୍ମ ଉପାଦାନଗୁଡ଼ିକୁ ଯୋଗ କରନ୍ତୁ..
ଉଦାହରଣ:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਗੈਰ-ਖਾਲੀ ਸੂਚੀ lst ਦਿੱਤੀ ਗਈ ਹੈ। ਟਾਂਕ ਇੰਡੈਕਸਾਂ 'ਤੇ ਮੌਜੂਦ ਜਿਸਤ ਤੱਤਾਂ ਨੂੰ ਜੋੜੋ..
ਉਦਾਹਰਨਾਂ:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""पूर्णाङ्कानाम् एका अरिक्ता सूचिः lst दत्ता अस्ति। विषम-सूचकाङ्केषु स्थितानां सम-तत्त्वानां योगं कुर्वन्तु..
उदाहरणानि:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""வெற்றிடமற்ற முழு எண்களின் பட்டியல் lst கொடுக்கப்பட்டுள்ளது. ஒற்றைப்படை குறியீடுகளில் உள்ள இரட்டைப்படை உறுப்புகளைக் கூட்டவும்..
எடுத்துக்காட்டுகள்:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""పూర్ణాంకాలతో కూడిన ఒక నాన్-ఎంప్టీ లిస్ట్ lst ఇవ్వబడింది. బేసి ఇండెక్స్లలో (odd indices) ఉన్న సరి మూలకాలను (even elements) కలపండి..
ఉదాహరణలు:
add([4, 2, 6, 7]) ==> 2
"""
|
def add(lst):
"""انٹیجرز کی ایک غیر خالی لسٹ lst دی گئی ہے۔ ان جفت عناصر کو جمع کریں جو طاق انڈیکسز پر ہیں۔۔
مثالیں:
add([4, 2, 6, 7]) ==> 2
"""
|
HumanEval/86 |
def anti_shuffle(s):
"""
Write a function that takes a string and returns an ordered version of it.
Ordered version of string, is a string where all words (separated by space)
are replaced by a new word where all the characters arranged in
ascending order based on ascii value.
Note: You should ... | return ' '.join([''.join(sorted(list(i))) for i in s.split(' ')])
| def check(candidate):
# Check some simple cases
assert candidate('Hi') == 'Hi'
assert candidate('hello') == 'ehllo'
assert candidate('number') == 'bemnru'
assert candidate('abcd') == 'abcd'
assert candidate('Hello World!!!') == 'Hello !!!Wdlor'
assert candidate('') == ''
assert candidat... | anti_shuffle |
def anti_shuffle(s):
"""
এটা ফলন লিখক যিয়ে এটা ষ্ট্ৰিং গ্ৰহণ কৰে আৰু ইয়াৰ এটা শৃংখলাবদ্ধ সংস্কৰণ ঘূৰাই দিয়ে।
ষ্ট্ৰিংৰ শৃংখলাবদ্ধ সংস্কৰণ হ'ল এনে এটা ষ্ট্ৰিং য'ত সকলো শব্দ (স্পেচ দ্বাৰা পৃথক কৰা)
এটা নতুন শব্দৰে প্ৰতিস্থাপন কৰা হয় য'ত সকলো বৰ্ণ ascii মানৰ ভিত্তিত
উৰ্ধ্বক্ৰমত সজোৱা হয়।
টোকা:... |
def anti_shuffle(s):
"""
এমন একটি ফাংশন লিখুন যা একটি স্ট্রিং গ্রহণ করে এবং এর একটি ক্রমানুসারে সাজানো সংস্করণ প্রদান করে।
স্ট্রিংয়ের ক্রমানুসারে সাজানো সংস্করণ হলো এমন একটি স্ট্রিং যেখানে সমস্ত শব্দ (স্পেস দ্বারা পৃথকীকৃত)
এমন একটি নতুন শব্দ দ্বারা প্রতিস্থাপিত হয় যাতে সমস্ত অক্ষর ascii মানের ভিত্তিত... |
def anti_shuffle(s):
"""
એક ફંક્શન લખો જે એક સ્ટ્રિંગ લે છે અને તેનું ક્રમબદ્ધ સ્વરૂપ (ordered version) પરત કરે છે.
સ્ટ્રિંગનું ક્રમબદ્ધ સ્વરૂપ એ એવી સ્ટ્રિંગ છે જ્યાં બધા શબ્દો (સ્પેસ દ્વારા અલગ પડેલા)
એવા નવા શબ્દથી બદલાય છે જેમાં બધા અક્ષરો ascii મૂલ્યના આધારે
ચડતા ક્રમમાં ગોઠવાયેલા હોય છે.
... |
def anti_shuffle(s):
"""
एक ऐसा फ़ंक्शन लिखें जो एक स्ट्रिंग लेता है और उसका एक ऑर्डर्ड (क्रमबद्ध) संस्करण लौटाता है।
स्ट्रिंग का ऑर्डर्ड संस्करण वह स्ट्रिंग है जहाँ सभी शब्दों (स्पेस द्वारा अलग किए गए)
को एक ऐसे नए शब्द से बदल दिया जाता है जिसमें सभी वर्ण ascii मान के
आधार पर आरोही क्रम (ascending... |
def anti_shuffle(s):
"""
ಒಂದು string ಅನ್ನು ಸ್ವೀಕರಿಸಿ ಅದರ ಕ್ರಮಬದ್ಧವಾದ (ordered) ಆವೃತ್ತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುವ function ಅನ್ನು ಬರೆಯಿರಿ.
String ನ ಕ್ರಮಬದ್ಧವಾದ ಆವೃತ್ತಿ ಎಂದರೆ, ಎಲ್ಲಾ ಪದಗಳನ್ನು (space ನಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾದ)
ಅವುಗಳ ಎಲ್ಲಾ ಅಕ್ಷರಗಳನ್ನು ascii ಮೌಲ್ಯದ ಆಧಾರದ ಮೇಲೆ ಏರಿಕೆ ಕ್ರಮದಲ್ಲಿ ಜೋಡಿಸಲಾದ
ಹೊಸ ಪದದಿಂದ ಬದಲಾಯಿಸಲ... | def anti_shuffle(s):
"""
ഒരു string സ്വീകരിച്ച് അതിന്റെ ordered രൂപം നൽകുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക.
string-ന്റെ ordered രൂപം എന്നാൽ, അതിലെ എല്ലാ വാക്കുകളും (സ്പേസ് ഉപയോഗിച്ച് വേർതിരിച്ചവ)
അവയിലെ എല്ലാ അക്ഷരങ്ങളും ascii മൂല്യത്തിന്റെ അടിസ്ഥാനത്തിൽ ആരോഹണക്രമത്തിൽ ക്രമീകരിച്ച
പുതിയ വാക്കുകളാൽ മാറ്റിസ്ഥാപിക... |
def anti_shuffle(s):
"""
दिलेली स्ट्रिंग स्वीकारून तिची क्रमबद्ध आवृत्ती (ordered version) परत करणारे एक फंक्शन लिहा.
स्ट्रिंगची क्रमबद्ध आवृत्ती म्हणजे अशी स्ट्रिंग, जिथे सर्व शब्द (स्पेसने वेगळे केलेले)
अशा नवीन शब्दाने बदलले जातात ज्यामधील सर्व अक्षरे (characters) ascii मूल्यावर
आधारित चढत्या क्... |
def anti_shuffle(s):
"""
एउटा स्ट्रिङ लिने र त्यसको क्रमबद्ध संस्करण फर्काउने एउटा function लेख्नुहोस्।
स्ट्रिङको क्रमबद्ध संस्करण भनेको त्यस्तो स्ट्रिङ हो जहाँ सबै शब्दहरू (space द्वारा छुट्याइएका)
यस्तो नयाँ शब्दद्वारा प्रतिस्थापन गरिन्छ जहाँ सबै क्यारेक्टरहरू ascii मानको आधारमा
बढ्दो क्रममा मिला... |
def anti_shuffle(s):
"""
ଗୋଟିଏ ଷ୍ଟ୍ରିଙ୍ଗ୍ ଗ୍ରହଣ କରୁଥିବା ଏବଂ ଏହାର ଏକ କ୍ରମବଦ୍ଧ (ordered) ସଂସ୍କରଣ ଫେରାଉଥିବା ଏକ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ।
ଷ୍ଟ୍ରିଙ୍ଗର କ୍ରମବଦ୍ଧ ସଂସ୍କରଣ ହେଉଛି ଏପରି ଏକ ଷ୍ଟ୍ରିଙ୍ଗ୍, ଯେଉଁଥିରେ ସମସ୍ତ ଶବ୍ଦ (ସ୍ପେସ୍ ଦ୍ୱାରା ପୃଥକ)
ଏକ ନୂତନ ଶବ୍ଦ ଦ୍ୱାରା ପ୍ରତିସ୍ଥାପିତ ହୁଏ ଯେଉଁଠାରେ ସମସ୍ତ ଅକ୍ଷର ascii ମୂଲ୍ୟ ଆଧାରରେ
ଆର... |
def anti_shuffle(s):
"""
ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇੱਕ ਸਟ੍ਰਿੰਗ ਲੈਂਦਾ ਹੈ ਅਤੇ ਇਸਦਾ ਇੱਕ ਕ੍ਰਮਬੱਧ (ordered) ਸੰਸਕਰਣ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਸਟ੍ਰਿੰਗ ਦਾ ਕ੍ਰਮਬੱਧ ਸੰਸਕਰਣ ਉਹ ਸਟ੍ਰਿੰਗ ਹੈ ਜਿੱਥੇ ਸਾਰੇ ਸ਼ਬਦ (ਸਪੇਸ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ) ਨੂੰ
ਇੱਕ ਨਵੇਂ ਸ਼ਬਦ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੇ ਅੱਖਰ ascii ਮੁੱਲ ਦੇ ਆਧਾਰ 'ਤੇ
ਚੜ੍ਹਦੇ ਕ੍ਰਮ ਵਿੱਚ ਵਿ... |
def anti_shuffle(s):
"""
एकं फलनं लिखन्तु यत् एकां स्ट्रिङ्ग् स्वीकरोति तथा च तस्याः क्रमितं रूपं प्रत्यर्पयति।
स्ट्रिङ्ग्-इत्यस्य क्रमितरूपं सा स्ट्रिङ्ग् अस्ति यत्र सर्वे शब्दाः (अन्तरालेन पृथक्कृताः)
एतेन नूतनशब्देन प्रतिस्थाप्यन्ते यस्मिन् सर्वे वर्णाः ascii मूल्यस्य आधारेण
आरोहिक्रमेण व्यवस्थि... |
def anti_shuffle(s):
"""
ஒரு string-ஐப் பெற்று, அதன் வரிசைப்படுத்தப்பட்ட வடிவத்தைத் திருப்பி அனுப்பும் ஒரு function-ஐ எழுதுக.
string-இன் வரிசைப்படுத்தப்பட்ட வடிவம் என்பது, அனைத்து சொற்களும் (இடைவெளியால் பிரிக்கப்பட்டவை)
அவற்றின் எழுத்துக்கள் ascii மதிப்பின் அடிப்படையில் ஏறுவரிசையில் வரிசைப்படுத்தப்பட்ட... |
def anti_shuffle(s):
"""
ఒక స్ట్రింగ్ను తీసుకుని, దాని యొక్క ఆర్డర్ చేయబడిన రూపాన్ని అందించే ఫంక్షన్ను రాయండి.
స్ట్రింగ్ యొక్క ఆర్డర్ చేయబడిన రూపం అంటే, అందులోని అన్ని పదాలు (స్పేస్ ద్వారా వేరు చేయబడినవి)
వాటిలోని అక్షరాలు ascii విలువ ఆధారంగా ఆరోహణ క్రమంలో అమర్చబడిన
కొత్త పదాలతో భర్తీ చేయబడిన స్ట... |
def anti_shuffle(s):
"""
ایک ایسا فنکشن لکھیں جو ایک اسٹرنگ لیتا ہے اور اس کا ایک ترتیب شدہ (ordered) ورژن واپس کرتا ہے۔
اسٹرنگ کا ترتیب شدہ ورژن، ایک ایسا اسٹرنگ ہے جہاں تمام الفاظ (جو اسپیس کے ذریعے الگ کیے گئے ہیں)
کو ایک ایسے نئے لفظ سے بدل دیا جاتا ہے جس میں تمام حروف ascii ویلیو کی بنیاد پر
ص... |
HumanEval/87 |
def get_row(lst, x):
"""
You are given a 2 dimensional data, as a nested lists,
which is similar to matrix, however, unlike matrices,
each row may contain a different number of columns.
Given lst, and integer x, find integers x in the list,
and return list of tuples, [(x1, y1), (x2, y2) ...] su... | coords = [(i, j) for i in range(len(lst)) for j in range(len(lst[i])) if lst[i][j] == x]
return sorted(sorted(coords, key=lambda x: x[1], reverse=True), key=lambda x: x[0])
| def check(candidate):
# Check some simple cases
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,1,6],
[1,2,3,4,5,1]
], 1) == [(0, 0), (1, 4), (1, 0), (2, 5), (2, 0)]
assert candidate([
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
[1,2,3,4,5,6],
... | get_row |
def get_row(lst, x):
"""
আপোনাক নেষ্টেড তালিকা (nested lists) হিচাপে এটা ২-মাত্ৰিক (2 dimensional) তথ্য দিয়া হৈছে,
যি মেট্ৰিক্সৰ সৈতে সাদৃশ্যপূৰ্ণ, কিন্তু মেট্ৰিক্সৰ বিপৰীতে,
প্ৰতিটো শাৰীত স্তম্ভৰ সংখ্যা বেলেগ বেলেগ হ'ব পাৰে।
lst আৰু এটা অখণ্ড সংখ্যা x দিয়া থাকিলে, তালিকাত থকা অখণ্ড সংখ্যা x বিচা... |
def get_row(lst, x):
"""
আপনাকে নেস্টেড লিস্ট আকারে একটি 2 মাত্রিক ডেটা দেওয়া হয়েছে,
যা ম্যাট্রিক্সের অনুরূপ, তবে ম্যাট্রিক্সের বিপরীতে,
প্রতিটি সারিতে ভিন্ন সংখ্যক কলাম থাকতে পারে।
lst এবং একটি পূর্ণসংখ্যা x দেওয়া থাকলে, লিস্টটিতে পূর্ণসংখ্যা x খুঁজুন,
এবং tuple-এর একটি লিস্ট, [(x1, y1), (x2, ... |
def get_row(lst, x):
"""
તમને નેસ્ટેડ લિસ્ટ્સ તરીકે 2 પરિમાણીય (2 dimensional) ડેટા આપવામાં આવ્યો છે,
જે મેટ્રિક્સ જેવો જ છે, જો કે, મેટ્રિક્સથી વિપરીત,
દરેક પંક્તિ (row) માં કૉલમની સંખ્યા અલગ હોઈ શકે છે.
આપેલ lst અને પૂર્ણાંક x માટે, લિસ્ટમાં પૂર્ણાંક x શોધો,
અને ટપલ્સની લિસ્ટ [(x1, y1), (x2, ... |
def get_row(lst, x):
"""
आपको नेस्टेड सूचियों (nested lists) के रूप में 2-आयामी डेटा दिया गया है,
जो मैट्रिक्स के समान है, हालांकि, मैट्रिक्स के विपरीत,
प्रत्येक पंक्ति (row) में कॉलम (columns) की संख्या भिन्न हो सकती है।
lst और पूर्णांक x दिए जाने पर, सूची में पूर्णांक x खोजें,
और टुपल्स की एक... |
def get_row(lst, x):
"""
ನಿಮಗೆ ನೆಸ್ಟೆಡ್ ಲಿಸ್ಟ್ಗಳ ರೂಪದಲ್ಲಿ 2 ಆಯಾಮದ ಡೇಟಾವನ್ನು ನೀಡಲಾಗಿದೆ,
ಇದು ಮ್ಯಾಟ್ರಿಕ್ಸ್ನಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ಮ್ಯಾಟ್ರಿಕ್ಸ್ಗಳಂತಲ್ಲದೆ,
ಪ್ರತಿ ಸಾಲು ವಿಭಿನ್ನ ಸಂಖ್ಯೆಯ ಕಾಲಮ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
lst ಮತ್ತು ಪೂರ್ಣಾಂಕ x ಅನ್ನು ನೀಡಿದಾಗ, ಲಿಸ್ಟ್ನಲ್ಲಿ ಪೂರ್ಣಾಂಕ x ಗಳನ್ನು ಹುಡುಕಿ,
ಮತ್ತು ಪ್ರತಿಯೊಂದು... |
def get_row(lst, x):
"""
നിങ്ങൾക്ക് ഒരു നെസ്റ്റഡ് ലിസ്റ്റ് (nested list) രൂപത്തിൽ 2 ഡൈമൻഷണൽ ഡാറ്റ നൽകിയിരിക്കുന്നു,
ഇത് മാട്രിക്സിന് സമാനമാണ്, എന്നാൽ മാട്രിക്സുകളിൽ നിന്ന് വ്യത്യസ്തമായി,
ഓരോ വരിയിലും (row) വ്യത്യസ്ത എണ്ണം നിരകൾ (columns) ഉണ്ടായിരിക്കാം.
lst, ഒപ്പം ഒരു പൂർണ്ണസംഖ്യയായ x ഉം നൽകിയിരിക്... |
def get_row(lst, x):
"""
तुम्हाला नेस्टेड लिस्ट्सच्या स्वरूपात 2-मितीय डेटा दिला आहे,
जो मॅट्रिक्ससारखा आहे, तथापि, मॅट्रिसेसच्या विपरीत,
प्रत्येक row मध्ये वेगवेगळ्या संख्येने columns असू शकतात.
lst, आणि पूर्णांक x दिला असता, लिस्टमध्ये पूर्णांक x शोधा,
आणि टपल्सची लिस्ट (list of tuples), [(x1... |
def get_row(lst, x):
"""
तपाईंलाई नेस्टेड सूचीको रूपमा २-आयामी (2 dimensional) डेटा दिइएको छ,
जो म्याट्रिक्स जस्तै छ, तर म्याट्रिक्सहरूको विपरीत,
प्रत्येक पङ्क्तिमा फरक संख्यामा स्तम्भहरू हुन सक्छन्।
दिइएको lst र पूर्णाङ्क x बाट, सूचीमा भएका पूर्णाङ्क x हरू पत्ता लगाउनुहोस्,
र [(x1, y1), (x2, y... |
def get_row(lst, x):
"""
ଆପଣଙ୍କୁ nested lists ଆକାରରେ ଏକ 2 dimensional ତଥ୍ୟ ଦିଆଯାଇଛି,
ଯାହା ଏକ matrix ସହିତ ସମାନ, କିନ୍ତୁ matrices ପରି ନୁହେଁ,
ପ୍ରତ୍ୟେକ row ରେ ଭିନ୍ନ ସଂଖ୍ୟକ columns ରହିପାରେ।
ଦିଆଯାଇଥିବା lst, ଏବଂ integer x ରୁ, list ରେ integers x କୁ ଖୋଜନ୍ତୁ,
ଏବଂ tuples ର ଏକ list ଫେରାନ୍ତୁ, [(x1, y1), (x2,... |
def get_row(lst, x):
"""
ਤੁਹਾਨੂੰ ਨੇਸਟਡ ਲਿਸਟਾਂ ਦੇ ਰੂਪ ਵਿੱਚ 2 ਅਯਾਮੀ (2 dimensional) ਡੇਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ,
ਜੋ ਕਿ ਮੈਟ੍ਰਿਕਸ ਦੇ ਸਮਾਨ ਹੈ, ਹਾਲਾਂਕਿ, ਮੈਟ੍ਰਿਕਸ ਦੇ ਉਲਟ,
ਹਰੇਕ ਕਤਾਰ (row) ਵਿੱਚ ਕਾਲਮਾਂ ਦੀ ਵੱਖਰੀ ਗਿਣਤੀ ਹੋ ਸਕਦੀ ਹੈ।
ਦਿੱਤੀ ਗਈ lst, ਅਤੇ ਪੂਰਨ ਅੰਕ x ਲਈ, ਲਿਸਟ ਵਿੱਚ ਪੂਰਨ ਅੰਕ x ਲੱਭੋ,
ਅਤੇ ਟਿਊਪਲਾਂ ਦੀ ਇੱਕ ਲਿਸਟ, [... |
def get_row(lst, x):
"""
भवते अन्तर्निहितसूचिरूपेण (nested lists) द्विविमीयदत्तांशः दत्तः अस्ति,
यः आव्यूहसदृशः (matrix) अस्ति, किन्तु आव्यूहानां वैपरीत्येन,
प्रत्येकपङ्क्तौ स्तम्भानां सङ्ख्या भिन्ना भवितुम् अर्हति।
lst तथा पूर्णाङ्कः x दत्ते सति, सूचौ x पूर्णाङ्कान् अन्विष्य,
tuples इत्येषां स... |
def get_row(lst, x):
"""
உங்களுக்கு nested lists வடிவில் 2 பரிமான தரவு வழங்கப்பட்டுள்ளது,
இது அணியைப்போன்றது, ஆனால் அணிகளைப் போலல்லாமல்,
ஒவ்வொரு வரிசையும் வெவ்வேறு எண்ணிக்கையிலான நிரல்களைக் கொண்டிருக்கலாம்.
lst மற்றும் integer x கொடுக்கப்பட்டால், பட்டியலில் உள்ள x முழு எண்களைக் கண்டறிந்து,
ஒ... |
def get_row(lst, x):
"""
మీకు నెస్టెడ్ లిస్ట్ల రూపంలో ఒక 2 డైమెన్షనల్ డేటా ఇవ్వబడింది,
ఇది మ్యాట్రిక్స్ లాంటిది, అయితే మ్యాట్రిక్స్ల వలె కాకుండా,
ప్రతి వరుస (row) వేర్వేరు సంఖ్యలో కాలమ్లను (columns) కలిగి ఉండవచ్చు.
lst మరియు పూర్ణాంకం x ఇచ్చినప్పుడు, లిస్ట్లో పూర్ణాంకాలు x ను కనుగొని,
[(x1,... |
def get_row(lst, x):
"""
آپ کو
nested lists
کے طور پر 2 جہتی ڈیٹا دیا گیا ہے،
جو میٹرکس سے ملتا جلتا ہے، تاہم، میٹرکس کے برعکس،
ہر قطار میں کالموں کی تعداد مختلف ہو سکتی ہے۔
دیے گئے lst، اور integer x
کے لیے، لسٹ میں integers x
تلاش کریں،
اور ٹیوپلز
کی ایک لسٹ واپس ک... |
HumanEval/88 |
def sort_array(array):
"""
Given an array of non-negative integers, return a copy of the given array after sorting,
you will sort the given array in ascending order if the sum( first index value, last index value) is odd,
or sort it in descending order if the sum( first index value, last index value) i... | return [] if len(array) == 0 else sorted(array, reverse= (array[0]+array[-1]) % 2 == 0)
| def check(candidate):
# Check some simple cases
assert True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate([]) == [], "Error"
assert candidate([5]) == [5], "Error"
assert candidate([2, 4, 3, 0, 1, 5]) == [0, 1, 2, 3, 4, 5], "Error"
assert candidate([2, 4, 3, 0, 1, ... | sort_array |
def sort_array(array):
"""
এটা অঋণাত্মক অখণ্ড সংখ্যাৰ array প্ৰদান কৰা হ'লে, sort কৰাৰ পিছত দিয়া array-টোৰ এটা copy ঘূৰাই দিয়ক,
যদি sum( প্ৰথম সূচকৰ মান, অন্তিম সূচকৰ মান) অযুগ্ম হয় তেন্তে আপুনি দিয়া array-টো ascending order-ত সজাব,
বা যদি sum( প্ৰথম সূচকৰ মান, অন্তিম সূচকৰ মান) যুগ্ম হয় তেন্তে ইয... |
def sort_array(array):
"""
অঋণাত্মক পূর্ণসংখ্যার একটি অ্যারে দেওয়া থাকলে, সাজানোর পর প্রদত্ত অ্যারেটির একটি কপি রিটার্ন করুন,
আপনি প্রদত্ত অ্যারেকে ঊর্ধ্বক্রমে (ascending order) সাজাবেন যদি sum( first index value, last index value) বিজোড় হয়,
অথবা এটিকে অধঃক্রমে (descending order) সাজাবেন যদি sum( first... |
def sort_array(array):
"""
બિન-ઋણ પૂર્ણાંકોનો array આપેલ હોય, સૉર્ટ કર્યા પછી આપેલ array ની નકલ (copy) પરત કરો,
જો sum(પ્રથમ ઇન્ડેક્સની કિંમત, છેલ્લા ઇન્ડેક્સની કિંમત) એકી (odd) હોય, તો તમે આપેલ array ને ચડતા ક્રમમાં (ascending order) સૉર્ટ કરશો,
અથવા જો sum(પ્રથમ ઇન્ડેક્સની કિંમત, છેલ્લા ઇન્ડેક્સની કિ... |
def sort_array(array):
"""
गैर-ऋणात्मक पूर्णांकों (non-negative integers) का एक array दिए जाने पर, सॉर्ट करने के बाद दिए गए array की एक प्रति (copy) लौटाएं,
यदि sum( first index value, last index value) विषम (odd) है, तो आप दिए गए array को आरोही क्रम (ascending order) में सॉर्ट करेंगे,
या यदि sum( firs... |
def sort_array(array):
"""
ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕಗಳ array ಒಂದನ್ನು ನೀಡಿದಾಗ, ವಿಂಗಡಿಸಿದ ನಂತರ ನೀಡಲಾದ array ನ ಪ್ರತಿಯನ್ನು ಹಿಂತಿರುಗಿಸಿ,
sum( first index value, last index value) ಬೆಸ ಸಂಖ್ಯೆಯಾಗಿದ್ದರೆ (odd), ನೀವು ನೀಡಲಾದ array ಅನ್ನು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ (ascending order) ವಿಂಗಡಿಸಬೇಕು,
ಅಥವಾ sum( first index value, last i... |
def sort_array(array):
"""
നെഗറ്റീവ് അല്ലാത്ത പൂർണ്ണസംഖ്യകളുടെ ഒരു അറേ നൽകിയാൽ, സോർട്ട് ചെയ്തതിനു ശേഷമുള്ള നൽകിയിട്ടുള്ള അറേയുടെ ഒരു കോപ്പി നൽകുക,
ആദ്യ ഇൻഡക്സിലെ വിലയുടെയും അവസാന ഇൻഡക്സിലെ വിലയുടെയും തുക sum( first index value, last index value) ഒറ്റസംഖ്യയാണെങ്കിൽ നിങ്ങൾ നൽകിയിട്ടുള്ള അറേയെ ആരോഹണക്രമത്തിൽ ... |
def sort_array(array):
"""
अऋण पूर्णांकांचा (non-negative integers) एक array दिला असता, sort केल्यानंतर दिलेल्या array ची एक प्रत (copy) परत करा,
जर sum( first index value, last index value) विषम (odd) असेल तर तुम्ही दिलेला array चढत्या क्रमाने (ascending order) sort कराल,
किंवा जर sum( first index val... |
def sort_array(array):
"""
गैर-ऋणात्मक पूर्णाङ्कहरूको एउटा array दिइएकोमा, sort गरेपछि दिइएको array को प्रतिलिपि (copy) फिर्ता गर्नुहोस्,
यदि sum( पहिलो इन्डेक्सको मान, अन्तिम इन्डेक्सको मान) बिजोर छ भने तपाईंले दिइएको array लाई ascending order मा sort गर्नुहुनेछ,
वा यदि sum( पहिलो इन्डेक्सको मान, अन्त... |
def sort_array(array):
"""
ଅଣ-ଋଣାତ୍ମକ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ array ଦିଆଗଲେ, sort କରିବା ପରେ ପ୍ରଦତ୍ତ array ର ଏକ copy ଫେରାନ୍ତୁ,
ଯଦି sum( first index value, last index value) ଅଯୁଗ୍ମ ହୁଏ, ତେବେ ଆପଣ ପ୍ରଦତ୍ତ array କୁ ଊର୍ଦ୍ଧ୍ୱକ୍ରମରେ (ascending order) sort କରିବେ,
କିମ୍ବା ଯଦି sum( first index value, last index val... |
def sort_array(array):
"""
ਗੈਰ-ਰਿਣਾਤਮਕ ਪੂਰਨ ਅੰਕਾਂ (non-negative integers) ਦਾ ਇੱਕ array ਦਿੱਤਾ ਗਿਆ ਹੈ, ਸੌਰਟ ਕਰਨ ਤੋਂ ਬਾਅਦ ਦਿੱਤੇ ਗਏ array ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰੋ,
ਤੁਸੀਂ ਦਿੱਤੇ ਗਏ array ਨੂੰ ਚੜ੍ਹਦੇ ਕ੍ਰਮ (ascending order) ਵਿੱਚ ਸੌਰਟ ਕਰੋਗੇ ਜੇਕਰ sum( ਪਹਿਲੇ ਇੰਡੈਕਸ ਦਾ ਮੁੱਲ, ਆਖਰੀ ਇੰਡੈਕਸ ਦਾ ਮੁੱਲ) ਟਾਂਕ (odd) ਹੈ,
ਜਾਂ ਇਸਨੂ... |
def sort_array(array):
"""
अऋणात्मकपूर्णाङ्कानाम् एकां पङ्क्तिं (array) प्राप्य, क्रमबद्धीकरणानन्तरं प्रदत्तपङ्क्तेः एकां प्रतिलिपिं प्रत्यर्पयत,
यदि sum( प्रथमसूचकाङ्कमूल्यम्, अन्तिमसूचकाङ्कमूल्यम् ) विषमम् (odd) अस्ति तर्हि प्रदत्तपङ्क्तिम् आरोहिक्रमेण क्रमबद्धां कुर्वन्तु,
अथवा यदि sum( प्रथमसूचकाङ्... |
def sort_array(array):
"""
எதிர்மறையற்ற முழு எண்களைக் கொண்ட ஒரு array கொடுக்கப்பட்டால், வரிசைப்படுத்திய பிறகு கொடுக்கப்பட்ட array-இன் ஒரு நகலைத் திருப்பியளிக்கவும்,
sum( முதல் index மதிப்பு, கடைசி index மதிப்பு) ஒற்றைப்படை எண்ணாக இருந்தால், கொடுக்கப்பட்ட array-ஐ ஏறுவரிசையில் வரிசைப்படுத்த வேண்டும்,
அல்... |
def sort_array(array):
"""
రుణాత్మకం కాని పూర్ణాంకాల అర్రే ఇవ్వబడినప్పుడు, సార్ట్ చేసిన తర్వాత ఇచ్చిన అర్రే యొక్క కాపీని రిటర్న్ చేయండి,
sum( first index value, last index value) బేసి సంఖ్య (odd) అయితే మీరు ఇచ్చిన అర్రేను ఆరోహణ క్రమంలో (ascending order) సార్ట్ చేయాలి,
లేదా sum( first index value, last ... |
def sort_array(array):
"""
غیر منفی اعداد (non-negative integers) کی ایک array دی گئی ہے، ترتیب دینے (sorting) کے بعد دی گئی array کی ایک کاپی واپس کریں،
اگر sum( پہلے انڈیکس کی ویلیو، آخری انڈیکس کی ویلیو) طاق (odd) ہو تو آپ دی گئی array کو صعودی ترتیب (ascending order) میں ترتیب دیں گے،
یا اگر sum( پ... |
HumanEval/89 |
def encrypt(s):
"""Create a function encrypt that takes a string as an argument and
returns a string encrypted with the alphabet being rotated.
The alphabet should be rotated in a manner such that the letters
shift down by two multiplied to two places.
For example:
encrypt('hi') returns 'lm'
... | d = 'abcdefghijklmnopqrstuvwxyz'
out = ''
for c in s:
if c in d:
out += d[(d.index(c)+2*2) % 26]
else:
out += c
return out
| def check(candidate):
# Check some simple cases
assert candidate('hi') == 'lm', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('asdfghjkl') == 'ewhjklnop', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('gf') == 'kj', "This prints if this assert... | encrypt |
def encrypt(s):
"""encrypt নামৰ এটা ফলন সৃষ্টি কৰক যিয়ে এটা ষ্ট্ৰিং আর্গুমেন্ট হিচাপে গ্ৰহণ কৰে আৰু
বৰ্ণমালা ঘূৰোৱাৰ দ্বাৰা এনক্ৰিপ্ট কৰা এটা ষ্ট্ৰিং ঘূৰাই দিয়ে।
বৰ্ণমালাখন এনেদৰে ঘূৰাব লাগে যাতে আখৰবোৰ
দুই গুণ দুই স্থান তললৈ স্থানান্তৰিত (shift down) হয়।
উদাহৰণস্বৰূপে:
encrypt('hi')-এ 'lm... |
def encrypt(s):
"""encrypt নামে একটি ফাংশন তৈরি করুন যা আর্গুমেন্ট হিসেবে একটি স্ট্রিং গ্রহণ করে এবং
বর্ণমালা রোটেট করার মাধ্যমে এনক্রিপ্ট করা একটি স্ট্রিং রিটার্ন করে।
বর্ণমালা এমনভাবে রোটেট করা উচিত যাতে অক্ষরগুলো
দুই গুণ দুই স্থানে নিচে সরে যায় (shift down করে)।
উদাহরণস্বরূপ:
encrypt('hi') ... |
def encrypt(s):
"""એક ફંક્શન encrypt બનાવો જે એક string ને આર્ગ્યુમેન્ટ તરીકે લે છે અને
આલ્ફાબેટને રોટેટ કરીને એન્ક્રિપ્ટ કરેલી string રિટર્ન કરે છે.
આલ્ફાબેટ એવી રીતે રોટેટ થવો જોઈએ જેથી અક્ષરો
બે ગુણ્યા બે સ્થાન જેટલા આગળ ખસે (shift down).
ઉદાહરણ તરીકે:
encrypt('hi') એ 'lm' રિટર્ન કરે છે
... |
def encrypt(s):
"""एक फ़ंक्शन encrypt बनाएं जो एक स्ट्रिंग को तर्क (argument) के रूप में लेता है और
वर्णमाला को घुमाकर (rotate करके) एन्क्रिप्ट की गई एक स्ट्रिंग लौटाता है।
वर्णमाला को इस तरह घुमाया जाना चाहिए कि अक्षर
दो गुणा दो स्थानों से नीचे (आगे) शिफ्ट हो जाएं।
उदाहरण के लिए:
encrypt('hi... |
def encrypt(s):
"""ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಆಲ್ಫಾಬೆಟ್ ಅನ್ನು ರೊಟೇಟ್ ಮಾಡಿ
ಎನ್ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರಿಟರ್ನ್ ಮಾಡುವ encrypt ಫಂಕ್ಷನ್ ರಚಿಸಿ.
ಅಕ್ಷರಗಳು ಎರಡನ್ನು ಎರಡರಿಂದ ಗುಣಿಸಿದಷ್ಟು ಸ್ಥಾನಗಳಷ್ಟು ಕೆಳಕ್ಕೆ ಸರಿಯುವಂತೆ (shift down ಆಗುವಂತೆ)
ಆಲ್ಫಾಬೆಟ್ ಅನ್ನು ರೊಟೇಟ್ ಮಾಡಬೇಕು.
... |
def encrypt(s):
"""ഒരു സ്ട്രിംഗ് ആർഗ്യുമെന്റായി സ്വീകരിക്കുകയും ആൽഫബെറ്റ് റൊട്ടേറ്റ് ചെയ്ത്
എൻക്രിപ്റ്റ് ചെയ്ത ഒരു സ്ട്രിംഗ് തിരികെ നൽകുകയും ചെയ്യുന്ന encrypt എന്ന ഫംഗ്ഷൻ നിർമ്മിക്കുക.
അക്ഷരങ്ങൾ രണ്ടിനെ രണ്ട് കൊണ്ട് ഗുണിച്ചത്ര സ്ഥാനങ്ങൾ താഴേക്ക് നീങ്ങുന്ന രീതിയിൽ
ആൽഫബെറ്റ് റൊട്ടേറ്റ് ചെയ്യേണ്ടതാണ്.
... |
def encrypt(s):
"""encrypt हे फंक्शन तयार करा जे एक string आर्ग्युमेंट म्हणून घेते आणि
वर्णमाला रोटेट करून एन्क्रिप्ट केलेली string परत करते.
वर्णमाला अशा रीतीने फिरवली (rotated) पाहिजे जेणेकरून अक्षरे
दोन गुणिले दोन स्थानांनी खाली सरकतील (shift down by two multiplied to two places).
उदाहरणार्थ:
... |
def encrypt(s):
"""एउटा function encrypt सिर्जना गर्नुहोस् जसले argument को रूपमा string लिन्छ र
वर्णमालालाई घुमाएर (rotated) encrypt गरिएको string फिर्ता गर्छ।
वर्णमालालाई यसरी घुमाइनुपर्छ कि अक्षरहरू
दुई गुणा दुई (two multiplied to two) स्थान तल सरोस्।
उदाहरणका लागि:
encrypt('hi') ले 'lm' फिर... |
def encrypt(s):
"""ଗୋଟିଏ ଫଙ୍କସନ୍ encrypt ତିଆରି କରନ୍ତୁ ଯାହା ଏକ string କୁ argument ଭାବରେ ଗ୍ରହଣ କରେ ଏବଂ
ବର୍ଣ୍ଣମାଳା ଘୂର୍ଣ୍ଣନ (rotate) କରି ଏନକ୍ରିପ୍ଟ ହୋଇଥିବା ଏକ string ଫେରାଏ।
ବର୍ଣ୍ଣମାଳାକୁ ଏପରି ଭାବରେ ଘୂର୍ଣ୍ଣନ କରାଯିବା ଉଚିତ ଯେପରି ଅକ୍ଷରଗୁଡ଼ିକ
ଦୁଇ ଗୁଣନ ଦୁଇ ସ୍ଥାନ ତଳକୁ ଘୁଞ୍ଚିବ (shift down)।
ଉଦାହରଣ ସ୍ୱରୂପ:
... |
def encrypt(s):
"""ਇੱਕ ਫੰਕਸ਼ਨ encrypt ਬਣਾਓ ਜੋ ਇੱਕ string ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਲੈਂਦਾ ਹੈ ਅਤੇ
ਵਰਣਮਾਲਾ ਨੂੰ ਘੁਮਾ ਕੇ ਐਨਕ੍ਰਿਪਟ ਕੀਤੀ ਗਈ ਇੱਕ string ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਵਰਣਮਾਲਾ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਘੁਮਾਇਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਅੱਖਰ
ਦੋ ਗੁਣਾ ਦੋ ਥਾਵਾਂ ਹੇਠਾਂ ਵੱਲ ਸ਼ਿਫਟ ਹੋ ਜਾਣ।
ਉਦਾਹਰਨ ਲਈ:
encrypt('hi') 'lm' ਵਾਪਸ ਕਰਦਾ ਹੈ
... |
def encrypt(s):
"""encrypt इति फलनं रचयतु यत् काञ्चित् string प्राचलरूपेण स्वीकरोति तथा
वर्णमालां घूर्णयित्वा गूढीकृतं string प्रत्याददाति।
वर्णमाला एवं प्रकारेण घूर्णीया येन अक्षराणि
द्विना गुणिते द्वौ (2 * 2) स्थानानि अग्रे सरन्ति।
उदाहरणार्थम्:
encrypt('hi') 'lm' प्रत्याददाति
encrypt('as... |
def encrypt(s):
"""ஒரு சரத்தை (string) உள்ளீட்டு மதிப்பாக (argument) ஏற்றுக்கொண்டு, எழுத்துக்களைச் சுழற்றி
என்க்ரிப்ட் செய்யப்பட்ட ஒரு சரத்தைத் திருப்பி அனுப்பும் encrypt என்ற செயல்பாட்டை உருவாக்கவும்.
எழுத்துக்கள் இரண்டை இரண்டால் பெருக்கினால் வரும் இடங்கள் அளவுக்கு கீழே நகரும் வகையில்
எழுத்துக்கள் ச... |
def encrypt(s):
"""ఒక స్ట్రింగ్ను ఆర్గ్యుమెంట్గా తీసుకుని, ఆల్ఫాబెట్ను రొటేట్ చేయడం ద్వారా ఎన్క్రిప్ట్ చేయబడిన
స్ట్రింగ్ను రిటర్న్ చేసే encrypt అనే ఫంక్షన్ను సృష్టించండి.
అక్షరాలు రెండుని రెండుతో గుణించగా వచ్చే స్థానాలు క్రిందికి మారేలా (shift down అయ్యేలా)
ఆల్ఫాబెట్ రొటేట్ చేయబడాలి.
ఉదాహరణకు... |
def encrypt(s):
"""ایک ایسا فنکشن encrypt بنائیں جو ایک string بطور آرگومنٹ لیتا ہے اور
حروف تہجی کو روٹیٹ کر کے اینکرپٹ شدہ string واپس کرتا ہے۔
حروف تہجی کو اس طریقے سے روٹیٹ کیا جانا چاہیے کہ حروف
دو ضرب دو درجے نیچے شفٹ ہو جائیں۔
مثال کے طور پر:
encrypt('hi') واپس کرتا ہے 'lm'
encrypt('... |
HumanEval/90 |
def next_smallest(lst):
"""
You are given a list of integers.
Write a function next_smallest() that returns the 2nd smallest element of the list.
Return None if there is no such element.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
... | lst = sorted(set(lst))
return None if len(lst) < 2 else lst[1]
| def check(candidate):
# Check some simple cases
assert candidate([1, 2, 3, 4, 5]) == 2
assert candidate([5, 1, 4, 3, 2]) == 2
assert candidate([]) == None
assert candidate([1, 1]) == None
assert candidate([1,1,1,1,0]) == 1
assert candidate([1, 0**0]) == None
assert candidate([-35, 34, 1... | next_smallest |
def next_smallest(lst):
"""
আপোনাক এটা integers-ৰ list দিয়া হৈছে।
এটা ফাংচন next_smallest() লিখক যিয়ে list-টোৰ 2nd smallest উপাদানটো ঘূৰাই দিয়ে।
যদি তেনে কোনো উপাদান নাই তেন্তে None ঘূৰাই দিয়ক।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]... |
def next_smallest(lst):
"""
আপনাকে পূর্ণসংখ্যার একটি লিস্ট দেওয়া হয়েছে।
একটি ফাংশন next_smallest() লিখুন যা লিস্টের 2nd ক্ষুদ্রতম উপাদানটি রিটার্ন করে।
এমন কোনো উপাদান না থাকলে None রিটার্ন করুন।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) ... |
def next_smallest(lst):
"""
તમને પૂર્ણાંકોની એક list આપવામાં આવી છે.
next_smallest() નામનું ફંક્શન લખો જે list નો 2nd સૌથી નાનો ઘટક રીટર્ન કરે.
જો આવો કોઈ ઘટક ન હોય તો None રીટર્ન કરો.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
... |
def next_smallest(lst):
"""
आपको पूर्णांकों की एक सूची दी गई है।
एक फ़ंक्शन next_smallest() लिखें जो सूची का दूसरा सबसे छोटा (2nd smallest) तत्व लौटाता है।
यदि ऐसा कोई तत्व नहीं है तो None लौटाएं।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([])... |
def next_smallest(lst):
"""
ನಿಮಗೆ ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯೊಂದನ್ನು ನೀಡಲಾಗಿದೆ.
ಪಟ್ಟಿಯ 2 ನೇ ಅತಿ ಚಿಕ್ಕ ಎಲಿಮೆಂಟ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ next_smallest() ಫಂಕ್ಷನ್ ಅನ್ನು ಬರೆಯಿರಿ.
ಅಂತಹ ಯಾವುದೇ ಎಲಿಮೆಂಟ್ ಇಲ್ಲದಿದ್ದರೆ None ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
... |
def next_smallest(lst):
"""
നിങ്ങൾക്ക് പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് നൽകിയിരിക്കുന്നു.
ലിസ്റ്റിലെ രണ്ടാമത്തെ ഏറ്റവും ചെറിയ എലമെന്റ് നൽകുന്ന next_smallest() എന്ന ഫംഗ്ഷൻ എഴുതുക.
അത്തരം ഒരു എലമെന്റ് ഇല്ലെങ്കിൽ None നൽകുക.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2... |
def next_smallest(lst):
"""
तुम्हाला integers ची एक list दिली आहे.
next_smallest() हे फंक्शन लिहा जे list मधील 2रा सर्वात लहान घटक परत करेल.
असा घटक नसल्यास None परत करा.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == None
next_smallest... |
def next_smallest(lst):
"""
तपाईंलाई पूर्णाङ्कहरूको एउटा सूची (list) दिइएको छ।
सूचीको दोस्रो सबैभन्दा सानो तत्व फर्काउने एउटा प्रकार्य next_smallest() लेख्नुहोस्।
यदि त्यस्तो कुनै तत्व छैन भने None फर्काउनुहोस्।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
ne... |
def next_smallest(lst):
"""
ଆପଣଙ୍କୁ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ list ଦିଆଯାଇଛି।
next_smallest() ନାମକ ଏକ ଫଙ୍କସନ୍ ଲେଖନ୍ତୁ ଯାହା list ର ୨ୟ କ୍ଷୁଦ୍ରତମ (2nd smallest) ଉପାଦାନ ଫେରସ୍ତ କରେ।
ଯଦି ସେପରି କୌଣସି ଉପାଦାନ ନାହିଁ, ତେବେ None ଫେରସ୍ତ କରନ୍ତୁ।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3... |
def next_smallest(lst):
"""
ਤੁਹਾਨੂੰ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦਿੱਤੀ ਗਈ ਹੈ।
ਇੱਕ ਫੰਕਸ਼ਨ next_smallest() ਲਿਖੋ ਜੋ ਸੂਚੀ ਦਾ 2nd ਸਭ ਤੋਂ ਛੋਟਾ ਐਲੀਮੈਂਟ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਜੇਕਰ ਅਜਿਹਾ ਕੋਈ ਐਲੀਮੈਂਟ ਨਹੀਂ ਹੈ ਤਾਂ None ਵਾਪਸ ਕਰੋ।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smalle... |
def next_smallest(lst):
"""
भवते पूर्णाङ्कानाम् एका सूची दत्ता अस्ति।
next_smallest() इति फलनं लिखन्तु यत् सूच्याः द्वितीयं लघुतमं तत्त्वं प्रत्यानयति।
यदि तादृशं तत्त्वं न विद्यते तर्हि None प्रत्यानयन्तु।
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_sm... |
def next_smallest(lst):
"""
முழுஎண்களின் பட்டியல் ஒன்று கொடுக்கப்பட்டுள்ளது.
பட்டியலின் 2-வது மிகச்சிறிய உறுப்பைத் தரும் next_smallest() என்ற சார்பை எழுதுக.
அத்தகைய உறுப்பு எதுவும் இல்லை என்றால் None-ஐத் திருப்பவும்.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
... |
def next_smallest(lst):
"""
మీకు పూర్ణాంకాల జాబితా ఇవ్వబడింది.
జాబితాలోని 2వ అతిచిన్న మూలకాన్ని రిటర్న్ చేసే next_smallest() ఫంక్షన్ను రాయండి.
అటువంటి మూలకం లేకపోతే None ని రిటర్న్ చేయండి.
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
next_smallest([]) == Non... |
def next_smallest(lst):
"""
آپ کو صحیح اعداد (integers) کی ایک فہرست دی گئی ہے۔
ایک فنکشن next_smallest() لکھیں جو فہرست کا دوسرا سب سے چھوٹا (2nd smallest) عنصر واپس کرے۔
اگر ایسا کوئی عنصر نہ ہو تو None واپس کریں۔
next_smallest([1, 2, 3, 4, 5]) == 2
next_smallest([5, 1, 4, 3, 2]) == 2
... |
HumanEval/91 |
def is_bored(S):
"""
You'll be given a string of words, and your task is to count the number
of boredoms. A boredom is a sentence that starts with the word "I".
Sentences are delimited by '.', '?' or '!'.
For example:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The ... | import re
sentences = re.split(r'[.?!]\s*', S)
return sum(sentence[0:2] == 'I ' for sentence in sentences)
| def check(candidate):
# Check some simple cases
assert candidate("Hello world") == 0, "Test 1"
assert candidate("Is the sky blue?") == 0, "Test 2"
assert candidate("I love It !") == 1, "Test 3"
assert candidate("bIt") == 0, "Test 4"
assert candidate("I feel good today. I will be productive. wil... | is_bored |
def is_bored(S):
"""
আপোনাক শব্দৰ এটা ষ্ট্ৰিং দিয়া হ'ব, আৰু আপোনাৰ কাম হৈছে boredom-ৰ সংখ্যা গণনা
কৰা। এটা boredom হৈছে এনে এটা বাক্য যিটো "I" শব্দৰে আৰম্ভ হয়।
বাক্যসমূহ '.', '?' বা '!' দ্বাৰা বিভক্ত কৰা হয়।
উদাহৰণস্বৰূপে:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is bl... |
def is_bored(S):
"""
আপনাকে শব্দের একটি স্ট্রিং দেওয়া হবে, এবং আপনার কাজ হলো boredom-এর সংখ্যা গণনা
করা। একটি boredom হলো এমন একটি বাক্য যা "I" শব্দটি দিয়ে শুরু হয়।
বাক্যগুলো '.', '?' অথবা '!' দ্বারা পৃথক করা থাকে।
উদাহরণস্বরূপ:
>>> is_bored("Hello world")
0
>>> is_bored("The sky... |
def is_bored(S):
"""
તમને શબ્દોની એક સ્ટ્રિંગ આપવામાં આવશે, અને તમારું કાર્ય boredom ની સંખ્યા
ગણવાનું છે. boredom એ એવું વાક્ય છે જે "I" શબ્દથી શરૂ થાય છે.
વાક્યો '.', '?' અથવા '!' દ્વારા અલગ પડે છે.
ઉદાહરણ તરીકે:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun... |
def is_bored(S):
"""
आपको शब्दों की एक स्ट्रिंग दी जाएगी, और आपका कार्य boredom की संख्या
गिनना है। एक boredom वह वाक्य है जो शब्द "I" से शुरू होता है।
वाक्य '.', '?' या '!' द्वारा अलग (delimited) किए जाते हैं।
उदाहरण के लिए:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is bl... |
def is_bored(S):
"""
ನಿಮಗೆ ಪದಗಳ ಒಂದು string ನೀಡಲಾಗುವುದು, ಮತ್ತು boredom ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಲೆಕ್ಕ ಹಾಕುವುದು
ನಿಮ್ಮ ಕಾರ್ಯವಾಗಿದೆ. "I" ಪದದಿಂದ ಪ್ರಾರಂಭವಾಗುವ ವಾಕ್ಯವನ್ನು boredom ಎನ್ನಲಾಗುತ್ತದೆ.
ವಾಕ್ಯಗಳನ್ನು '.', '?' ಅಥವಾ '!' ನಿಂದ ಬೇರ್ಪಡಿಸಲಾಗುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ:
>>> is_bored("Hello world")
0
>>> is_bor... |
def is_bored(S):
"""
നിങ്ങൾക്ക് വാക്കുകളുടെ ഒരു സ്ട്രിംഗ് നൽകപ്പെടും, കൂടാതെ boredoms-ന്റെ എണ്ണം
കണക്കാക്കുക എന്നതാണ് നിങ്ങളുടെ ദൗത്യം. "I" എന്ന വാക്കിൽ തുടങ്ങുന്ന വാക്യത്തെയാണ് boredom എന്ന് പറയുന്നത്.
വാക്യങ്ങൾ '.', '?' അല്ലെങ്കിൽ '!' എന്നിവയാൽ വേർതിരിച്ചിരിക്കുന്നു.
ഉദാഹരണത്തിന്:
>>> is_... |
def is_bored(S):
"""
तुम्हाला शब्दांची एक स्ट्रिंग दिली जाईल, आणि boredom ची संख्या मोजणे हे
तुमचे कार्य आहे. Boredom म्हणजे असे वाक्य जे "I" या शब्दाने सुरू होते.
वाक्ये '.', '?' किंवा '!' द्वारे विभक्त (delimited) केली जातात.
उदाहरणार्थ:
>>> is_bored("Hello world")
0
>>> is_bored(... |
def is_bored(S):
"""
तपाईंलाई शब्दहरूको एउटा स्ट्रिङ दिइनेछ, र तपाईंको कार्य boredom हरूको सङ्ख्या
गणना गर्नु हो। boredom भनेको "I" शब्दबाट सुरु हुने वाक्य हो।
वाक्यहरू '.', '?' वा '!' द्वारा छुट्ट्याइएका हुन्छन्।
उदाहरणका लागि:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is... |
def is_bored(S):
"""
ଆପଣଙ୍କୁ ଶବ୍ଦଗୁଡ଼ିକର ଏକ string ଦିଆଯିବ, ଏବଂ ଆପଣଙ୍କ କାର୍ଯ୍ୟ ହେଉଛି boredom ର ସଂଖ୍ୟା ଗଣନା
କରିବା। ଗୋଟିଏ boredom ହେଉଛି ଏପରି ଏକ ବାକ୍ୟ ଯାହା "I" ଶବ୍ଦ ସହିତ ଆରମ୍ଭ ହୁଏ।
ବାକ୍ୟଗୁଡ଼ିକ '.', '?' କିମ୍ବା '!' ଦ୍ୱାରା ବିଭାଜିତ ହୋଇଥାଏ।
ଉଦାହରଣ ସ୍ୱରୂପ:
>>> is_bored("Hello world")
0
>>> is... |
def is_bored(S):
"""
ਤੁਹਾਨੂੰ ਸ਼ਬਦਾਂ ਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਦਿੱਤੀ ਜਾਵੇਗੀ, ਅਤੇ ਤੁਹਾਡਾ ਕੰਮ boredoms ਦੀ ਗਿਣਤੀ
ਕਰਨਾ ਹੈ। ਇੱਕ boredom ਉਹ ਵਾਕ ਹੁੰਦਾ ਹੈ ਜੋ ਸ਼ਬਦ "I" ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ।
ਵਾਕਾਂ ਨੂੰ '.', '?' ਜਾਂ '!' ਦੁਆਰਾ ਵੱਖ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਉਦਾਹਰਨ ਲਈ:
>>> is_bored("Hello world")
0
>>> is_bored("The sky i... |
def is_bored(S):
"""
भवते शब्दानाम् एकः string दीयते, तथा च boredom इत्येतेषां सङ्ख्यां
गणयितुं भवतां कार्यम् अस्ति। boredom तादृशं वाक्यं भवति यत् "I" इति शब्देन प्रारभते।
वाक्यानि '.', '?' अथवा '!' इत्येतैः परिसीमितानि भवन्ति।
यथा उदाहरणार्थम्:
>>> is_bored("Hello world")
0
>>> is... |
def is_bored(S):
"""
உங்களுக்கு வார்த்தைகளைக் கொண்ட ஒரு string கொடுக்கப்படும், மேலும் boredom-களின்
எண்ணிக்கையைக் கணக்கிடுவதே உங்கள் பணியாகும். "I" என்ற சொல்லுடன் தொடங்கும் ஒரு வாக்கியமே boredom ஆகும்.
வாக்கியங்கள் '.', '?' அல்லது '!' ஆகியவற்றால் பிரிக்கப்படுகின்றன.
எடுத்துக்காட்டாக:
>>> is... |
def is_bored(S):
"""
మీకు పదాల string ఇవ్వబడుతుంది, మరియు boredom ల సంఖ్యను లెక్కించడం మీ పని.
ఒక boredom అంటే "I" అనే పదంతో ప్రారంభమయ్యే వాక్యం.
వాక్యాలు '.', '?' లేదా '!' ద్వారా వేరు చేయబడతాయి.
ఉదాహరణకు:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun is shini... |
def is_bored(S):
"""
آپ کو الفاظ کی ایک اسٹرنگ دی جائے گی، اور آپ کا کام boredoms کی تعداد شمار کرنا ہے۔
ایک boredom وہ جملہ ہے جو لفظ "I" سے شروع ہوتا ہے۔
جملے '.'، '?' یا '!' سے الگ کیے جاتے ہیں۔
مثال کے طور پر:
>>> is_bored("Hello world")
0
>>> is_bored("The sky is blue. The sun ... |
HumanEval/92 |
def any_int(x, y, z):
'''
Create a function that takes 3 numbers.
Returns true if one of the numbers is equal to the sum of the other two, and all numbers are integers.
Returns false in any other cases.
Examples
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_int(3, -2, ... |
if isinstance(x,int) and isinstance(y,int) and isinstance(z,int):
if (x+y==z) or (x+z==y) or (y+z==x):
return True
return False
return False
| def check(candidate):
# Check some simple cases
assert candidate(2, 3, 1)==True, "This prints if this assert fails 1 (good for debugging!)"
assert candidate(2.5, 2, 3)==False, "This prints if this assert fails 2 (good for debugging!)"
assert candidate(1.5, 5, 3.5)==False, "This prints if this assert fa... | any_int |
def any_int(x, y, z):
'''
৩ টা সংখ্যা গ্ৰহণ কৰা এটা ফলন সৃষ্টি কৰক।
যদি সংখ্যাবোৰৰ এটা বাকী দুটাৰ যোগফলৰ সমান হয়, আৰু সকলোবোৰ সংখ্যা অখণ্ড সংখ্যা (integer) হয়, তেন্তে true ঘূৰাই দিয়ে।
অন্য যিকোনো ক্ষেত্ৰত false ঘূৰাই দিয়ে।
উদাহৰণসমূহ
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ ... |
def any_int(x, y, z):
'''
একটি ফাংশন তৈরি করুন যা 3টি সংখ্যা গ্রহণ করে।
যদি সংখ্যাগুলির একটি অন্য দুটির যোগফলের সমান হয় এবং সমস্ত সংখ্যা পূর্ণসংখ্যা হয়, তবে true রিটার্ন করে।
অন্য যেকোনো ক্ষেত্রে false রিটার্ন করে।
Examples
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
a... |
def any_int(x, y, z):
'''
3 સંખ્યાઓ લેતું એક ફંક્શન બનાવો.
જો તેમાંથી કોઈ એક સંખ્યા બાકીની બે સંખ્યાઓના સરવાળા જેટલી હોય, અને બધી સંખ્યાઓ પૂર્ણાંક હોય તો true રિટર્ન કરે છે.
અન્ય કોઈપણ કિસ્સામાં false રિટર્ન કરે છે.
Examples
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
an... |
def any_int(x, y, z):
'''
एक ऐसा फ़ंक्शन बनाएं जो 3 संख्याएं लेता हो।
यदि इनमें से कोई एक संख्या अन्य दो के योग के बराबर है, और सभी संख्याएं पूर्णांक (integers) हैं, तो true लौटाता है।
अन्य किसी भी स्थिति में false लौटाता है।
उदाहरण
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False... |
def any_int(x, y, z):
'''
3 ಸಂಖ್ಯೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಒಂದು ಫಂಕ್ಷನ್ ರಚಿಸಿ.
ಸಂಖ್ಯೆಗಳಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆಯು ಉಳಿದೆರಡು ಸಂಖ್ಯೆಗಳ ಮೊತ್ತಕ್ಕೆ ಸಮನಾಗಿದ್ದು, ಮತ್ತು ಎಲ್ಲ ಸಂಖ್ಯೆಗಳೂ ಪೂರ್ಣಾಂಕಗಳಾಗಿದ್ದರೆ (integers) true ರಿಟರ್ನ್ ಮಾಡುತ್ತದೆ.
ಇತರ ಯಾವುದೇ ಸಂದರ್ಭಗಳಲ್ಲಿ false ರಿಟರ್ನ್ ಮಾಡುತ್ತದೆ.
ಉದಾಹರಣೆಗಳು
any_int(5, 2,... |
def any_int(x, y, z):
'''
3 സംഖ്യകൾ സ്വീകരിക്കുന്ന ഒരു ഫംഗ്ഷൻ നിർമ്മിക്കുക.
സംഖ്യകളിൽ ഒരെണ്ണം മറ്റ് രണ്ട് സംഖ്യകളുടെ തുകയ്ക്ക് തുല്യമാവുകയും, എല്ലാ സംഖ്യകളും പൂർണ്ണസംഖ്യകൾ (integers) ആവുകയും ചെയ്താൽ true നൽകുക.
മറ്റെല്ലാ സാഹചര്യങ്ങളിലും false നൽകുക.
Examples
any_int(5, 2, 7) ➞ True
... |
def any_int(x, y, z):
'''
3 संख्या घेणारे एक फंक्शन तयार करा.
जर त्या संख्यांपैकी एक संख्या इतर दोन संख्यांच्या बेरजेइतकी असेल आणि सर्व संख्या पूर्णांक (integers) असतील, तर true परत करते.
इतर कोणत्याही बाबतीत false परत करते.
उदाहरणे
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False... |
def any_int(x, y, z):
'''
3 वटा संख्याहरू लिने एउटा फलनबनाउनुहोस्।
यदि संख्याहरू मध्ये कुनै एउटा संख्या बाँकी दुई संख्याको योगफलसँग बराबर छ, र सबै संख्याहरू पूर्णाङ्क (integers) हुन् भने true फर्काउँछ।
अन्य कुनै पनि अवस्थामा false फर्काउँछ।
Examples
any_int(5, 2, 7) ➞ True
any_int... |
def any_int(x, y, z):
'''
3 ଟି ସଂଖ୍ୟା ଗ୍ରହଣ କରୁଥିବା ଏକ ଫଙ୍କସନ୍ ତିଆରି କରନ୍ତୁ।
ଯଦି ସଂଖ୍ୟାଗୁଡ଼ିକ ମଧ୍ୟରୁ ଗୋଟିଏ ଅନ୍ୟ ଦୁଇଟିର ଯୋଗଫଳ ସହିତ ସମାନ ହୁଏ, ଏବଂ ସମସ୍ତ ସଂଖ୍ୟା ପୂର୍ଣ୍ଣସଂଖ୍ୟା (integers) ହୋଇଥାନ୍ତି, ତେବେ true ଫେରାଏ।
ଅନ୍ୟ ଯେକୌଣସି କ୍ଷେତ୍ରରେ false ଫେରାଏ।
ଉଦାହରଣଗୁଡ଼ିକ
any_int(5, 2, 7) ➞ True
... |
def any_int(x, y, z):
'''
ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਓ ਜੋ 3 ਸੰਖਿਆਵਾਂ ਲੈਂਦਾ ਹੈ।
ਜੇਕਰ ਸੰਖਿਆਵਾਂ ਵਿੱਚੋਂ ਕੋਈ ਇੱਕ ਬਾਕੀ ਦੋ ਦੇ ਜੋੜ ਦੇ ਬਰਾਬਰ ਹੋਵੇ, ਅਤੇ ਸਾਰੀਆਂ ਸੰਖਿਆਵਾਂ integers ਹੋਣ ਤਾਂ true ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਕਿਸੇ ਵੀ ਹੋਰ ਸਥਿਤੀ ਵਿੱਚ false ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਉਦਾਹਰਨਾਂ
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False... |
def any_int(x, y, z):
'''
तिस्रः संख्याः स्वीकुर्वत् एकं फलनं रचयतु।
यदि काचित् एका संख्या इतरयोः द्वयोः योगसमाना भवति, तथा च सर्वाः संख्याः पूर्णाङ्काः सन्ति, तर्हि true प्रत्यापयति।
अन्येषु सर्वेषु सन्दर्भेषु false प्रत्यापयति।
उदाहरणानि
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ... |
def any_int(x, y, z):
'''
3 எண்களை எடுத்துக்கொள்ளும் ஒரு செயல்பாட்டை உருவாக்கவும்.
எண்களில் ஒன்று மற்ற இரண்டு எண்களின் கூட்டுத்தொகைக்கு சமமாகவும், அனைத்து எண்களும் முழு எண்களாகவும் இருந்தால் true என்பதைத் திருப்பியளிக்கும்.
மற்ற அனைத்து நிலைகளிலும் false என்பதைத் திருப்பியளிக்கும்.
எடுத்துக்கா... |
def any_int(x, y, z):
'''
3 సంఖ్యలను తీసుకునే ఒక ఫంక్షన్ను సృష్టించండి.
సంఖ్యలలో ఏదైనా ఒకటి మిగిలిన రెండింటి మొత్తానికి సమానమై, మరియు అన్ని సంఖ్యలు పూర్ణాంకాలు (integers) అయితే true ని అందిస్తుంది.
మిగిలిన ఏ సందర్భాలలోనైనా false ని అందిస్తుంది.
ఉదాహరణలు
any_int(5, 2, 7) ➞ True
an... |
def any_int(x, y, z):
'''
ایک ایسا فنکشن بنائیں جو 3 اعداد لیتا ہو۔
اگر اعداد میں سے کوئی ایک عدد باقی دو کے مجموعے کے برابر ہو، اور تمام اعداد integers ہوں تو true واپس کرے۔
کسی بھی دوسری صورت میں false واپس کرے۔
Examples
any_int(5, 2, 7) ➞ True
any_int(3, 2, 2) ➞ False
any_... |
HumanEval/93 |
def encode(message):
"""
Write a function that takes a message, and encodes in such a
way that it swaps case of all letters, replaces all vowels in
the message with the letter that appears 2 places ahead of that
vowel in the english alphabet.
Assume only letters.
Examples:
>>>... | vowels = "aeiouAEIOU"
vowels_replace = dict([(i, chr(ord(i) + 2)) for i in vowels])
message = message.swapcase()
return ''.join([vowels_replace[i] if i in vowels else i for i in message])
| def check(candidate):
# Check some simple cases
assert candidate('TEST') == 'tgst', "This prints if this assert fails 1 (good for debugging!)"
assert candidate('Mudasir') == 'mWDCSKR', "This prints if this assert fails 2 (good for debugging!)"
assert candidate('YES') == 'ygs', "This prints if this asse... | encode |
def encode(message):
"""
এটা ফলন লিখক যিয়ে এটা message গ্ৰহণ কৰে, আৰু ইয়াক এনেদৰে encode কৰে যাতে ই সকলো আখৰৰ case অদল-বদল কৰে, message-টোত থকা সকলো vowel-ক ইংৰাজী বৰ্ণমালাত সেই vowel-টোৰ ২ টা স্থান আগত থকা আখৰটোৰে প্ৰতিস্থাপন কৰে।
কেৱল আখৰ আছে বুলি ধৰি লওক।
উদাহৰণসমূহ:
>>> encode('test')
... |
def encode(message):
"""
একটি ফাংশন লিখুন যা একটি message গ্রহণ করে এবং এমনভাবে এনকোড করে যাতে এটি সমস্ত অক্ষরের কেস অদলবদল (swap) করে, message-এর সমস্ত vowel-কে ইংরেজি বর্ণমালায় সেই vowel-এর ২ স্থান পরের অক্ষর দিয়ে প্রতিস্থাপন করে।
ধরে নিন শুধুমাত্র অক্ষর রয়েছে।
Examples:
>>> encode('test')
... |
def encode(message):
"""
એક ફંક્શન લખો જે એક message લે છે, અને તેને એવી રીતે encode કરે છે કે
તે બધા અક્ષરોનો case swap કરે છે, message માંના બધા vowels ને
અંગ્રેજી મૂળાક્ષરોમાં તે vowel કરતાં 2 સ્થાન આગળ આવતા
અક્ષર વડે બદલે છે.
માત્ર અક્ષરો જ છે એમ ધારી લો.
ઉદાહરણો:
>>> enco... |
def encode(message):
"""
एक ऐसा फ़ंक्शन लिखें जो एक message लेता है, और इसे इस प्रकार एन्कोड करता है
कि यह सभी अक्षरों का केस (case) बदल देता है, message में मौजूद सभी vowels को
अंग्रेजी वर्णमाला में उस vowel से 2 स्थान आगे आने वाले अक्षर से बदल देता है।
केवल अक्षरों को ही मानकर चलें।
Exam... |
def encode(message):
"""
ಒಂದು ಸಂದೇಶವನ್ನು (message) ತೆಗೆದುಕೊಂಡು, ಎಲ್ಲಾ ಅಕ್ಷರಗಳ ಕೇಸ್ ಅನ್ನು ಅದಲುಬದಲು ಮಾಡುವ
ಮತ್ತು ಸಂದೇಶದಲ್ಲಿರುವ ಎಲ್ಲಾ ಸ್ವರಗಳನ್ನು (vowels) ಇಂಗ್ಲಿಷ್ ವರ್ಣಮಾಲೆಯಲ್ಲಿ ಆ ಸ್ವರಕ್ಕಿಂತ
2 ಸ್ಥಾನಗಳಷ್ಟು ಮುಂದೆ ಬರುವ ಅಕ್ಷರದಿಂದ ಬದಲಾಯಿಸುವ ರೀತಿಯಲ್ಲಿ ಎನ್ಕೋಡ್ ಮಾಡುವ ಫಂಕ್ಷನ್
ಒಂದನ್ನು ಬರೆಯಿರಿ.
ಕೇವಲ ಅಕ್ಷರಗಳ... | def encode(message):
"""
ഒരു സന്ദേശം സ്വീകരിച്ച്, അതിലെ എല്ലാ അക്ഷരങ്ങളുടെയും case മാറ്റുകയും, സന്ദേശത്തിലെ
എല്ലാ സ്വരാക്ഷരങ്ങളെയും ഇംഗ്ലീഷ് അക്ഷരമാലയിൽ ആ സ്വരാക്ഷരത്തിന് 2 സ്ഥാനങ്ങൾ മുന്നിലുള്ള
അക്ഷരം ഉപയോഗിച്ച് പകരം റീപ്ലേസ് ചെയ്യുകയും ചെയ്യുന്ന രീതിയിൽ encode ചെയ്യുന്ന
ഒരു ഫംഗ്ഷൻ എഴുതുക.
അക്... |
def encode(message):
"""
एक फंक्शन लिहा जे message घेते, आणि ते अशा प्रकारे encode करते की
सर्व अक्षरांचा case बदलते (swap करते), message मधील सर्व vowels ना
इंग्रजी वर्णमालेत त्या vowel च्या 2 स्थाने पुढे असणाऱ्या अक्षराने बदलते.
फक्त अक्षरेच आहेत असे गृहीत धरा.
उदाहरणे:
>>> encode... |
def encode(message):
"""
एउटा सन्देश (message) लिने, र यसलाई यसरी encode गर्ने एउटा function लेख्नुहोस्
जसले सबै अक्षरहरूको case साटासाट गर्दछ, सन्देशमा रहेका सबै vowels लाई
अंग्रेजी वर्णमालामा त्यो vowel भन्दा २ स्थान अगाडि आउने अक्षरले
प्रतिस्थापन गर्दछ।
केवल अक्षरहरू मात्र छन् भनी मान्नुहोस्... |
def encode(message):
"""
ଗୋଟିଏ ଫଙ୍କସନ ଲେଖନ୍ତୁ ଯାହା ଏକ message ଗ୍ରହଣ କରେ, ଏବଂ ଏହାକୁ ଏପରି ଭାବରେ encode କରେ ଯେ
ଏହା ସମସ୍ତ ଅକ୍ଷରଗୁଡ଼ିକର case ବଦଳାଇ ଦିଏ (swap କରେ), message ରେ ଥିବା ସମସ୍ତ vowel କୁ
ଇଂରାଜୀ ବର୍ଣ୍ଣମାଳାରେ ସେହି vowel ର 2 ଟି ସ୍ଥାନ ପରେ ଆସୁଥିବା ଅକ୍ଷର ସହିତ ପ୍ରତିସ୍ଥାପନ କରେ।
କେବଳ ଅକ୍ଷର ହିଁ ଅଛି ବୋଲି... |
def encode(message):
"""
ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਿਖੋ ਜੋ ਇੱਕ message ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ
encode ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਸਾਰੇ ਅੱਖਰਾਂ ਦਾ ਕੇਸ (case) ਬਦਲ ਦਿੰਦਾ ਹੈ, message ਵਿਚਲੇ
ਸਾਰੇ vowels ਨੂੰ ਅੰਗਰੇਜ਼ੀ ਵਰਣਮਾਲਾ (english alphabet) ਵਿੱਚ ਉਸ vowel ਤੋਂ
2 ਸਥਾਨ ਅੱਗੇ ਆਉਣ ਵਾਲੇ ਅੱਖਰ ਨਾਲ ਬਦਲ ਦਿੰਦਾ ਹੈ।
ਸਿਰਫ਼ ਅ... |
def encode(message):
"""
एतादृशं फलनं लिखतु यत् message स्वीकरोति, तथा च एवं कूटयति
येन तत् सर्वेषां वर्णानां case विपर्यस्यति (swaps), message
मध्ये स्थितान् सर्वान् स्वरवर्णान् (vowels) आङ्ग्लवर्णमालायां तस्मात्
स्वरवर्णात् 2 स्थानानि अग्रे विद्यमानेन वर्णेन प्रतिस्थापयति।
केवलं वर्णाः एव... |
def encode(message):
"""
ஒரு message-ஐப் பெற்று, அனைத்து எழுத்துகளின் case-ஐ மாற்றி (swaps case), message-இல் உள்ள
அனைத்து vowels-களையும் ஆங்கில நெடுங்கணக்கில் (english alphabet) அந்த vowel-க்கு 2 இடங்கள்
அடுத்து (ahead) வரும் எழுத்தாக மாற்றும் வகையில் encode செய்யும் ஒரு function-ஐ எழுதுக.
எழுத்து... |
def encode(message):
"""
ఒక message ను తీసుకుని, అన్ని అక్షరాల కేస్ (case) ను పరస్పరం మార్చి (swap చేసి),
ఆ message లోని అన్ని అచ్చులను (vowels) english alphabet లో ఆ
అచ్చు కంటే 2 స్థానాలు ముందుకు ఉండే అక్షరంతో భర్తీ చేసే విధంగా
దానిని encode చేసే ఫంక్షన్ను రాయండి.
కేవలం అక్షరాలు మాత్రమే ఉ... |
def encode(message):
"""
ایک ایسا فنکشن لکھیں جو ایک message لیتا ہے، اور اسے اس طرح encode کرتا
ہے کہ یہ تمام حروف کا کیس تبدیل (swap) کر دیتا ہے، message میں موجود تمام vowels
کو انگریزی حروف تہجی میں اس vowel سے 2 درجے آگے آنے والے حرف سے بدل
دیتا ہے۔
صرف حروف فرض کریں۔
Examples:
... |
HumanEval/94 |
def skjkasdkd(lst):
"""You are given a list of integers.
You need to find the largest prime value and return the sum of its digits.
Examples:
For lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] the output should be 10
For lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] the output shoul... | def isPrime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
maxx = 0
i = 0
while i < len(lst):
if(lst[i] > maxx and isPrime(lst[i])):
maxx = lst[i]
i+=1
result = sum(int(digit) for digit in str(maxx))
... | def check(candidate):
# Check some simple cases
assert candidate([0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3]) == 10, "This prints if this assert fails 1 (good for debugging!)"
# Check some edge cases that are easy to work out by hand.
assert candidate([1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]... | skjkasdkd |
def skjkasdkd(lst):
"""আপোনাক এটা অখণ্ড সংখ্যাৰ তালিকা দিয়া হৈছে।
আপুনি আটাইতকৈ ডাঙৰ মৌলিক মানটো বিচাৰি উলিয়াব লাগিব আৰু তাৰ অংকসমূহৰ যোগফল ঘূৰাই দিব লাগিব।
উদাহৰণ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ৰ বাবে আউটপুট হ'ব লাগে 10
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,... |
def skjkasdkd(lst):
"""আপনাকে পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে।
আপনাকে বৃহত্তম মৌলিক মানটি খুঁজে বের করতে হবে এবং এর অঙ্কগুলোর যোগফল রিটার্ন করতে হবে।
উদাহরণ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] এর জন্য আউটপুট 10 হওয়া উচিত
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]... |
def skjkasdkd(lst):
"""તમને પૂર્ણાંકોની એક list આપવામાં આવી છે.
તમારે સૌથી મોટી અવિભાજ્ય (prime) કિંમત શોધવાની છે અને તેના અંકોનો સરવાળો રિટર્ન કરવાનો છે.
ઉદાહરણો:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] માટે આઉટપુટ 10 હોવું જોઈએ
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] ... |
def skjkasdkd(lst):
"""आपको पूर्णांकों (integers) की एक सूची दी गई है।
आपको सबसे बड़ा अभाज्य (prime) मान ज्ञात करना है और उसके अंकों का योग लौटाना है।
उदाहरण:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] के लिए आउटपुट 10 होना चाहिए
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] के ... |
def skjkasdkd(lst):
"""ನಿಮಗೆ ಪೂರ್ಣಾಂಕಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡಲಾಗಿದೆ.
ನೀವು ಅತಿ ದೊಡ್ಡ ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಯನ್ನು (prime value) ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ಅದರ ಅಂಕಿಗಳ ಮೊತ್ತವನ್ನು ರಿಟರ್ನ್ ಮಾಡಬೇಕು.
ಉದಾಹರಣೆಗಳು:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ಗಾಗಿ ಔಟ್ಪುಟ್ 10 ಆಗಿರಬೇಕು
lst = [1,0,1,8,2,4597,2,1,3,4... |
def skjkasdkd(lst):
"""നിങ്ങൾക്ക് പൂർണ്ണസംഖ്യകളുടെ ഒരു ലിസ്റ്റ് നൽകിയിരിക്കുന്നു.
ഇതിലെ ഏറ്റവും വലിയ അഭാജ്യസംഖ്യ (prime value) കണ്ടെത്തുകയും അതിന്റെ അക്കങ്ങളുടെ തുക റിട്ടേൺ ചെയ്യുകയും വേണം.
ഉദാഹരണങ്ങൾ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ആണെങ്കിൽ ഔട്ട്പുട്ട് 10 ആയിരിക്കണം
l... |
def skjkasdkd(lst):
"""तुम्हाला पूर्णांकांची एक सूची दिली आहे.
तुम्हाला सर्वात मोठी मूळ संख्या शोधायची आहे आणि तिच्या अंकांची बेरीज परत करायची आहे.
उदाहरणे:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] साठी आउटपुट 10 असावे
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] साठी आउटपुट ... |
def skjkasdkd(lst):
"""तपाईंलाई पूर्णाङ्कहरूको एउटा सूची दिइएको छ।
तपाईंले सबैभन्दा ठूलो अभाज्य (prime) मान पत्ता लगाउनुपर्छ र त्यसका अङ्कहरूको योगफल फिर्ता गर्नुपर्छ।
उदाहरणहरू:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] को लागि आउटपुट 10 हुनुपर्छ
lst = [1,0,1,8,2,4597,2,1,3,40,1... |
def skjkasdkd(lst):
"""ଆପଣଙ୍କୁ ପୂର୍ଣ୍ଣସଂଖ୍ୟାଗୁଡ଼ିକର ଏକ list ଦିଆଯାଇଛି।
ଆପଣଙ୍କୁ ସର୍ବବୃହତ ମୌଳିକ ସଂଖ୍ୟା (prime value) ଖୋଜିବାକୁ ହେବ ଏବଂ ଏହାର ଅଙ୍କଗୁଡ଼ିକର ଯୋଗଫଳ ଫେରାଇବାକୁ ହେବ।
ଉଦାହରଣ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ପାଇଁ output 10 ହେବା ଉଚିତ
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1... |
def skjkasdkd(lst):
"""ਤੁਹਾਨੂੰ ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦਿੱਤੀ ਗਈ ਹੈ।
ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਵੱਡਾ ਅਭਾਜ (prime) ਮੁੱਲ ਲੱਭਣ ਅਤੇ ਇਸਦੇ ਅੰਕਾਂ ਦਾ ਜੋੜ ਵਾਪਸ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਉਦਾਹਰਨਾਂ:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] ਲਈ ਆਉਟਪੁੱਟ 10 ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1]... |
def skjkasdkd(lst):
"""भवते पूर्णाङ्कानाम् एका सूची दत्ता अस्ति।
भवता बृहत्तमम् अभाज्यमानं (prime value) अन्वेष्टव्यं तथा तस्य अङ्कानां योगः प्रत्यानेयः।
उदाहरणानि:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] कृते निर्गमः 10 भवेत्
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] कृत... |
def skjkasdkd(lst):
"""உங்களுக்கு முழு எண்களின் பட்டியல் ஒன்று கொடுக்கப்பட்டுள்ளது.
நீங்கள் மிகப்பெரிய பகா எண்ணைக் கண்டறிந்து, அதன் இலக்கங்களின் கூட்டுத்தொகையைத் திருப்பியளிக்க வேண்டும்.
எடுத்துக்காட்டுகள்:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] என்பதற்கு வெளியீடு 10 ஆக இருக்க வேண... |
def skjkasdkd(lst):
"""మీకు పూర్ణాంకాల జాబితా ఇవ్వబడింది.
మీరు అతిపెద్ద ప్రధాన సంఖ్యను కనుగొని, దాని అంకెల మొత్తాన్ని తిరిగి ఇవ్వాలి.
ఉదాహరణలు:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] కొరకు అవుట్పుట్ 10 కావాలి
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] కొరకు అవుట్పుట్ 25... |
def skjkasdkd(lst):
"""آپ کو انٹیجرز کی ایک لسٹ دی گئی ہے۔
آپ کو سب سے بڑی مفرد قدر (prime value) تلاش کرنی ہے اور اس کے ہندسوں کا مجموعہ واپس کرنا ہے۔
مثالیں:
lst = [0,3,2,1,3,5,7,4,5,5,5,2,181,32,4,32,3,2,32,324,4,3] کے لیے آؤٹ پٹ 10 ہونی چاہیے
lst = [1,0,1,8,2,4597,2,1,3,40,1,2,1,2,4,2,5,1] کے... |
HumanEval/95 |
def check_dict_case(dict):
"""
Given a dictionary, return True if all keys are strings in lower
case or all keys are strings in upper case, else return False.
The function should return False is the given dictionary is empty.
Examples:
check_dict_case({"a":"apple", "b":"banana"}) should return... | if len(dict.keys()) == 0:
return False
else:
state = "start"
for key in dict.keys():
if isinstance(key, str) == False:
state = "mixed"
break
if state == "start":
if key.isupper():
state = "upper"... | def check(candidate):
# Check some simple cases
assert candidate({"p":"pineapple", "b":"banana"}) == True, "First test error: " + str(candidate({"p":"pineapple", "b":"banana"}))
assert candidate({"p":"pineapple", "A":"banana", "B":"banana"}) == False, "Second test error: " + str(candidate({"p":"pineapple",... | check_dict_case |
def check_dict_case(dict):
"""
এটা dictionary প্ৰদান কৰা হ'লে, যদি সকলো key সৰুফলাৰ (lower case) string হয় অথবা সকলো key বৰফলাৰ (upper case) string হয়, তেন্তে True ঘূৰাই দিয়ক, অন্যথা False ঘূৰাই দিয়ক।
প্ৰদত্ত dictionary-খন খালী হ'লে ফাংচনটোৱে False ঘূৰাই দিব লাগে।
উদাহৰণ:
check_dict_case({"a":"appl... |
def check_dict_case(dict):
"""
একটি dictionary দেওয়া থাকলে, সব key যদি lower case-এর string হয়
অথবা সব key যদি upper case-এর string হয় তবে True রিটার্ন করুন, অন্যথায় False রিটার্ন করুন।
প্রদত্ত dictionary খালি হলে ফাংশনটির False রিটার্ন করা উচিত।
উদাহরণ:
check_dict_case({"a":"apple", "b":"bana... |
def check_dict_case(dict):
"""
એક dictionary આપેલ હોય, જો બધી keys lower case માં strings હોય અથવા બધી keys upper case માં strings હોય તો True પરત કરો, નહિતર False પરત કરો.
જો આપેલી dictionary ખાલી હોય તો function એ False પરત કરવું જોઈએ.
ઉદાહરણો:
check_dict_case({"a":"apple", "b":"banana"}) એ True ... |
def check_dict_case(dict):
"""
एक dictionary दिए जाने पर, यदि सभी keys lower case में strings हैं या सभी keys upper case में strings हैं, तो True लौटाएं, अन्यथा False लौटाएं।
यदि दी गई dictionary खाली है, तो फ़ंक्शन को False लौटाना चाहिए।
उदाहरण:
check_dict_case({"a":"apple", "b":"banana"}) को True... |
def check_dict_case(dict):
"""
ಒಂದು dictionary ಯನ್ನು ನೀಡಿದಾಗ, ಎಲ್ಲಾ keys ಗಳು lower case ನಲ್ಲಿರುವ string ಗಳಾಗಿದ್ದರೆ ಅಥವಾ ಎಲ್ಲಾ keys ಗಳು upper case ನಲ್ಲಿರುವ string ಗಳಾಗಿದ್ದರೆ True ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ, ಇಲ್ಲದಿದ್ದರೆ False ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ.
ನೀಡಲಾದ dictionary ಖಾಲಿಯಾಗಿದ್ದರೆ ಈ function False ಅನ್ನು ಹಿಂತಿರುಗಿಸಬೇಕು.
... |
def check_dict_case(dict):
"""
ഒരു dictionary നൽകിയാൽ, അതിലെ എല്ലാ key-കളും lower case-ലുള്ള string-കൾ ആണെങ്കിലോ അല്ലെങ്കിൽ എല്ലാ key-കളും upper case-ലുള്ള string-കൾ ആണെങ്കിലോ True നൽകുക, അല്ലാത്തപക്ഷം False നൽകുക.
നൽകിയിരിക്കുന്ന dictionary ശൂന്യമാണെങ്കിൽ ഫംഗ്ഷൻ False നൽകണം.
ഉദാഹരണങ്ങൾ:
check_dict... |
def check_dict_case(dict):
"""
दिलेली dictionary दिल्यास, जर सर्व keys या lower case मधील strings असतील किंवा
सर्व keys या upper case मधील strings असतील, तर True परत करा, अन्यथा False परत करा.
दिलेली dictionary रिकामी असल्यास function ने False परत केले पाहिजे.
उदाहरणे:
check_dict_case({"a":"app... |
def check_dict_case(dict):
"""
एउटा dictionary दिइएको अवस्थामा, यदि सबै key हरू lower case का string हरू हुन्
वा सबै key हरू upper case का string हरू हुन् भने True फर्काउनुहोस्, अन्यथा False फर्काउनुहोस्।
दिइएको dictionary खाली भएमा function ले False फर्काउनुपर्छ।
उदाहरणहरू:
check_dict_case({"a... |
def check_dict_case(dict):
"""
ଗୋଟିଏ dictionary ଦିଆଗଲେ, ଯଦି ସମସ୍ତ keys ଲୋୟରକେସ୍ (lower case) ଷ୍ଟ୍ରିଙ୍ଗ୍ ଅଥବା ସମସ୍ତ keys ଅପରକେସ୍ (upper case) ଷ୍ଟ୍ରିଙ୍ଗ୍ ହୋଇଥାନ୍ତି, ତେବେ True ଫେରାନ୍ତୁ, ନଚେତ୍ False ଫେରାନ୍ତୁ।
ଯଦି ଦିଆଯାଇଥିବା dictionary ଟି ଖାଲି ଥାଏ, ତେବେ ଫଙ୍କସନଟି False ଫେରାଇବା ଉଚିତ।
ଉଦାହରଣ:
check_dict_ca... |
def check_dict_case(dict):
"""
ਇੱਕ dictionary ਦਿੱਤੀ ਗਈ ਹੈ, ਜੇਕਰ ਸਾਰੀਆਂ keys lower case ਵਿੱਚ strings ਹਨ ਜਾਂ ਸਾਰੀਆਂ keys upper case ਵਿੱਚ strings ਹਨ ਤਾਂ True ਵਾਪਸ ਕਰੋ, ਨਹੀਂ ਤਾਂ False ਵਾਪਸ ਕਰੋ।
ਜੇਕਰ ਦਿੱਤੀ ਗਈ dictionary ਖਾਲੀ ਹੈ ਤਾਂ ਫੰਕਸ਼ਨ ਨੂੰ False ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਉਦਾਹਰਣਾਂ:
check_dict_case({"a":"ap... |
def check_dict_case(dict):
"""
दत्ते dictionary मध्ये, यदि सर्वाणि keys लघ्वक्षरेषु (lower case) strings सन्ति
अथवा सर्वाणि keys बृहदक्षरेषु (upper case) strings सन्ति, तदा True प्रत्यायच्छतु, अन्यथा False प्रत्यायच्छतु।
यदि दत्तं dictionary रिक्तम् अस्ति, तर्हि इदं function False प्रत्यायच्छेत्।
उ... |
def check_dict_case(dict):
"""
கொடுக்கப்பட்ட ஒரு அகராதியில், அனைத்து keys-களும் சிற்றெழுத்தில்
உள்ள strings ஆகவோ
அல்லது அனைத்து விசைகளும் பேரெழுத்தில் உள்ள சரங்கள்ஆகவோ இருந்தால் True எனத் திருப்பியளிக்கவும், இல்லையெனில் False எனத் திருப்பியளிக்கவும்.
கொடுக்கப்பட்ட அகராதி காலியாக இருந்தால் இந்தசெய... |
def check_dict_case(dict):
"""
ఒక dictionary ఇచ్చినప్పుడు, అన్ని keys లోవర్ కేస్ (lower case) స్ట్రింగ్లు అయినా లేదా అన్ని keys అప్పర్ కేస్ (upper case) స్ట్రింగ్లు అయినా True ని రిటర్న్ చేయండి, లేకపోతే False ని రిటర్న్ చేయండి.
ఇచ్చిన dictionary ఖాళీగా ఉంటే ఫంక్షన్ False ని రిటర్న్ చేయాలి.
ఉదాహరణలు:
... |
def check_dict_case(dict):
"""
ایک dictionary دی گئی ہو، تو True واپس کریں اگر تمام keys لوئر کیس (lower case) میں strings ہوں
یا تمام keys اپر کیس (upper case) میں strings ہوں، ورنہ False واپس کریں۔
اگر دی گئی dictionary خالی ہو تو فنکشن کو False واپس کرنا چاہیے۔
مثالیں:
check_dict_case({"a":... |
HumanEval/96 |
def count_up_to(n):
"""Implement a function that takes an non-negative integer and returns an array of the first n
integers that are prime numbers and less than n.
for example:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]... | primes = []
for i in range(2, n):
is_prime = True
for j in range(2, i):
if i % j == 0:
is_prime = False
break
if is_prime:
primes.append(i)
return primes
| def check(candidate):
assert candidate(5) == [2,3]
assert candidate(6) == [2,3,5]
assert candidate(7) == [2,3,5]
assert candidate(10) == [2,3,5,7]
assert candidate(0) == []
assert candidate(22) == [2,3,5,7,11,13,17,19]
assert candidate(1) == []
assert candidate(18) == [2,3,5,7,11,13,17]... | count_up_to |
def count_up_to(n):
"""এটা ফাংচন ৰূপায়ণ কৰক যিয়ে এটা অঋণাত্মক অখণ্ড সংখ্যা গ্ৰহণ কৰে আৰু n তকৈ সৰু আৰু মৌলিক সংখ্যা হোৱা প্ৰথম n টা অখণ্ড সংখ্যাৰ এটা এৰে ওভতাই দিয়ে।
উদাহৰণস্বৰূপে:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,... |
def count_up_to(n):
"""এমন একটি ফাংশন বাস্তবায়ন করুন যা একটি অ-ঋণাত্মক পূর্ণসংখ্যা গ্রহণ করে এবং মৌলিক সংখ্যা ও n-এর চেয়ে ছোট এমন প্রথম n-টি পূর্ণসংখ্যার একটি অ্যারে রিটার্ন করে।
উদাহরণস্বরূপ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,... |
def count_up_to(n):
"""એક એવું ફંક્શન ઇમ્પ્લીમેન્ટ કરો જે એક non-negative integer લે છે અને n કરતાં નાના હોય તેમજ
prime numbers હોય તેવા પ્રથમ n પૂર્ણાંકોનો array રિટર્ન કરે છે.
ઉદાહરણ તરીકે:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5... |
def count_up_to(n):
"""एक ऐसा फ़ंक्शन लागू करें जो एक गैर-ऋणात्मक पूर्णांक लेता है और उन पहले n
पूर्णांकों का एक ऐरे लौटाता है जो अभाज्य संख्याएं हैं और n से कम हैं।
उदाहरण के लिए:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17... |
def count_up_to(n):
"""ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕವನ್ನು ತೆಗೆದುಕೊಂಡು, ಅವಿಭಾಜ್ಯ ಸಂಖ್ಯೆಗಳಾಗಿರುವ ಮತ್ತು n ಗಿಂತ ಕಡಿಮೆಯಿರುವ ಮೊದಲ n
ಪೂರ್ಣಾಂಕಗಳ ಅರೇಯನ್ನು ಹಿಂದಿರುಗಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ಅನ್ನು ಇಂಪ್ಲಿಮೆಂಟ್ ಮಾಡಿ.
ಉದಾಹರಣೆಗೆ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) =>... |
def count_up_to(n):
"""നെഗറ്റീവ് അല്ലാത്ത ഒരു പൂർണ്ണസംഖ്യ സ്വീകരിക്കുകയും n-നേക്കാൾ ചെറുതും അഭാജ്യസംഖ്യകളുമായ ആദ്യ n
പൂർണ്ണസംഖ്യകളുടെ ഒരു അറേ തിരികെ നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ നടപ്പിലാക്കുക.
ഉദാഹരണത്തിന്:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_... |
def count_up_to(n):
"""एक ऋणेतर पूर्णांक घेणारे आणि n पेक्षा लहान व मूळ संख्या असलेल्या पहिल्या n
पूर्णांकांची ॲरे परत करणारे एक फंक्शन लागू करा.
उदाहरणार्थ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19]
count_up_to(1)... |
def count_up_to(n):
"""एउटा नन-नेगेटिभ पूर्णाङ्क लिने र n भन्दा साना तथा अभाज्य सङ्ख्याहरू रहेका पहिलो n वटा पूर्णाङ्कहरूको array फिर्ता गर्ने फलन कार्यान्वयन गर्नुहोस्।
उदाहरणका लागि:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17... |
def count_up_to(n):
"""ଗୋଟିଏ function ଇମ୍ପ୍ଲିମେଣ୍ଟ କରନ୍ତୁ ଯାହା ଏକ non-negative integer ନିଏ ଏବଂ n ରୁ କମ୍ ଥିବା ମୌଳିକ ସଂଖ୍ୟା (prime numbers) ହୋଇଥିବା ପ୍ରଥମ n ଟି ପୂର୍ଣ୍ଣସଂଖ୍ୟାର ଏକ array ଫେରସ୍ତ କରେ।
ଉଦାହରଣ ସ୍ୱରୂପ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(2... |
def count_up_to(n):
"""ਇੱਕ ਅਜਿਹਾ ਫੰਕਸ਼ਨ ਲਾਗੂ ਕਰੋ ਜੋ ਇੱਕ ਗੈਰ-ਰਿਣਾਤਮਕ ਪੂਰਨ ਅੰਕ ਲੈਂਦਾ ਹੈ ਅਤੇ ਪਹਿਲੇ n
ਪੂਰਨ ਅੰਕਾਂ ਦੀ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਅਭਾਜ ਸੰਖਿਆਵਾਂ ਹਨ ਅਤੇ n ਤੋਂ ਘੱਟ ਹਨ।
ਉਦਾਹਰਨ ਲਈ:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,1... |
def count_up_to(n):
"""तादृशस्य फलनस्य रचनां कुर्वन्तु यत् एकम् ऋणेतर-पूर्णाङ्कं गृह्णाति तथा च n इत्यस्मात् न्यूनाः याः अभाज्यसङ्ख्याः सन्ति, तेषां प्रथम-n-पूर्णाङ्कानाम् एकां पङ्क्तिं (array) प्रतिददाति।
यथा:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_t... |
def count_up_to(n):
"""எதிர்மறையற்ற முழு எண் ஒன்றை ஏற்றுக்கொண்டு, பகா எண்களாகவும் n-ஐ விடக் குறைவாகவும் உள்ள முதல் n
முழு எண்களின் ஓர் அணியைத் திருப்பியளிக்கும் ஒரு செயல்பாட்டைச் செயல்படுத்தவும்.
எடுத்துக்காட்டாக:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
cou... |
def count_up_to(n):
"""ఒక రుణేతర పూర్ణాంకాన్ని తీసుకుని, ప్రధాన సంఖ్యలై ఉండి మరియు n కంటే తక్కువగా ఉండే మొదటి n
పూర్ణాంకాల అర్రేను తిరిగి ఇచ్చే ఫంక్షన్ను అమలు చేయండి.
ఉదాహరణకు:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,3,5,7,11,13,17,19... |
def count_up_to(n):
"""ایک ایسا فنکشن نافذ کریں جو ایک غیر منفی صحیح عدد لیتا ہے اور ان پہلے n صحیح اعداد کا ایک array واپس کرتا ہے جو مفرد اعداد (prime numbers) ہوں اور n سے کم ہوں۔
مثال کے طور پر:
count_up_to(5) => [2,3]
count_up_to(11) => [2,3,5,7]
count_up_to(0) => []
count_up_to(20) => [2,... |
HumanEval/97 |
def multiply(a, b):
"""Complete the function that takes two integers and returns
the product of their unit digits.
Assume the input is always valid.
Examples:
multiply(148, 412) should return 16.
multiply(19, 28) should return 72.
multiply(2020, 1851) should return 0.
multiply(14,-15) ... | return abs(a % 10) * abs(b % 10)
| def check(candidate):
# Check some simple cases
assert candidate(148, 412) == 16, "First test error: " + str(candidate(148, 412))
assert candidate(19, 28) == 72, "Second test error: " + str(candidate(19, 28))
assert candidate(2020, 1851) == 0, "Third test error: " + str(c... | multiply |
def multiply(a, b):
"""দুটা অখণ্ড সংখ্যা গ্ৰহণ কৰা আৰু সিহঁতৰ এককৰ ঘৰৰ অংক দুটাৰ গুণফল
ঘূৰাই দিয়া ফলনটো সম্পূৰ্ণ কৰক।
ধৰি লওক ইনপুট সদায় বৈধ।
উদাহৰণ:
multiply(148, 412) এ 16 ঘূৰাই দিয়া উচিত।
multiply(19, 28) এ 72 ঘূৰাই দিয়া উচিত।
multiply(2020, 1851) এ 0 ঘূৰাই দিয়া উচিত।
multiply(... |
def multiply(a, b):
"""ফাংশনটি সম্পূর্ণ করুন যা দুটি পূর্ণসংখ্যা গ্রহণ করে এবং
তাদের একক স্থানীয় অঙ্কগুলির গুণফল রিটার্ন করে।
ধরে নিন ইনপুট সর্বদা বৈধ।
উদাহরণ:
multiply(148, 412) এর 16 রিটার্ন করা উচিত।
multiply(19, 28) এর 72 রিটার্ন করা উচিত।
multiply(2020, 1851) এর 0 রিটার্ন করা উচিত।
... |
def multiply(a, b):
"""બે પૂર્ણાંકો લેતા અને તેમના એકમના અંકોનો ગુણાકાર પરત કરતા
ફંક્શનને પૂર્ણ કરો.
ધારી લો કે ઇનપુટ હંમેશા માન્ય છે.
ઉદાહરણો:
multiply(148, 412) એ 16 પરત કરવું જોઈએ.
multiply(19, 28) એ 72 પરત કરવું જોઈએ.
multiply(2020, 1851) એ 0 પરત કરવું જોઈએ.
multiply(14,-15) એ 20 પર... |
def multiply(a, b):
"""उस फ़ंक्शन को पूरा करें जो दो पूर्णांक लेता है और
उनके इकाई अंकों का गुणनफल लौटाता है।
मान लें कि इनपुट हमेशा मान्य है।
उदाहरण:
multiply(148, 412) को 16 लौटाना चाहिए।
multiply(19, 28) को 72 लौटाना चाहिए।
multiply(2020, 1851) को 0 लौटाना चाहिए।
multiply(14,-15) को... |
def multiply(a, b):
"""ಎರಡು ಪೂರ್ಣಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ಅವುಗಳ ಬಿಡಿ ಸ್ಥಾನದ ಅಂಕಿಗಳ ಗುಣಲಬ್ಧವನ್ನು
ಹಿಂದಿರುಗಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸಿ.
ಇನ್ಪುಟ್ ಯಾವಾಗಲೂ ಮಾನ್ಯವಾಗಿರುತ್ತದೆ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ.
ಉದಾಹರಣೆಗಳು:
multiply(148, 412) ಯು 16 ಅನ್ನು ಹಿಂದಿರುಗಿಸಬೇಕು.
multiply(19, 28) ಯು 72 ಅನ್ನು ಹಿಂದಿರುಗಿಸಬೇಕು.
m... |
def multiply(a, b):
"""രണ്ട് പൂർണ്ണസംഖ്യകൾ സ്വീകരിച്ച്, അവയുടെ ഒറ്റയുടെ സ്ഥാനത്തെ അക്കങ്ങളുടെ
ഗുണനഫലം നൽകുന്ന ഫംഗ്ഷൻ പൂർത്തിയാക്കുക.
ഇൻപുട്ട് എല്ലായ്പ്പോഴും സാധുവാണെന്ന് കരുതുക.
ഉദാഹരണങ്ങൾ:
multiply(148, 412) എന്നത് 16 നൽകണം.
multiply(19, 28) എന്നത് 72 നൽകണം.
multiply(2020, 1851) എന്നത് 0 ... |
def multiply(a, b):
"""दोन पूर्णांक घेणारे आणि त्यांच्या एकक स्थानावरील अंकांचा
गुणाकार परत करणारे फंक्शन पूर्ण करा.
इनपुट नेहमी वैध आहे असे गृहीत धरा.
उदाहरणे:
multiply(148, 412) ने 16 परत केले पाहिजे.
multiply(19, 28) ने 72 परत केले पाहिजे.
multiply(2020, 1851) ने 0 परत केले पाहिजे.
... |
def multiply(a, b):
"""दुईवटा पूर्णाङ्कहरू लिने र तिनीहरूको इकाई अङ्कहरूको
गुणनफल फर्काउने प्रकार्य पूरा गर्नुहोस्।
इनपुट सधैं मान्य छ भनी मान्नुहोस्।
उदाहरणहरू:
multiply(148, 412) ले 16 फर्काउनुपर्छ।
multiply(19, 28) ले 72 फर्काउनुपर्छ।
multiply(2020, 1851) ले 0 फर्काउनुपर्छ।
multiply... |
def multiply(a, b):
"""ଦୁଇଟି integer ଗ୍ରହଣ କରୁଥିବା ଏବଂ ସେଗୁଡ଼ିକର unit digits ର ଗୁଣନଫଳ ଫେରାଉଥିବା
ଫଙ୍କସନଟିକୁ ସମ୍ପୂର୍ଣ୍ଣ କରନ୍ତୁ।
ମନେକରନ୍ତୁ input ସର୍ବଦା valid ଅଟେ।
ଉଦାହରଣ:
multiply(148, 412) 16 ଫେରାଇବା ଉଚିତ।
multiply(19, 28) 72 ଫେରାଇବା ଉଚିତ।
multiply(2020, 1851) 0 ଫେରାଇବା ଉଚିତ।
multiply(14... |
def multiply(a, b):
"""ਉਹ ਫੰਕਸ਼ਨ ਪੂਰਾ ਕਰੋ ਜੋ ਦੋ ਪੂਰਨ ਅੰਕ ਲੈਂਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਇਕਾਈ ਅੰਕਾਂ ਦਾ ਗੁਣਨਫਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਮੰਨ ਲਓ ਕਿ ਇਨਪੁਟ ਹਮੇਸ਼ਾ ਵੈਧ ਹੈ।
ਉਦਾਹਰਣਾਂ:
multiply(148, 412) ਨੂੰ 16 ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
multiply(19, 28) ਨੂੰ 72 ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
multiply(2020, 1851) ਨੂੰ 0 ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
... |
def multiply(a, b):
"""एतत् कार्यं पूरयन्तु यत् द्वौ पूर्णाङ्कौ स्वीकरोति तयोः
एककस्थानस्याङ्कयोः गुणनफलं च प्रतिददाति।
निवेशः सर्वदा मान्यः अस्ति इति मन्यताम्।
उदाहरणाणि:
multiply(148, 412) इत्यनेन 16 प्रतिदातव्यम्।
multiply(19, 28) इत्यनेन 72 प्रतिदातव्यम्।
multiply(2020, 1851) इत्यनेन 0... |
def multiply(a, b):
"""இரண்டு முழு எண்களைப் பெற்று அவற்றின் ஒன்றாம் இலக்கங்களின்
பெருக்கற்பலனைத் திருப்பியளிக்கும் வகையில் இந்த function-ஐ முழுமையாக்கவும்.
உள்ளீடு எப்போதும் செல்லுபடியானது என்று கருதிக்கொள்ளவும்.
எடுத்துக்காட்டுகள்:
multiply(148, 412) என்பது 16-ஐத் திருப்பியளிக்க வேண்டும்.
mul... |
def multiply(a, b):
"""రెండు పూర్ణాంకాలను తీసుకుని, వాటి ఒకట్ల స్థానంలోని అంకెల
లబ్ధాన్ని తిరిగి ఇచ్చే ఫంక్షన్ను పూర్తి చేయండి.
ఇన్పుట్ ఎల్లప్పుడూ సరైనదిగా ఉంటుందని భావించండి.
ఉదాహరణలు:
multiply(148, 412) 16 ను రిటర్న్ చేయాలి.
multiply(19, 28) 72 ను రిటర్న్ చేయాలి.
multiply(2020, 1851) 0 ... |
def multiply(a, b):
"""اس فنکشن کو مکمل کریں جو دو integers لیتا ہے اور
ان کے اکائی کے ہندسوں کا حاصل ضرب واپس کرتا ہے۔
فرض کریں کہ ان پٹ ہمیشہ درست ہے۔
مثالیں:
multiply(148, 412) کو 16 واپس کرنا چاہیے۔
multiply(19, 28) کو 72 واپس کرنا چاہیے۔
multiply(2020, 1851) کو 0 واپس کرنا چاہیے۔
... |
HumanEval/98 |
def count_upper(s):
"""
Given a string s, count the number of uppercase vowels in even indices.
For example:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
| count = 0
for i in range(0,len(s),2):
if s[i] in "AEIOU":
count += 1
return count
| def check(candidate):
# Check some simple cases
assert candidate('aBCdEf') == 1
assert candidate('abcdefg') == 0
assert candidate('dBBE') == 0
assert candidate('B') == 0
assert candidate('U') == 1
assert candidate('') == 0
assert candidate('EEEE') == 2
# Check some edge cases th... | count_upper |
def count_upper(s):
"""
এটা ষ্ট্ৰিং s দিয়া হৈছে, যুগ্ম সূচকাংকত (even indices) থকা ডাঙৰ ফলাৰ স্বৰবৰ্ণৰ (uppercase vowels) সংখ্যা গণনা কৰক।
উদাহৰণস্বৰূপে:
count_upper('aBCdEf')-এ 1 ঘূৰাই দিয়ে
count_upper('abcdefg')-এ 0 ঘূৰাই দিয়ে
count_upper('dBBE')-এ 0 ঘূৰাই দিয়ে
"""
|
def count_upper(s):
"""
একটি স্ট্রিং s দেওয়া থাকলে, জোড় ইন্ডেক্সে থাকা uppercase vowel-এর সংখ্যা গণনা করুন।
উদাহরণস্বরূপ:
count_upper('aBCdEf') রিটার্ন করে 1
count_upper('abcdefg') রিটার্ন করে 0
count_upper('dBBE') রিটার্ন করে 0
"""
|
def count_upper(s):
"""
આપેલી સ્ટ્રિંગ s માં, બેકી ઇન્ડેક્સ (even indices) પર રહેલા uppercase vowels ની સંખ્યા ગણો.
ઉદાહરણ તરીકે:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
|
def count_upper(s):
"""
एक स्ट्रिंग s दिए जाने पर, सम इंडेक्स (even indices) पर uppercase vowels की संख्या की गणना करें।
उदाहरण के लिए:
count_upper('aBCdEf') 1 लौटाता है
count_upper('abcdefg') 0 लौटाता है
count_upper('dBBE') 0 लौटाता है
"""
|
def count_upper(s):
"""
ಒಂದು ಸ್ಟ್ರಿಂಗ್ s ಅನ್ನು ನೀಡಿದಾಗ, ಸಮ ಸೂಚ್ಯಂಕಗಳಲ್ಲಿ (even indices) ಇರುವ uppercase ಸ್ವರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಎಣಿಸಿ.
ಉದಾಹರಣೆಗೆ:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
|
def count_upper(s):
"""
ഒരു സ്ട്രിംഗ് s നൽകിയാൽ, ഇരട്ട ഇൻഡക്സുകളിലുള്ള (even indices) വലിയ അക്ഷരങ്ങളായ സ്വരാക്ഷരങ്ങളുടെ (uppercase vowels) എണ്ണം കണ്ടെത്തുക.
ഉദാഹരണത്തിന്:
count_upper('aBCdEf') 1 നൽകുന്നു
count_upper('abcdefg') 0 നൽകുന്നു
count_upper('dBBE') 0 നൽകുന്നു
"""
|
def count_upper(s):
"""
दिलेल्या स्ट्रिंग s मध्ये, सम निर्देशांकांवर (even indices) असलेल्या अप्परकेस स्वरांची (uppercase vowels) संख्या मोजा.
उदाहरणार्थ:
count_upper('aBCdEf') 1 रिटर्न करते
count_upper('abcdefg') 0 रिटर्न करते
count_upper('dBBE') 0 रिटर्न करते
"""
|
def count_upper(s):
"""
दिइएको string s मा, जोर indices (even indices) मा रहेका uppercase vowel हरूको सङ्ख्या गणना गर्नुहोस्।
उदाहरणका लागि:
count_upper('aBCdEf') ले 1 फिर्ता गर्छ
count_upper('abcdefg') ले 0 फिर्ता गर्छ
count_upper('dBBE') ले 0 फिर्ता गर्छ
"""
|
def count_upper(s):
"""
ଗୋଟିଏ string s ଦିଆଯାଇଛି, ଯୁଗ୍ମ indices ରେ ଥିବା uppercase vowels ଗୁଡ଼ିକର ସଂଖ୍ୟା ଗଣନା କରନ୍ତୁ।
ଉଦାହରଣ ସ୍ୱରୂପ:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
|
def count_upper(s):
"""
ਇੱਕ ਸਟ੍ਰਿੰਗ s ਦਿੱਤੀ ਗਈ ਹੋਣ 'ਤੇ, even indices 'ਤੇ uppercase vowels ਦੀ ਗਿਣਤੀ ਕਰੋ।
ਉਦਾਹਰਨ ਲਈ:
count_upper('aBCdEf') 1 ਵਾਪਸ ਕਰਦਾ ਹੈ
count_upper('abcdefg') 0 ਵਾਪਸ ਕਰਦਾ ਹੈ
count_upper('dBBE') 0 ਵਾਪਸ ਕਰਦਾ ਹੈ
"""
|
def count_upper(s):
"""
दत्ते string s मध्ये, सम-सूचकाङ्केषु (even indices) स्थितानां बृहदक्षर-स्वराणां (uppercase vowels) संख्यां गणयतु।
उदाहरणार्थम्:
count_upper('aBCdEf') 1 प्रतिददाति
count_upper('abcdefg') 0 प्रतिददाति
count_upper('dBBE') 0 प्रतिददाति
"""
|
def count_upper(s):
"""
ஒரு ஸ்ட்ரிங் s கொடுக்கப்பட்டால், இரட்டைப்படை குறியீடுகளில் (even indices) உள்ள uppercase உயிரெழுத்துக்களின் (uppercase vowels) எண்ணிக்கையைக் கணக்கிடவும்.
எடுத்துக்காட்டாக:
count_upper('aBCdEf') 1-ஐத் தருகிறது
count_upper('abcdefg') 0-ஐத் தருகிறது
count_upper('dBBE')... |
def count_upper(s):
"""
ఒక స్ట్రింగ్ s ఇవ్వబడినప్పుడు, సరి సూచికలలో (even indices) ఉన్న uppercase vowels సంఖ్యను లెక్కించండి.
ఉదాహరణకు:
count_upper('aBCdEf') returns 1
count_upper('abcdefg') returns 0
count_upper('dBBE') returns 0
"""
|
def count_upper(s):
"""
ایک اسٹرنگ s دی گئی ہے، جفت انڈیکسز (even indices) پر موجود بڑے حروف والے مصوتوں (uppercase vowels) کی تعداد شمار کریں۔
مثال کے طور پر:
count_upper('aBCdEf') 1 واپس کرتا ہے
count_upper('abcdefg') 0 واپس کرتا ہے
count_upper('dBBE') 0 واپس کرتا ہے
"""
|
HumanEval/99 |
def closest_integer(value):
'''
Create a function that takes a value (string) representing a number
and returns the closest integer to it. If the number is equidistant
from two integers, round it away from zero.
Examples
>>> closest_integer("10")
10
>>> closest_integer("15.3")
15
... | from math import floor, ceil
if value.count('.') == 1:
# remove trailing zeros
while (value[-1] == '0'):
value = value[:-1]
num = float(value)
if value[-2:] == '.5':
if num > 0:
res = ceil(num)
else:
res = floor(num)
elif len(valu... | def check(candidate):
# Check some simple cases
assert candidate("10") == 10, "Test 1"
assert candidate("14.5") == 15, "Test 2"
assert candidate("-15.5") == -16, "Test 3"
assert candidate("15.3") == 15, "Test 3"
# Check some edge cases that are easy to work out by hand.
assert candidate("0... | closest_integer |
def closest_integer(value):
'''
এটা সংখ্যাক প্ৰতিনিধিত্ব কৰা এটা value (string) গ্ৰহণ কৰা আৰু ইয়াৰ আটাইতকৈ
ওচৰৰ integer টো ঘূৰাই পঠোৱা এটা ফলন সৃষ্টি কৰক। যদি সংখ্যাটো দুটা integer-ৰ
পৰা সমদূৰত্বত থাকে, তেন্তে ইয়াক শূন্যৰ পৰা দূৰলৈ round কৰক।
Examples
>>> closest_integer("10")
10
>>> c... |
def closest_integer(value):
'''
একটি ফাংশন তৈরি করুন যা একটি সংখ্যাকে উপস্থাপনকারী একটি মান (string) গ্রহণ করে
এবং এর নিকটতম integer রিটার্ন করে। যদি সংখ্যাটি দুটি integer থেকে সমদূরবর্তী
হয়, তবে এটিকে শূন্য থেকে দূরে (away from zero) রাউন্ড করুন।
উদাহরণ
>>> closest_integer("10")
10
>... |
def closest_integer(value):
'''
એક ફંક્શન બનાવો જે સંખ્યા રજૂ કરતું મૂલ્ય (string) લે છે
અને તેની સૌથી નજીકનો integer પરત કરે છે. જો સંખ્યા બે integers થી
સમાન અંતરે હોય, તો તેને શૂન્યથી દૂર (away from zero) રાઉન્ડ કરો.
ઉદાહરણો
>>> closest_integer("10")
10
>>> closest_integer("15.3")
... |
def closest_integer(value):
'''
एक ऐसा फ़ंक्शन बनाएं जो किसी संख्या को दर्शाने वाला एक मान (string) लेता है
और उसके सबसे निकटतम पूर्णांक (integer) को लौटाता है। यदि संख्या दो पूर्णांकों
से समान दूरी पर है, तो इसे शून्य से दूर राउंड (round away from zero) करें।
Examples
>>> closest_integer("10"... |
def closest_integer(value):
'''
ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ value (string) ಅನ್ನು ಸ್ವೀಕರಿಸಿ,
ಅದಕ್ಕೆ ಅತ್ಯಂತ ಸಮೀಪವಿರುವ ಪೂರ್ಣಾಂಕವನ್ನು (integer) ಹಿಂದಿರುಗಿಸುವ ಒಂದು ಫಂಕ್ಷನ್ ರಚಿಸಿ. ಒಂದು ವೇಳೆ ಆ ಸಂಖ್ಯೆಯು
ಎರಡು ಪೂರ್ಣಾಂಕಗಳಿಂದ ಸಮಾನ ದೂರದಲ್ಲಿದ್ದರೆ, ಅದನ್ನು ಶೂನ್ಯದಿಂದ ದೂರಕ್ಕೆ ರೌಂಡ್ ಮಾಡಿ.
ಉದಾಹರಣೆಗಳು
>>> closest_inte... |
def closest_integer(value):
'''
ഒരു സംഖ്യയെ പ്രതിനിധീകരിക്കുന്ന ഒരു value (string) സ്വീകരിക്കുകയും
അതിനോട് ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യ (integer) നൽകുകയും ചെയ്യുന്ന ഒരു ഫംഗ്ഷൻ ഉണ്ടാക്കുക. സംഖ്യ രണ്ട്
പൂർണ്ണസംഖ്യകളിൽ നിന്നും തുല്യ അകലത്തിലാണെങ്കിൽ, അതിനെ പൂജ്യത്തിൽ നിന്നും അകലേക്ക് റൗണ്ട് ചെയ്യുക.
... |
def closest_integer(value):
'''
एका संख्येचे प्रतिनिधित्व करणारे value (string) घेणारे आणि त्या संख्येच्या सर्वात जवळचा integer
परत करणारे एक फंक्शन तयार करा. जर ती संख्या दोन integers पासून समान अंतरावर
असेल, तर तिला शून्यापासून दूर (round away from zero) राउंड करा.
उदाहरणे
>>> closest_intege... |
def closest_integer(value):
'''
एउटा संख्यालाई प्रतिनिधित्व गर्ने मान (string) लिने र त्यसको
सबैभन्दा नजिकको integer फर्काउने एउटा प्रकार्य बनाउनुहोस्। यदि संख्या
दुईवटा integer बाट समान दूरीमा छ भने, त्यसलाई शून्यबाट टाढा राउन्ड गर्नुहोस्।
Examples
>>> closest_integer("10")
10
>>> clo... |
def closest_integer(value):
'''
ଗୋଟିଏ function ପ୍ରସ୍ତୁତ କରନ୍ତୁ ଯାହା ଏକ ସଂଖ୍ୟାକୁ ପ୍ରତିନିଧିତ୍ୱ କରୁଥିବା ଏକ value (string) ଗ୍ରହଣ କରେ
ଏବଂ ଏହାର ନିକଟତମ integer ଫେରସ୍ତ କରେ। ଯଦି ସଂଖ୍ୟାଟି ଦୁଇଟି integer ଠାରୁ
ସମାନ ଦୂରତାରେ ଥାଏ, ତେବେ ଏହାକୁ ଶୂନ ଠାରୁ ଦୂରକୁ round କରନ୍ତୁ।
ଉଦାହରଣ
>>> closest_integer("10")
10... |
def closest_integer(value):
'''
ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਓ ਜੋ ਇੱਕ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਮੁੱਲ (string) ਲੈਂਦਾ ਹੈ
ਅਤੇ ਇਸਦੇ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਪੂਰਨ ਅੰਕ (integer) ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਸੰਖਿਆ ਦੋ ਪੂਰਨ ਅੰਕਾਂ ਤੋਂ
ਬਰਾਬਰ ਦੂਰੀ 'ਤੇ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਜ਼ੀਰੋ ਤੋਂ ਦੂਰ ਰਾਊਂਡ (round away from zero) ਕਰੋ।
ਉਦਾਹਰਨਾਂ
>>> closest_integer("... |
def closest_integer(value):
'''
एकं फलनं रचयतु यत् सङ्ख्यां निरूपयन्तं मानम् (string) स्वीकरोति
तथा च तस्य निकटतमं पूर्णाङ्कं प्रत्याददाति। यदि सा सङ्ख्या द्वाभ्यां
पूर्णाङ्काभ्यां समदूरे वर्तते, तर्हि तां शून्यात् दूरं वर्तुलयतु (round away from zero)।
उदाहरणानि
>>> closest_integer("10")
... |
def closest_integer(value):
'''
ஒரு எண்ணைக் குறிக்கும் value (string)-ஐப் பெற்று,
அதற்கு மிக அருகிலுள்ள முழு எண்ணை (integer) திருப்பியளிக்கும் ஒரு செயல்பாட்டை உருவாக்கவும். கொடுக்கப்பட்ட எண் இரண்டு முழு எண்களிலிருந்தும்
சம தூரத்தில் இருந்தால், அதை பூஜ்ஜியத்திலிருந்து தூரமாக முழுமையாக்கவும் (round away ... |
def closest_integer(value):
'''
ఒక సంఖ్యను సూచించే value (string) ను తీసుకుని, దానికి అత్యంత సమీపంలో ఉండే
పూర్ణాంకాన్ని (integer) రిటర్న్ చేసే ఫంక్షన్ను రూపొందించండి. ఒకవేళ ఆ సంఖ్య రెండు పూర్ణాంకాల నుండి
సమాన దూరంలో ఉంటే, దానిని సున్నా నుండి దూరంగా (round away from zero) రౌండ్ చేయండి.
ఉదాహరణలు
... |
def closest_integer(value):
'''
ایک ایسا فنکشن بنائیں جو کسی عدد کی نمائندگی کرنے والی value (string) لے
اور اس کے قریب ترین integer واپس کرے۔ اگر وہ عدد دو integers سے
برابر فاصلے پر ہو، تو اسے صفر سے دور (away from zero) راؤنڈ کریں۔
Examples
>>> closest_integer("10")
10
>>> closest_i... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.