25

मैं रेडिट पर एक विचित्र धागे से गुजर रहा था, और इस पर आया:

(͡ ° (͜ʖ ° ͜ʖ) (͜ʖ ° ͡ ʖ °) ͡) °) ͡ °)

यह उन लोगों के एक समूह का प्रतिनिधित्व कर रहा है जो कुछ संदिग्ध रूप से मुस्कुरा रहे हैं।

(हालांकि नीचे की चुनौती में, दाईं आंख के बाईं ओर रिक्त स्थान किसी तरह गिरा दिया गया था, जबकि मैं चुनौती लिख रहा था। युक्ति पर ध्यान दें)।

आपका लक्ष्य nनिम्नलिखित नियमों के साथ गहरी मुस्कुराती हुई चेहरों का एक समूह बनाना है:

गहराई पर, एक पूर्ण चेहरा ( ( ͡° ͜ʖ ͡°)) दिखाया गया है।
गहराई पर दो, आधे चेहरे दिखाए गए हैं। बाईं ओर, आधे से अधिक चेहरे ( ( ͡° ͜ʖ) का प्रतिनिधित्व किया जाता है। दाईं ओर, दाईं ओर दिखाया गया है, और मुंह छोड़ा हुआ है ( ʖ ͡°))
कोई भी गहरा, और केवल सिर और आंखों के किनारों को दिखाया गया है ( ( ͡°और ͡°)। सिर के आंख और बाईं ओर के बीच एक जगह है, लेकिन वहाँ, उपस्थिति के बावजूद, दाईं ओर कोई स्थान नहीं है। रिक्ति ͡वर्ण के कारण है। चीजों के साथ गड़बड़।

इनपुट:

n, यह दिखाने के लिए कि चेहरों की कितनी परतें गहरी हैं।
nहमेशा सीमा में रहेगा 0 <= n <= 500। आपको इस सीमा के बाहर कुछ भी संभालने की आवश्यकता नहीं है।
n1 से ऑफसेट किया जा सकता है ताकि 0 का मतलब है कि कोई चेहरा न हो। हालांकि आपको -1 को संभालना होगा।

आउटपुट:

एक स्ट्रिंग, या चरित्र सरणी, या कुछ भी दूर से तुलनीय (जैसे पायथन / जावास्क्रिप्ट में एकल-वर्ण स्ट्रिंग्स की सूची)। इसे सीधे भी छापा जा सकता है। सफ़ेद-स्थान को पीछे छोड़ना ठीक है।

आप एक पूरा कार्यक्रम, या एक कार्य प्रस्तुत कर सकते हैं।

चूंकि यह देखना मुश्किल है कि कौन से पात्र शामिल हैं, यहाँ इसे पायथन में रखा गया है:

>> [ord(c) for c in '( ͡° ͜ʖ ͡°)']
[40, 32, 865, 176, 32, 860, 662, 32, 865, 176, 41]

>> [ord(c) for c in '( ͡°( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)͡°)͡°)']
[40, 32, 865, 176, 40, 32, 865, 176, 40, 32, 865, 176, 32, 860, 662, 40, 32, 865, 176, 32, 860, 662, 32, 865, 176, 41, 662, 32, 865, 176, 41, 865, 176, 41, 865, 176, 41]

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

face_crowd(0)
''

face_crowd(1)
'( ͡° ͜ʖ ͡°)'

face_crowd(2)
'( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)'

face_crowd(5)
'( ͡°( ͡°( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)͡°)͡°)͡°)'

face_crowd(10)
'( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)'

face_crowd(500)
'( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)'

यहां एक असाधारण रूप से भोली पुनरावर्ती संदर्भ कार्यान्वयन (मेरे गीथूब पर पोस्ट किया गया) है। मैंने इसे स्पष्टता के लिए जितना संभव हो उतना सरल रखने की कोशिश की; लेकिन बहुत दोहराव है

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

यह कोड-गोल्फ है, इसलिए प्रत्येक भाषा में कम से कम बाइट्स जीतता है।

code-golf string ascii-art

— Carcigenicate
स्रोत

11

TIO पर प्रस्तुत किए जाने पर यह और भी संदेहास्पद लगता है। : पी

— अर्नुलड

युक्ति और परीक्षण के मामले असंगत प्रतीत होते हैं; कल्पना में बाद की गहराई के दाहिने हिस्से की शुरुआत में एक जगह है, जबकि परीक्षण के मामले नहीं हैं।

— tjjfvi

@ अरनुलद ओह वाह। हां, हर जगह यह थोड़ा अलग तरीके से दिखाई देता है।

— कर्क राशि

3

हास्केल , 89 87 80 बाइट्स

7 बाइट्स एक्सनोर के लिए धन्यवाद

(!!)$"":x:iterate(4#8)(7#6$x)
x="( ͡° ͜ʖ ͡°)"
(a#b)y=take a x++y++drop b x

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

शुरू करने के लिए हम xसुविधा के लिए एक स्ट्रिंग के लिए (to ° ͡ to °) प्रदान करते हैं ।

x="( ͡° ͜ʖ ͡°)"

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

(!!)$"":x:iterate(4#8)(7#6$x)

हमारे पास एक विशेष कार्य है (#)जो एक स्ट्रिंग के आगे और पीछे एक निर्दिष्ट राशि (͜ʖ ° ͡ the °) जोड़ता है:

(a#b)y=take a x++y++drop b x

— गेहूं का जादूगर
स्रोत

8

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

f=n=>n?"( ͡°"+(--n>1?f(n):" ͜ʖ"+(n?f(n)+"ʖ ":" "))+"͡°)":""

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

या एक बेहतर प्रतिपादन के लिए निम्नलिखित स्निपेट के साथ प्रयास करें।

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

f=n=>n?"( ͡°"+(--n>1?f(n):" ͜ʖ"+(n?f(n)+"ʖ ":" "))+"͡°)":""

for(n = 0; n <= 10; n++) {
  o.innerHTML += '"' + f(n) + '"\n';
}

pre { font-family:Arial }

<pre id="o"></pre>

Expand snippet

टिप्पणी की गई

निम्नलिखित कोड में, हम "eEMN"स्वरूपण को संरक्षित करने के लिए वर्ण सेट (भौं, आंख, मुंह और नाक क्रमशः) का उपयोग करते हैं।

f = n =>           // f is a recursive function taking the number n of remaining
                   // faces to draw
  n ?              // if n is greater than 0:
    "( eE" + (     //   append the left cheek + a space + the left eye
      --n > 1 ?    //   decrement n; if it's still greater than 1:
        f(n)       //     append the result of a recursive call
      :            //   else (n = 0 or 1):
        "MN" + (   //     append the mouth and the nose
          n ?      //     if n = 1:
            f(n)   //       append the result of a recursive call
            + "N " //       followed by the nose + a space
          :        //     else (n = 0):
            " "    //       append a space and stop recursion
        )          //
    )              //
    + "eE)"        //   append the right eye + the right cheek
  :                // else:
                   //   the special case n = 0 is reached only if the original
    ""             //   input is 0; just return an empty string

— Arnauld
स्रोत

6

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

f=lambda i:L[:7+~2%~i]+f(i-1)+L[6+2%i:]if i>1else L*i
L='( ͡° ͜ʖ ͡°)'

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

-6 बाइट्स एक्सनोर के लिए धन्यवाद

— Jitse
स्रोत

6

मैंने कुछ ब्रूट-फोर्स खोज की और पाया कि यह 4+3*(i<3)हो सकता है 7+~2%~iऔर 8-2*(i<3)हो सकता है 6+2%i।

— xnor

@ एक्सन ब्रिलियंट, धन्यवाद!

— १६:०५ पर Jitse

6

एक्सेल, 85 बाइट्स

=IF(A1>1,REPT("( ͡°",A1-1)&" ʖ( ͡° ͜ʖ ͡°)ʖ "&REPT("͡°)",A1-1),REPT("( ͡° ͜ʖ ͡°)",A1))

के लिए अनुभवहीन समाधान n>1। 0टेस्टकेस को संभालने के लिए आवश्यक दूसरा दोहराव ।

— Wernisch
स्रोत

क्या आपको आखिरी जरूरत है REPT?

— नील

मामले REPTको संभालने के लिए अंतिम आवश्यक है 0।

— वेर्निस्क

5

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

.+
$*< $&$*>
 >>
 >ʖ >
<(?=<? )
< ͜ʖ
<
( ͡°
>
͡°)

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
$*< $&$*>

गाल उत्पन्न करें, लेकिन <एस और >एस का उपयोग करें क्योंकि (एस और )एस को उद्धृत करने की आवश्यकता होगी। बीच का एक स्थान मध्यम आदमी की नाक और बाईं आंख के बीच में समाप्त होता है।

 >>
 >ʖ >

अगर बीच के आदमी के बाईं तरफ एक आदमी है, तो उस आदमी को एक नाक और उसके बीच और उसकी बाईं आंख के बीच का स्थान दें।

<(?=<? )
< ͜ʖ

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

<
( ͡°

दाएं गालों को ठीक करें और दाईं आंखें जोड़ें।

>
͡°)

बाएं गाल को ठीक करें और बाईं आंखें जोड़ें।

— नील
स्रोत

1

@ अर्नुलड पे, मुझे कुछ समय लगा, लेकिन मुझे लगता है कि मैं इसे केवल एक अतिरिक्त बाइट के लिए ठीक करने में कामयाब रहा!

— नील

4

पर्ल 5 `-p` , 96 बाइट्स

$\='( ͡° ͜ʖ ͡°)'if$_--;$\="( ͡° ͜ʖ$\ʖ ͡°)"if$_-->0;$\="( ͡°$\ ͡°)"while$_-->0}{

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

— Xcali
स्रोत

81 बाइट्स

— नहुएल फौलीउल

4

सूचित 7 , 262 बाइट्स

To say x:say "[Unicode 865][Unicode 176]".
To say y:say Unicode 860.
To say z:say Unicode 662.
To say p (N - number):say "( [x][p N minus 1][x])".
To say p (N - 2):say "( [x] [y][z][p 1][z][x])".
To say p (N - 1):say "( [x] [y][z] [x])".
To say p (N - 0):say "".

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

पाठ के कुछ दोहराए गए बिट्स होते हैं, जैसे "([x]", जो संभवतः अपने स्वयं के कार्यों के रूप में सारगर्भित हो सकते हैं - लेकिन I7 बहुत क्रियात्मक है, एक नए फ़ंक्शन को परिभाषित करने से अधिक बाइट्स बचेंगे! यह एकमात्र स्थान को परिभाषित करता है! नया कार्य बाइट को बचाने के लिए लगता है कि गैर-एएससीआईआई पात्रों के लिए है, क्योंकि उन्हें प्रिंट करने के लिए सिंटैक्स और भी अधिक है लिए सिंटैक्स फ़ंक्शन परिभाषाओं के लिए सिंटैक्स की तुलना में कहीं क्रिया है।

इसे चलाने के लिए बॉयलरप्लेट:

Foo is a room. When play begins: say p 7.

अपनी पसंद के गैर-नकारात्मक पूर्णांक के साथ 7 बदलें।

— Draconis
स्रोत

एक सूचित उत्तर देखकर अच्छा लगा!

— फ्लुडरर

3

स्टैक्स , 42 बाइट्स

ü/┐▐Φd¬•U►^τ∩█┴êZ3↔uº'µ3ó(▀◄Ü▒iÇÆ'[∞_¥▄>A√

इसे चलाएं और डीबग करें

मुझे लगता है कि यह विंडोज में फ़ायरफ़ॉक्स में काम नहीं करता है। लेकिन ऐसा सिर्फ इसलिए है क्योंकि मोनोस्पेस के लिए एफएफ डिफ़ॉल्ट फ़ॉन्ट कूरियर है, जो इन फैंसी यूनिकोड संशोधक या जो कुछ भी समर्थन नहीं करता है। मुझे लगता है।

— पुनरावर्ती
स्रोत

3

C ++ (gcc) , 102 बाइट्स

#include <string>
std::string f(int n){return n?"( ͡°"+(--n>1?f(n):" ͜ʖ"+(n?f(n)+"ʖ ":" "))+"͡°)":"";}

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

अर्नुलद के जावास्क्रिप्ट समाधान का बेशर्म बंदरगाह।

— जी। स्लीपेन
स्रोत

1

शायद आपको #include <string> # 103

— AZTECCO

दरअसल, मुझे याद दिलाने के लिए धन्यवाद :)

— जी स्लीपेन

2

जूलिया 1.0 , 85 बाइट्स

f(n,s="( ͡° ͜ʖ ͡°)")=n<3 ? ["",s,s[1:10]s*s[10:17]][n+1] : s[1:5]f(n-1)s[12:17]

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

— user3263164
स्रोत

2

जाप , 47 बाइट्स (UTF-8)

?"( ͡°{´U>1?ß:" ͜ʖ"+(U?'ʖiß:S} ͡°)":P

झबरा के लिए धन्यवाद एक बाइट बचाया

कोशिश करो

— अज्ञान का अवतार
स्रोत

47 बाइट्स ?

— झबरा

इसके लिए अपेक्षित आउटपुट U=0एक खाली स्ट्रिंग है, ताकि आप इसके बजाय किसी स्थान को आउटपुट करने की पुष्टि करना चाहें।

— झबरा

2

जावा 7, 133 90 89 बाइट्स

String f(int n){return--n<0?"":"( ͡°"+(n>1?f(n):" ͜ʖ"+(n>0?f(n)+"ʖ ":" "))+"͡°)";}

पोर्ट ऑफ @ अर्नाउल्ड का पुनरावर्ती जावास्क्रिप्ट उत्तर , क्योंकि यह जावा 8+ लैम्ब्डा के उपयोग से मेरे शुरुआती पहले प्रयास से कम है।

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

स्पष्टीकरण:

String f(int n){               // Recursive method with integer parameter & String return-type
  return--n                    //  Decrease the input by 1 first
           <0?                 //  And if the input is now -1:
              ""               //   Return an empty string
             :                 //  Else:
             "( ͡°"             //   Return the left part of Lenny's face
             +(n>1?            //   And if the modified input is larger than 1:
                   f(n)        //    Append a recursive call with this now decreased input
                  :            //   Else (the input is here either 0 or 1):
                   " ͜ʖ"        //    Append Lenny's nose
                   +(n>0?      //    And if the input is larger than 0 (thus 1):
                         f(n)  //     Append a recursive call
                         +"ʖ " //     As well as the right part of its nose
                        :      //    Else (thus 0):
                         " "   //     Append a space instead
            ))+"͡°)";}          //   And also append the right part of Lenny's

— केविन क्रूज़सेन
स्रोत

2

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

f=lambda i:i*'x'and"( ͡° ͜ʖ"[:7+~2%~i]+f(i-1)+"ʖ ͡°)"[2%i:]

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

सूचकांक गणना का विचार @ जित्से के समाधान में @xnor से लिया गया है ।

— जोएल
स्रोत

1

कैनवस , 46 बाइट्स

b＊5USy{↖ｑYｑ⇵≡„a¹„┬Ｈｃ＋
⁷ｍ；⁷±ｍ±└＋＋
Ｈ？３４⁸］］⁷］５７⁸｝

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

— dzaima
स्रोत

1

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

ＮθＰ⭆θ✂ʖ ͡°)⊗‹¹ι←⭆θ✂ʖ͜ °͡ (∧‹¹ι³

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

Ｎθ

चेहरों की संख्या इनपुट करें।

Ｐ⭆θ✂ʖ ͡°)⊗‹¹ι

चेहरों के बाईं ओर प्रिंट करें (हमारे दाईं ओर जैसा कि हम उन्हें देखते हैं)। इन स्ट्रिंग में ʖ ͡°)दो बार दोहराया जाता है, और फिर पहले दो वर्णों के बिना उस स्ट्रिंग को शेष संख्या को दोहराया जाता है।

←⭆θ✂ʖ͜ °͡ (∧‹¹ι³

चेहरों के दाईं ओर प्रिंट करें (हमारे बाईं ओर जैसा कि हम उन्हें देखते हैं)। ये (उलट) स्ट्रिंग से मिलकर बनता हैʖ͜ °͡ ( दो बार दोहराया गया , और फिर पहले दो वर्णों के बिना उस स्ट्रिंग ने शेष संख्या को दोहराया।

आप में से अधिक पर्यवेक्षक ने देखा होगा कि मध्य चेहरे की अपनी नाक दो बार उत्पन्न होती है यही कारण है कि मैं इस तरह से प्रिंट कर रहा हूं कि वे ओवरलैप करते हैं।

— नील
स्रोत

1

पायथन 3 , 80 चार्ट, 86 बाइट्स

x='( ͡° ͜ʖ ͡°)'
n=3-1
print(x[:4]*(n-1)+x[:7]*(n!=0)+x+x[6:]*(n!=0)+x[8:]*(n-1))

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

इनपुट डालने के लिए, आप जो भी इनपुट चाहते हैं, उसे 3 में बदलें, -1 को छोड़कर।

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

यहाँ कुछ भी नहीं चल रहा है, बस स्ट्रिंग स्लाइसिंग और बूलियन्स का दुरुपयोग

— Tryer
स्रोत

संदिग्ध रूप से खुश लेनिन चेहरों की भीड़ बनाएँ (͜ʖ ° ͡) °)

हास्केल , 89 87 80 बाइट्स

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

टिप्पणी की गई

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

एक्सेल, 85 बाइट्स

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

पर्ल 5 -p , 96 बाइट्स

सूचित 7 , 262 बाइट्स

स्टैक्स , 42 बाइट्स

C ++ (gcc) , 102 बाइट्स

जूलिया 1.0 , 85 बाइट्स

जाप , 47 बाइट्स (UTF-8)

जावा 7, 133 90 89 बाइट्स

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

कैनवस , 46 बाइट्स

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

पायथन 3 , 80 चार्ट, 86 बाइट्स

पर्ल 5 `-p` , 96 बाइट्स