ฉันกำลังผ่านเกลียวที่แปลกประหลาดบน Reddit และเจอสิ่งนี้:

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

มันเป็นตัวแทนของกลุ่มคนที่ยิ้มค่อนข้างมีพิรุธ

(ในการท้าทายด้านล่างช่องว่างทางด้านซ้ายของดวงตาขวาถูกทิ้งไว้อย่างใดในขณะที่ฉันกำลังเขียนความท้าทายหมายเหตุ spec)

เป้าหมายของคุณคือการสร้างกลุ่มของรอยยิ้มบนใบหน้าที่ลุ่มnลึกด้วยกฎต่อไปนี้:

1. ที่ระดับความลึกหนึ่งหน้าเต็ม ( ( ͡° ͜ʖ ͡°)) จะปรากฏขึ้น
2. ที่ระดับความลึกสองจะแสดงใบหน้าครึ่งหน้า ทางด้านซ้ายจะมีเพียงครึ่งหนึ่งของใบหน้า ( ( ͡° ͜ʖ) อย่างไรก็ตามทางด้านขวาจะแสดงทางด้านขวาและไม่ใส่ปาก ( ʖ ͡°))
3. ลึก ๆ และมีเพียงด้านข้างของหัวและตาจะแสดงอยู่ ( ( ͡°และ͡°). มีช่องว่างระหว่างตาและด้านซ้ายของหัว แต่มีแม้จะมีการปรากฏตัวไม่มีช่องว่างด้านขวา. ระยะห่างเป็นเนื่องจาก͡ตัวอักษรที่ ยุ่งกับสิ่งเล็กน้อย

การป้อนข้อมูล:

• nแสดงจำนวนชั้นของใบหน้าที่จะแสดง
• nจะอยู่ในช่วง0 <= n <= 500เสมอ คุณไม่จำเป็นต้องจัดการอะไรนอกช่วงนี้
• nอาจถูกชดเชยด้วย 1 เพื่อให้ 0 หมายถึงหนึ่งหน้าแทนที่จะไม่มีใบหน้า คุณจะต้องจัดการ -1 ก่อน

เอาท์พุท:

• สตริงหรืออาร์เรย์อักขระหรือสิ่งอื่นใดที่สามารถเปรียบเทียบกันได้จากระยะไกล (เช่นรายการของสตริงอักขระเดี่ยวใน Python / Javascript) นอกจากนี้ยังสามารถพิมพ์ได้โดยตรง พื้นที่สีขาวต่อท้ายเป็นเรื่องปกติ

คุณสามารถส่งโปรแกรมที่สมบูรณ์หรือฟังก์ชั่น

เนื่องจากเป็นการยากที่จะดูว่าตัวละครมีส่วนเกี่ยวข้องอะไรนี่เป็นเค้าโครงใน Python:

>> [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)
'( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)͡°)'

นี่คือการใช้การอ้างอิงแบบเรียกซ้ำแบบไร้สาระ (โพสต์บน Github ของฉัน) ฉันพยายามทำให้มันชัดที่สุดเท่าที่จะเป็นไปได้เพื่อความชัดเจน แต่มีการทำซ้ำจำนวนมาก

ฉันโพสต์มันจากภายนอกเพราะฉันต้องการห่อไว้ในสปอยเลอร์ในกรณีที่คนไม่ต้องการดูข้อมูลอ้างอิง แต่มันซับซ้อนกว่าการคัดลอกรหัส ฉันคิดว่ามันไม่สำคัญต่อความท้าทายจริง ๆ ดังนั้นมันจึงไม่ใช่เรื่องใหญ่หากมันลงไปฉันสามารถวางมันไว้ที่นี่หากมันสำคัญ

นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์น้อยที่สุดในแต่ละภาษาจะชนะ

Haskell , 89 87 80 ไบต์

7 ไบต์ปิดขอบคุณ xnor

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

ลองออนไลน์!

ในการเริ่มต้นเรากำหนด (͡°͜ʖ͡°) ให้กับสตริงxเพื่อความสะดวก

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

จากนั้นเราจะสร้างรายการคำตอบและจัดทำดัชนีเพื่อค้นหาคำตอบ สิ่งนี้ทำได้โดยการเข้ารหัสสองคำตอบแรกเป็นสององค์ประกอบแรกของรายการแล้ววนซ้ำฟังก์ชันที่เพิ่มอักขระ 4 ตัวแรกและอักขระ 4 ตัวสุดท้ายที่ด้านหน้าและด้านหลังของสตริงข้ามคำตอบที่สาม

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

นอกจากนี้เรายังมีฟังก์ชั่นพิเศษ(#)ซึ่งจะเพิ่มจำนวน (of °͜ʖ͡°) ที่ระบุไว้ที่ด้านหน้าและด้านหลังของสตริง:

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

JavaScript (ES6), 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>

แสดงความคิดเห็น

ในรหัสต่อไปนี้เราใช้ชุดอักขระ"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

Python 3 , 75 ไบต์

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

ลองออนไลน์!

-6 ไบต์ขอบคุณ xnor

Excel, 85 ไบต์

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

n>1วิธีการแก้ปัญหาไร้เดียงสาสำหรับ ต้องทำซ้ำครั้งที่สองเพื่อจัดการกับ0testcase

เรติน่า 0.8.2 , 56 ไบต์

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

ลองออนไลน์! คำอธิบาย:

.+
$*< $&$*>

สร้างแก้ม แต่ใช้<s และ>s เพราะ(s และ)s จะต้องมีการยกมา ช่องว่างตรงกลางจะอยู่ระหว่างจมูกของชายกลางกับตาซ้าย

 >>
 >ʖ >

หากชายตรงกลางมีชายคนหนึ่งอยู่ทางซ้ายให้จมูกคนนั้นกับช่องว่างระหว่างมันกับตาซ้ายของเขา

<(?=<? )
< ͜ʖ

เพิ่มปากและจมูกให้กับชายตรงกลางและชายข้างขวาถ้ามี เราไม่เห็นตาซ้ายของชายคนนี้ทางด้านขวาของเขาดังนั้นเขาจึงไม่ต้องการพื้นที่และเราให้พื้นที่ตรงกลางในระยะแรก

<
( ͡°

แก้ไขแก้มขวาและเพิ่มตาขวา

>
͡°)

แก้ไขแก้มซ้ายและเพิ่มตาซ้าย

Perl 5 -p , 96 ไบต์

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

ลองออนไลน์!

แจ้ง 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 "".

สิ่งนี้ใช้ประโยชน์จากการโอเวอร์โหลดของฟังก์ชัน Inform 7: โอเวอร์โหลดที่เฉพาะเจาะจงมากที่สุดจะถูกเรียกใช้และฟังก์ชันที่ใช้ตัวเลข (จำนวนเต็มใด ๆ ) เนื่องจากอาร์กิวเมนต์นั้นมีความเฉพาะเจาะจงน้อยกว่าฟังก์ชั่นที่รับหมายเลขสอง (และสองเท่านั้น) เป็นอาร์กิวเมนต์ .

มีบางส่วนของข้อความซ้ำ ๆ เช่น "([x]" ซึ่งอาจเป็นนามธรรมเป็นหน้าที่ของตัวเอง - แต่ I7 verbose ดังนั้นการกำหนดฟังก์ชั่นใหม่ใช้ไบต์มากกว่านี้จะบันทึก! สถานที่เดียวที่กำหนด ฟังก์ชั่นใหม่ดูเหมือนว่าจะบันทึกไบต์สำหรับอักขระที่ไม่ใช่ ASCII เนื่องจากไวยากรณ์สำหรับการพิมพ์มีความละเอียดมากกว่าไวยากรณ์สำหรับคำจำกัดความของฟังก์ชัน

หม้อไอน้ำเพื่อเรียกใช้สิ่งนี้:

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

แทนที่ 7 ด้วยจำนวนเต็มที่ไม่เป็นลบที่คุณเลือก

Stax , 42 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

ฉันคิดว่ามันดูเหมือนว่าจะไม่ทำงานใน Firefox ใน Windows แต่นั่นเป็นเพียงเพราะตัวอักษรเริ่มต้น FF สำหรับการบินและอวกาศคือ Courier ซึ่งดูเหมือนจะไม่สนับสนุนตัวดัดแปลงยูนิโค้ดแฟนซีหรืออะไรก็ตาม ฉันคิด.

C ++ (gcc) , 102 ไบต์

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

ลองออนไลน์!

พอร์ตไร้ยางอายของโซลูชัน JavaScript ของ Arnauld

Julia 1.0 , 85 bytes

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

ลองออนไลน์!

Japt , 47 ไบต์ (UTF-8)

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

บันทึกเป็นไบต์ขอบคุณ Shaggy

ลองมัน

Java 7, 133 90 89 ไบต์

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

คำตอบ JavaScript แบบเรียกซ้ำของ Port of @ Arnauldเนื่องจากสั้นกว่าครั้งแรกที่ฉันลองใช้แลมบ์ด้า 8+ ของ Java ครั้งแรก

ลองออนไลน์

คำอธิบาย:

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 

Python 3 , 66 ไบต์

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

ลองออนไลน์!

ความคิดการคำนวณดัชนีจะยืมมาจากใน @xnor @ วิธีการแก้ปัญหาของ

ผ้าใบขนาด 46 ไบต์

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

ลองที่นี่!

ถ่าน , 41 ไบต์

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

ลองออนไลน์! deverbosifier พยายามอ้างอิงสตริงที่สองด้วยเหตุผลบางอย่าง แต่ดูเหมือนว่าไม่จำเป็น แต่นี่เป็นเวอร์ชั่น verboseหากคุณต้องการ คำอธิบาย:

Ｎθ

ใส่จำนวนใบหน้า

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

พิมพ์ด้านซ้ายของใบหน้า (ด้านขวาของเราเมื่อเราเห็น) สิ่งเหล่านี้ประกอบด้วยสตริงʖ ͡°)ทำซ้ำได้ถึงสองครั้งและจากนั้นสตริงที่ไม่มีอักขระสองตัวแรกจะทำซ้ำจำนวนครั้งที่เหลือ

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

พิมพ์ด้านขวาของใบหน้า (ด้านซ้ายของเราตามที่เราเห็น) สิ่งเหล่านี้ประกอบด้วยสตริง (กลับรายการ)ʖ͜ °͡ (ซ้ำหลายครั้งและจากนั้นสตริงนั้นที่ไม่มีอักขระสองตัวแรกจะทำซ้ำจำนวนครั้งที่เหลือ

ผู้สังเกตการณ์ในหมู่คุณมากขึ้นจะสังเกตเห็นว่าใบหน้าตรงกลางมีจมูกของมันที่สร้างขึ้นสองครั้งซึ่งเป็นสาเหตุที่ฉันพิมพ์ในลักษณะที่ทับซ้อนกัน

Python 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 เป็นอินพุทที่คุณต้องการโดยปล่อยให้อยู่คนเดียว

หากใครรู้วิธีที่ดีกว่าในการป้อนข้อมูลที่จะลดจำนวนถ่านให้ฉันรู้

ไม่มีอะไรแฟนซีเกิดขึ้นที่นี่เพียงแค่การหั่นสตริงและใช้บูลีนในทางที่ผิด