हाल ही में, मैंने एक टाइपो बनाया और मैंने यूनिकोड के बजाय यूनिकॉर्न लिखा , मैंने वही किया जो कोई भी सामान्य व्यक्ति करेगा और मैंने इससे एक एसोलंग बनाया । इस चुनौती में आप एक यूनिकॉर्न दुभाषिया लिख रहे होंगे।

क्योंकि यूनिकॉर्न कार्यक्रम भयानक लंबे होते हैं, इसलिए आपको इसकी भरपाई के लिए एक छोटा दुभाषिया लिखना होगा।

उदाहरण

ये ट्रांसप्लड परिणाम हैं, न कि वास्तविक व्याख्या किए गए परिणाम जो आपके प्रोग्राम को आउटपुट करना चाहिए

🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄
1

🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄
alert([x=(p=prompt())/2+Math.sqrt(p*p/4-prompt()),p-x])

🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄 🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐🐐
"Hello, World!"

विशिष्टता

यूनिकॉर्न को "वर्गों" में विभाजित किया गया है जो अंतरिक्ष-पृथक हैं
प्रत्येक अनुभाग एक चरित्र का प्रतिनिधित्व करता है
🦄प्रत्येक खंड में यूनिकॉर्न ( ) की संख्या इसे संबंधित वर्ण (यानी 32 यूनिकॉर्न -> chr(32)-> ) से परिवर्तित किया गया है ।
यदि अनुभाग में बकरियां हैं ( 🐐), तो बकरियों की मात्रा की लंबाई दोगुनी होनी चाहिए , फिर संबंधित चरित्र में बदल दी जाएगी
यदि अनुभाग में कोई अन्य वर्ण हैं, तो प्रोग्राम को वर्ण को अनदेखा करना चाहिए।
प्रत्येक अनुभाग (चरित्र) को एक कार्यक्रम बनाने के लिए जोड़ा जाना चाहिए
इस परिणामी कार्यक्रम का मूल्यांकन उस भाषा में किया जाना चाहिए जिसे आपने प्रोग्राम में लिखा है। (जैसे जावास्क्रिप्ट eval, पायथन के exec)
यूनिकॉर्न यूनिकोड हैं U+1F984; बकरियां यूनिकोड हैं U+1F410।
यदि आप संकलित भाषा चुनते हैं, तो आप संकलित, संकलित इकसिंगा कोड को आउटपुट / सहेज सकते हैं

🦄(इकसिंगों) और 🐐(बकरियों) सभी को इस चुनौती के लिए एक बाइट के रूप में गिना जाता है।

यदि आपकी भाषा इमोजीस का समर्थन नहीं करती है, तो आप यूनिकॉर्न को ( u) और बकरियों को ( g) के रूप में पहचान सकते हैं । आप इमोजीस का समर्थन नहीं कर सकते हैं और u ,g

यदि आप वास्तव में ~~यूनिकोड को~~ यूनिकॉर्न देखना चाहते हैं , तो यहां इस पोस्ट की एक तस्वीर है

+50 इनाम: 6500 चार्ट के तहत होने के दौरान (मूल) यूनिकॉर्न के सबसे छोटे कार्यक्रम के लिए । आपको इस संस्करण का उपयोग करना चाहिए , यह फ़ायरफ़ॉक्स, क्रोम या सफारी पर चलना चाहिए।

code-golf interpreter

— Downgoat
स्रोत

17

मुझे नहीं पता था कि इकसिंगे उस आकार के थे ।

— दरवाज़े

5

@Doorknob ob यह आयताकार गेंडा का युग है!

— तनमठ

4

उन लोगों के लिए जो इस पृष्ठ पर गेंडा और बकरी नहीं देख सकते हैं, गेंडा और बकरी ।

— एल'एंडिया स्ट्रोमैन

16

मैं बकरियां देख सकता हूं, लेकिन गेंडा नहीं। क्या वे छिप रहे हैं, या बकरियां मुझे इकसिंगों को देखने नहीं दे रही हैं?

— R

14

मेरे कंप्यूटर पर, इस भाषा को "मजेदार यूनिकोड बॉक्स" कहा जाना चाहिए।

— बिल्ली

9

पायथ - 23 17 बाइट्स

.vsmC+/d\🦄y/d\🐐cz

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

यह रिक्त स्थान द्वारा इनपुट को विभाजित करके काम करता है, फिर प्रत्येक अनुभाग के लिए इकसिंगों की संख्या और बकरियों की संख्या * 2 तब उन्हें जोड़ना, फिर कोड बिंदु पर चार ले जाना। यह सार सरणी और पाइथ-इवलिंग के योग से समाप्त हुआ।

— Maltysen
स्रोत

21

यूनिकॉर्न (ईएस 6), 5934 5278 बाइट्स

कस्टम एन्कोडिंग के तहत, यह 5278 बाइट्स (1 बाइट प्रति चार) है; लेकिन UTF-8 के साथ, यह 4 बाइट्स प्रति चार्ट (हालांकि एक स्थान के लिए केवल 1), या 20869 कुल होगा।

(too many Unicorns and Goats to reasonably display here)

इसके बजाय, यहां एक पास्टबिन है। यह यूनिकॉर्न कोड इस जेएस स्निपेट को प्रेषित करता है:

s=>eval(s.replace(/\S+ ?/g,c=>String.fromCharCode(c.length>>1<<c.charCodeAt()%2)))

अब, यह सबसे कम संभव संस्करण नहीं है; यह छोटा है:

s=>eval(s.replace(/\S+ ?/g,c=>String.fromCharCode(c.length>>1<<("🦄">c))))

हालांकि, वहां मौजूद एक गेंडा 56034 बकरियों को स्थानांतरित कर देगा, इस प्रकार यह स्कोर लगभग 11 हो जाएगा।

यहाँ वह कार्य है जो मैं यूनिकॉर्न को प्रेषित करता था:

कोड स्निपेट दिखाएं

function g(s){return s.replace(/./g,function(c){i=c.charCodeAt();return(i%2?"🦄".repeat(i):"🐐".repeat(i/2))+" "}).slice(0,-1)}

<textarea id=O cols=100></textarea><button id=P onclick="Q.value=g(O.value);R.innerHTML=(Q.value.length+Q.value.split(' ').length-1)/2">Run</button><br><textarea id=Q rows=10 cols=100>Output appears here.</textarea><br><p>Length: <span id=R>0</span><br></p>

स्निपेट का विस्तार करें

नोट: मैंने वास्तव में कार्यक्रम का परीक्षण नहीं किया है, क्योंकि एक ऑनलाइन दुभाषिया नहीं है जो मुझे मिल सकता है (हालांकि मुझे लगता है कि मैं .js फ़ाइल को HTML में हुक कर सकता हूं ...?)

— ETHproductions
स्रोत

यह कैसे होता है कि 5KB से अधिक वाले इस उत्तर को 17 बाइट्स वाले उत्तर की तुलना में अधिक वोट दिया जाता है।

— OldBunny2800

1

@ OldBunny2800 क्योंकि गेंडा।

— ETHproductions

4

पायथन 179 176 बाइट्स

संपादित करें : मैंने अभी s.split ('') = s.split () सीखा है

यहाँ दूसरी "वास्तविक" प्रोग्रामिंग भाषा यूनिकॉर्न दुभाषिया है। मैं यूनिकॉर्न के "UnicornPy" संस्करण को "गेंडा पाई" कहता हूं। मैं इसे बहुत अधिक आधिकारिक बना रहा हूं!

s=raw_input()
s=s.replace('🐐','🦄🦄')
s=s.replace('🦄','u')
for i in s:
    if i not in "ug ":
        s=s.replace(i,'')
s=s.split()
for i in s:
    s[s.index(i)]=chr(len(i))
exec(''.join(s))

किसी कारण से, मुझे यूनिक और बकरी इमोजी को यू और जी में बदलना होगा। मुझे नहीं पता क्यों।

यहाँ यह कोशिश करो!

— TanMath
स्रोत

1

डेनिस की वेबसाइट को "ऑनलाइन प्रयास करें!" कहा जाता है। और वाक्यांश को कॉपीराइट नहीं किया गया ...

— एलेक्स ए।

6

@AlexA। यह एक मजाक था!

— तनमठ

जावास्क्रिप्ट UTF-16 (मुझे लगता है) का उपयोग करता है, इसलिए गेंडा और बकरी वास्तव में प्रत्येक में 2 वर्ण हैं।

— 12Me21

1

@ 12M2121 PPCG के इतिहास में किसी ने भी जावास्क्रिप्ट को UTF-16 के रूप में नहीं गिना है।

— पावेल

मेरा मतलब था कि JS में स्ट्रिंग्स को UTF-16

— 12Me21

3

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

eval ARGV[0].gsub(/[^ug ]/,'').split.map{|b|(b.size*(b[0]=='u'?1:2)).chr}.join

यह मूल रूप से पहली कमांड लाइन तर्क को पढ़ता है, इसे प्रत्येक अंतरिक्ष चरित्र पर विभाजित करता है, ब्लॉक के आकार को उपयुक्त चरित्र में मैप करता है और सभी को एक साथ जोड़ता है।

संपादित करें: इस आवश्यकता को भूल गए कि अन्य सभी पात्रों को अनदेखा किया जाना चाहिए

— बीडीए
स्रोत

अब यह करता है ... उल्लेख करने के लिए धन्यवाद!

— बीडीए

3

गेंडा ES6 (अमान्य), 3379 बाइट्स

यह अमान्य है क्योंकि यह यूनिकॉर्न के नवीनतम संस्करण का उपयोग इंद्रधनुष, बादलों के साथ सूरज, और चमक के साथ करता है। जेसी कोड के लिए @ETHproductions के लिए धन्यवाद गेंडा व्याख्या करने के लिए।

code is in the paste bin below

पास्टबिन: http://pastebin.com/raw/Q9Kd4ixA
यह केवल 3379 बाइट्स है अगर स्पार्कल्स, सूरज / बादल, और इंद्रधनुष भी 1 बाइट हैं।

— ev3commander
स्रोत

1

गणितज्ञ, ११hem बाइट्स

a=StringCount;ToExpression@FromCharacterCode[If[#~StringTake~1=="u",#~a~"u",2IntegerLength[#~a~"g"]]&/@StringSplit@#]&

विनिर्देशन में बताए अनुसार कार्य करता है। मैं इंटरप्रेटर विस्फोट के बिना गणितज्ञ स्ट्रिंग शाब्दिकों में इमोजी का उपयोग नहीं कर सकता था, इसलिए मैंने उपयोग किया uऔर g।

— LegionMammal978
स्रोत

1

जंग, 426 बाइट्स

use std::io::Write;macro_rules!c{($n:expr,$a:expr)=>(println!("{}",std::str::from_utf8(&std::process::Command::new($n).arg($a).output().unwrap().stdout).unwrap());)}fn main(){let d:String=std::env::args().skip(1).next().unwrap().split(' ').map(|s|s.chars().fold(0u8,|a,c|a+match c as char{'🦄'=>1,'🐐'=>2,_=>0}) as char).collect();std::fs::File::create("o").unwrap().write_all(d.as_bytes()).unwrap();c!("rustc","o");c!("o","");}

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

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

Ungolfed:

use std::io::Write;

macro_rules! command {
    ($name:expr,$argument:expr) => (println!("{}", std::str::from_utf8(
        std::process::Command::new($name)
                              .arg($argument)
                              .output()
                              .unwrap()
    ));)
}

fn main() {
    let decoded: String = std::env::args()
        .skip(1) //ignore program name
        .next().unwrap().split(' ') //get first arg split on spaces
        //transform every section in a char
        .map(|section| section.chars()
            .fold(0u8, |accumulator, chr| accumulator + match chr as char {
            '🦄' => 1,
            '🐐' => 2,
            _ => 0
        }) as char)
        //convert iterator to string
        .collect();

    std::fs::File::create("o").unwrap()
        .write_all(decoded.as_bytes()).unwrap();
    command!("rustc", "o");
    command!("o", "");
}

— Kroltan
स्रोत

दरअसल, UTF-8 में इमोजी प्रत्येक 4 बाइट्स हैं।

— लीजियनममाल 978

@ LegionMammal978 मैंने गलती से चार-गिनती के बजाय बाइट काउंट का इस्तेमाल किया: P

— Kroltan

पूरा कार्यक्रम 394 बाइट्स का है।

— लीजियनममाल 978

1

मैं का उपयोग इस ।

— लीजियनममाल 978

1

दरअसल, इस चुनौती के लिए इमोजी की गिनती एक बाइट के रूप में होती है, इसलिए चार की गिनती के समान ही चार गिनती होती है।

— तनमठ

1

PHP, 83 80 86 87 बाइट्स

अब यूनिकॉर्न-रेडी

3 बाइट्स की लागत के लिए मैंने यह गेंडा तैयार किया:

$a=mb_substr_count;foreach(explode(" ",$argv[1])as$b)echo chr($a($b,🦄)+2*$a($b,🐐));

कमांड लाइन से एक इनपुट लेता है, जैसे:

$ unciorns.php "🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🐐 🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄🦄"

यह आउटपुट करेगा 32।

डेमो

खरीदने से पहले कोशिश करें

दुर्भाग्य से OS X 10.10.5 ~~समर्थन नहीं करता~~ है जो यूनिकॉर्न को छिपा रहा है। यहाँ वैकल्पिक ug-approach ( 80 बाइट्स ) है:

$s=substr_count;foreach(explode(' ',$argv[1])as$c)echo chr($s($c,u)+2*$s($c,g));

कमांड लाइन से एक तर्क लेता है, जैसे:

$ php unicorns.php "uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuug uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu"

प्रयास करें स्नातकीय -संस्करण

संपादित करता

सहेजा गया 1 बाइट बड़े पैमाने पर पुनर्रचना की वजह से। यह संस्करण पहले ही फिर से खारिज कर दिया गया है, क्योंकि मैं मूल को और भी आगे ले जाने में कामयाब रहा:

डेमो छोड़ दिया संस्करण ( 86 बाइट्स )

for($_=$argv[1].' ';$c=$_[$i++];)$t+=u==$c?1:(g==$c?2:(' '==$c?-$t+!print chr($t):0));

के साथ बदलकर 6 बाइट्स बचाएforforeach
जोड़ा 3 बाइट्स बना यूनिकॉर्न के लिए तैयार ।

— insertusernamehere
स्रोत

1

रूबी, 75 अक्षर

एक गंधा गहरे लाल रंग का दुभाषिया है कि सभी की जगह 🦄के साथ ' '(एक अंतरिक्ष) और सभी 🐐के साथ' ' (दो रिक्त स्थान), और प्रत्येक खंड की लंबाई हो जाता है।

मैं यूनिकॉर्न ~~रूबाइकॉर्न~~ रुबिकॉर्न का यह संस्करण ~~कहता~~ हूं ।

->s{eval s.split(a=' ').map{|r|r.gsub('🦄',a).gsub('🐐',a*2).size.chr}.join}

— MegaTom
स्रोत

माणिक्य , संभवतः?

— क्रॉल्टन

@Kroltan जो एक कूलर का नाम है।

— मेगाटॉम

1

पायथन 3, 94 86 बाइट्स

यह एक साधारण पार्सर है जो मिश्रण uऔर gएक सेक्शन में काम करता है ।

s=input().split();exec(''.join(chr(sum([[0,2][j<"u"],1][j>"g"]for j in i))for i in s))

एक उदाहरण के रूप (का उपयोग करते हुए uऔर gअलग वर्गों में):

gggggggggggggggggggggggggggggggggggggggggggggggggggggggg ggggggggggggggggggggggggggggggggggggggggggggggggggggggggg uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu ggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggggggggggggggggggggggggggggggggggggggggg gggggggggggggggggggg uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

को पार्स करना चाहिए

print(1)

— Sherlock9
स्रोत

1

रैकेट , 200 बाइट्स

(define(f s)(eval(read(open-input-string(list->string(map integer->char(map(λ(x)(foldl(λ(y a)(case y[(#\u)(add1 a)][(#\g)(+ a 2)]))0 x))(map string->list(string-split s)))))))(make-base-namespace)))

Ungolfed:

(define(f s)
  (eval(read(open-input-string
             (list->string ;;back to string
              (map integer->char ;;back to char
                   (map(λ(x)
                         (foldl(λ(y a)
                                 (case y
                                   [(#\u)(add1 a)]
                                   [(#\g)(+ a 2)]))
                               0 x))
                       (map string->list (string-split s))))))) ;;splitting by space, converting to list of chars
       (make-base-namespace)))

यह स्ट्रिंग को रिक्त स्थान द्वारा स्ट्रिंग की सूची में विभाजित करके शुरू होता है, फिर प्रति स्प्लिट स्ट्रिंग की सूची बनाता है। फिर चार्ट की प्रत्येक सूची को एक संख्या में घटाकर 1 जोड़ा जाता है यदि इकसिंगा, 2 यदि बकरी। अंत में, प्रत्येक सूची में सम्‍मिलित राशि को वर्णों की सूची बना दिया जाता है, फिर एक स्ट्रिंग जो निष्कासित करने के लिए पारित की जाती है।

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

— रोड्रिगो रुइज़ मुर्गुआ
स्रोत

साइट पर आपका स्वागत है! साइट पर मॉड में से एक ने ऑनलाइन कार्यक्रम चलाने के लिए एक वेबसाइट बनाई है (रैकेट पेज: tio.run/nexus/racket )। आप अपने कोड को वहां पेस्ट कर सकते हैं (हो सकता है कि हेडर या फूटर में जोड़कर अगर रैकेट को एक फ़ंक्शन से बाहर पूरा कार्यक्रम बनाने के लिए कुछ अतिरिक्त चाहिए) और फिर एक लिंक प्राप्त करें जिसे आप इस उत्तर में जोड़ सकते हैं। यह आवश्यक नहीं है लेकिन यह उन लोगों के लिए अच्छा है जो आपके कोड का परीक्षण करना चाहते हैं।

— 0 '

@ 1000000000 मैंने इसे जोड़ा है, टिप के लिए धन्यवाद!

— रोड्रिगो रुइज मुर्गुआ

1

जावास्क्रिप्ट, 140 154 141 बाइट्स

var s='';i.split(" ").forEach((e)=>{s+=String.fromCharCode((e.split("🦄").length-1)+2*(e.split("🐐").length-1));});console.log(eval(s));

यह एक सुई के रूप में अंतरिक्ष का उपयोग करते हुए, स्ट्रिंग की एक सरणी में इनपुट स्ट्रिंग को विभाजित करता है। यह तब इकसिंगों और बकरियों * 2 की मात्रा को गिनने के लिए आगे बढ़ता है और जो परिणाम होगा उसका मूल्यांकन किया जाएगा।

अधिक पठनीय:

var s = '';
i.split(" ").forEach((e) => {
    s+=String.fromCharCode((e.split("🦄").length-1)+2*(e.split("🐐").length-1));
});
console.log(eval(s));

संपादित करें:

सीएलआई से एक तर्क को स्वीकार करने के लिए अद्यतन कोड, उपयोग करें: node unicorn.js "🐐🦄 🦄🦄"

var s='';process.argv[2].split(' ').forEach((e)=>{s+=String.fromCharCode((e.split('🦄').length-1)+2*(e.split('🐐').length-1));});console.log(eval(s));

Ungolfed:

var s = '';
process.argv[2].split(' ').forEach((e) => {
    s+=String.fromCharCode((e.split('🦄').length-1)+2*(e.split('🐐').length-1));
});
console.log(eval(s));

2 संपादित करें:

फ़ंक्शन पैरामीटर के रूप में इनपुट को स्वीकार करने के लिए संपादित, उपयोग node unicorn.js

i=>{var s='';i.split(' ').forEach((e)=>{s+=String.fromCharCode((e.split('🦄').length-1)+2*(e.split('🐐').length-1));});return eval(s);};

Ungolfed:

i =>{
    var s = '';
    i.split(' ').forEach((e) => {
        s+=String.fromCharCode((e.split('🦄').length-1)+2*(e.split('🐐').length-1));
    });
    return eval(s);
};

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

— अल्वारो अर्रेगुई
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! हमें सभी उत्तरों की आवश्यकता होती है या तो पूर्ण कार्यक्रम (जैसे इनपुट के माध्यम से prompt()) या फ़ंक्शन (फ़ंक्शन पैरामीटर के माध्यम से इनपुट लेना i=>{var s='';...}):।

— ईथप्रोडक्शन

इनपुट को एक तर्क के रूप में स्वीकार करने के लिए मेरे जवाब को संपादित किया

— अल्वारो अर्रेगुई

1

RProgN , 25 बाइट्स

~`🐐'🦄🦄'R'(🦄+)%s*'{Lc}R do

व्याख्या की

~                             # Zero Space Segment
 `🐐                         # The String literal "🐐"
   '🦄🦄'                   # The String literal "🦄🦄"
       R                     # Replace, turning all goats into twonicorns
        '(🦄+)%s*'          # The pattern string "(🦄+)%s*", which is "A fewnicorns, then as much whitespace as possible, or none.
                 {Lc}R      # Replace with the result of the function, which converts the captured subgroup to it's Length, then to a char.
                       do   # Straight up do it.

एक बार फिर, RProgN लगातार ठीक होने के जाल में पड़ जाता है।

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

— Ataco
स्रोत

0

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

{use MONKEY-SEE-NO-EVAL;EVAL [~] .words».&{chr m:g/\🦄/+2*m:g/\🐐/}}

— SMLS
स्रोत

0

स्माइलबासिक, 125 बाइट्स

INPUT S$WHILE LEN(S$)R=ASC(POP(S$))IF R-32THEN C=C+!(R-117)+2*!(R-103)ELSE O$=CHR$(C)+O$C=0
WEND
SAVE"TXT:@",CHR$(C)+O$EXEC"@

बचत के बिना कोड को निष्पादित करने के लिए PRGEDIT का उपयोग करना बहुत अच्छा है, लेकिन यह भी बहुत लंबा है।

कोड:

INPUT CODE$ 'making the user type 1000s of characters just so I could save 2 or 3
WHILE LEN(CODE$)
 CHAR$=POP(CODE$) 'I convert the code backwards, since POP( is shorter than SHIFT(
 IF CHAR$==" " THEN
  UNSHIFT OUT$,CHR$(CHAR)
  CHAR=0
 ELSE
  INC CHAR,(CHAR$=="u")+(CHAR$=="g")*2
 ELSE
WEND
SAVE "TXT:@",CHR$(CHAR)+OUT$
EXEC "TXT:@"

— 12Me21
स्रोत

एक गेंडा दुभाषिया बनाओ

उदाहरण

विशिष्टता

पायथ - 23 17 बाइट्स

यूनिकॉर्न (ईएस 6), 5934 5278 बाइट्स

पायथन 179 176 बाइट्स

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

गेंडा ES6 (अमान्य), 3379 बाइट्स

गणितज्ञ, ११hem बाइट्स

जंग, 426 बाइट्स

PHP, 83 80 86 87 बाइट्स

अब यूनिकॉर्न-रेडी

रूबी, 75 अक्षर

पायथन 3, 94 86 बाइट्स

रैकेट , 200 बाइट्स

जावास्क्रिप्ट, 140 154 141 बाइट्स

RProgN , 25 बाइट्स

व्याख्या की

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

स्माइलबासिक, 125 बाइट्स