Indic-LLM-Eval-Suite
Collection
An open, community-driven evolving collection of benchmarks for comprehensive and reliable evaluation of LLMs across Indian Languages • 23 items • Updated
Datasets:
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) تک جاری رہتا ہے۔
لیجنڈ... |
End of preview. Expand in Data Studio
indic-humaneval
HumanEval, from OpenAI, is 164 hand-written Python programming problems, each a function signature and docstring with unit tests. It measures the functional correctness of code a model writes from the docstring (pass@k).
indic-humaneval is HumanEval translated into 14 Indian languages by an LLM translation pipeline with automatic quality checks, with a portion of the translations reviewed and corrected by human annotators. It is part of the Indic-LLM-Eval-Suite.
Upstream source: openai/openai_humaneval
Languages
Assamese (as), Bengali (bn), Gujarati (gu), Hindi (hi), Kannada (kn), Malayalam (ml), Marathi (mr), Nepali (ne), Odia (or), Punjabi (pa), Sanskrit (sa), Tamil (ta), Telugu (te), Urdu (ur)
Layout
One row per original benchmark item, with every language on that same row. The original columns are carried through unchanged; each translated field gains one column per language:
prompt -> prompt_Hindi_translation, prompt_Bengali_translation, ...
| rows | 164 |
| languages | 14 |
| translated fields | prompt |
| columns | 19 |
More details
For how the translations were made and verified, and for model results on the suite, see the report and the blog:
- Report: coming soon
- Blog: Introducing Indic-LLM-Eval-Suite
Citation
If you use this dataset, please cite:
@misc{indicllmevalsuite2026blog,
title = {Introducing Indic-LLM-Eval-Suite: Better Indic Models Need Better Benchmarks},
author = {Kunchukuttan, Anoop and Kamath, Anusha and Khapra, Mitesh M. and
Khan, Mohammed Safi Ur Rahman and Agarwal, Niket and Thethy, Rajpreet and
Akkati, Ramani and Joshi, Raviraj and Murthy, Rudra and
Jayakumar, Thanmay and Vaidya, Utkarsh},
year = {2026},
month = oct,
howpublished = {\url{https://ai4bharat.github.io/indic-llm-eval-suite-blog/}},
note = {AI4Bharat, IIT Madras and NVIDIA}
}
- Downloads last month
- 19