Tôi đã trải qua một chủ đề kỳ lạ trên Reddit, và tình cờ thấy điều này:

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

Nó đại diện cho một nhóm người mỉm cười hơi nghi ngờ.

(Tuy nhiên, trong thử thách dưới đây, khoảng trống ở bên trái của mắt phải bị bỏ đi bằng cách nào đó trong khi tôi đang viết thử thách. Lưu ý thông số kỹ thuật).

Mục tiêu của bạn là tạo ra một nhóm những khuôn mặt tươi cười nsâu sắc với các quy tắc sau:

1. Ở độ sâu một, một khuôn mặt đầy đủ ( ( ͡° ͜ʖ ͡°)) được hiển thị.
2. Ở độ sâu hai, một nửa khuôn mặt được hiển thị. Ở phía bên trái, hơn một nửa khuôn mặt ( ( ͡° ͜ʖ) được biểu thị. Tuy nhiên, ở bên phải, bên phải được hiển thị và miệng bị bỏ qua ( ʖ ͡°))
3. Bất kỳ sâu sắc hơn, và chỉ có hai bên đầu và đôi mắt được hiển thị ( ( ͡°và ͡°). Có một khoảng cách giữa mắt và bên trái của người đứng đầu, nhưng có, mặc dù xuất hiện, không có khoảng trống ở bên phải. Khoảng cách là do các ͡nhân vật mà gây rối với mọi thứ một chút.

Đầu vào:

• n, hiển thị có bao nhiêu lớp sâu của khuôn mặt để hiển thị.
• nsẽ luôn ở trong phạm vi 0 <= n <= 500. Bạn không cần phải xử lý bất cứ điều gì ngoài phạm vi này.
• ncó thể được bù bởi 1 để 0 có nghĩa là một mặt thay vì không có mặt. Bạn sẽ cần phải xử lý -1 sau đó.

Đầu ra:

• Một chuỗi, hoặc mảng ký tự hoặc bất cứ thứ gì có thể so sánh từ xa (như danh sách các chuỗi ký tự đơn trong Python / Javascript). Nó cũng có thể được in trực tiếp. Trailing-space trắng là tốt.

Bạn có thể gửi một chương trình hoàn chỉnh, hoặc một chức năng.

Vì rất khó để xem những nhân vật nào có liên quan, đây là điều được trình bày trong 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]

Các trường hợp thử nghiệm:

face_crowd(0)
''

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

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

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

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

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

Đây là một triển khai tham chiếu đệ quy cực kỳ ngây thơ (được đăng trên Github của tôi). Tôi đã cố gắng giữ nó càng đơn giản càng tốt cho rõ ràng; nhưng có rất nhiều sự trùng lặp

Tôi đã đăng nó ra bên ngoài vì tôi muốn bọc nó trong một spoiler trong trường hợp mọi người không muốn xem tài liệu tham khảo, nhưng điều đó làm phức tạp việc sao chép mã. Tôi cho rằng nó không quan trọng đối với thử thách, vì vậy nó không phải là vấn đề lớn nếu nó đi xuống Tôi có thể dán nó ở đây nếu nó được coi là quan trọng.

Đây là môn đánh gôn, vì vậy số byte ít nhất trong mỗi ngôn ngữ sẽ thắng.

Haskell , 89 87 80 byte

Giảm 7 byte nhờ xnor

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

Hãy thử trực tuyến!

Để bắt đầu, chúng ta gán (͡ ° ͜ʖ °) cho một chuỗi xđể thuận tiện.

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

Sau đó, chúng tôi xây dựng một danh sách các câu trả lời và lập chỉ mục để tìm giải pháp. Điều này được thực hiện bằng cách mã hóa hai câu trả lời đầu tiên là hai phần tử đầu tiên của danh sách và sau đó lặp lại một hàm thêm 4 ký tự đầu tiên và 4 ký tự cuối vào trước và sau của chuỗi qua câu trả lời thứ ba.

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

Chúng tôi cũng có chức năng đặc biệt (#)bổ sung một lượng nhất định (͡ ° ͜ʖ °) vào mặt trước và mặt sau của chuỗi:

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

JavaScript (ES6), 66 byte

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

Hãy thử trực tuyến!

Hoặc thử với đoạn mã sau để hiển thị tốt hơ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>

Đã bình luận

Trong đoạn mã sau, chúng tôi sử dụng bộ ký tự "eEMN"(lông mày, mắt, miệng và mũi tương ứng) để giữ nguyên định dạng.

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 byte

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

Hãy thử trực tuyến!

-6 byte nhờ xnor

Excel, 85 byte

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

Giải pháp ngây thơ cho n>1. Lặp lại thứ hai cần thiết để xử lý 0testcase.

Võng mạc 0.8.2 , 56 byte

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

Hãy thử trực tuyến! Giải trình:

.+
$*< $&$*>

Tạo má, nhưng sử dụng <s và >s vì (s và )s sẽ cần được trích dẫn. Một khoảng trống ở giữa kết thúc giữa mũi và mắt trái của người đàn ông giữa.

 >>
 >ʖ >

Nếu người đàn ông ở giữa có một người đàn ông ở bên trái, hãy cho người đàn ông đó một cái mũi và một khoảng trống giữa nó và mắt trái của anh ta.

<(?=<? )
< ͜ʖ

Thêm miệng và mũi cho người đàn ông ở giữa và người đàn ông ở bên phải nếu có. Chúng tôi không nhìn thấy mắt trái của người đàn ông bên phải nên anh ta không cần một khoảng trống, và chúng tôi đã cho người đàn ông ở giữa một khoảng trống trên sân khấu đầu tiên.

<
( ͡°

Sửa má phải và thêm mắt phải.

>
͡°)

Sửa má trái và thêm mắt trái.

Perl 5 -p , 96 byte

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

Hãy thử trực tuyến!

Thông báo 7 , 262 byte

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 "".

Điều này lợi dụng quá tải chức năng của Inform 7: quá tải cụ thể nhất sẽ được chạy và hàm lấy một số (bất kỳ số nguyên nào) làm đối số của nó ít cụ thể hơn hàm lấy số hai (và chỉ hai) làm đối số .

Có một số bit văn bản lặp đi lặp lại, như "([x]", có khả năng có thể được trừu tượng hóa như các chức năng của chính họ nhưng I7 rất dài dòng, việc xác định một hàm mới cần nhiều byte hơn mức này sẽ tiết kiệm! chức năng mới dường như lưu byte là dành cho các ký tự không phải ASCII, vì cú pháp in chúng thậm chí còn dài dòng hơn cú pháp cho các định nghĩa hàm.

Nồi hơi để chạy này:

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

Thay thế 7 bằng một số nguyên không âm của sự lựa chọn của bạn.

Stax , 42 byte

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

Chạy và gỡ lỗi nó

Tôi nghĩ rằng nó dường như không hoạt động trong Firefox trong Windows. Nhưng đó chỉ là vì phông chữ mặc định FF cho monospace là Courier, dường như không hỗ trợ các bộ sửa đổi unicode ưa thích này hoặc bất cứ thứ gì. Tôi nghĩ.

C ++ (gcc) , 102 byte

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

Hãy thử trực tuyến!

Cổng không biết xấu hổ của giải pháp JavaScript của Arnauld.

Julia 1.0 , 85 byte

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

Hãy thử trực tuyến!

Japt , 47 byte (UTF-8)

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

Đã lưu một byte nhờ Shaggy

Thử nó

Java 7, 133 90 89 byte

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

Cảng Câu trả lời JavaScript đệ quy @ Arnauld , vì nó ngắn hơn lần thử đầu tiên của tôi khi sử dụng lambda Java 8+.

Hãy thử trực tuyến.

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Ý tưởng tính toán chỉ số được mượn từ @xnor trong giải pháp của @ Jitse .

Canvas , 46 byte

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

Hãy thử nó ở đây!

Than , 41 byte

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

Hãy thử trực tuyến! Deverbosifier cố gắng trích dẫn chuỗi thứ hai vì một số lý do, nhưng dường như không cần thiết, nhưng đây là phiên bản dài dòng nếu bạn muốn. Giải trình:

Ｎθ

Nhập số lượng khuôn mặt.

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

In bên trái của các khuôn mặt (bên phải của chúng tôi khi chúng ta nhìn thấy chúng). Chúng bao gồm các chuỗiʖ ͡°) lặp lại tối đa hai lần, và sau đó chuỗi đó không có hai ký tự đầu tiên lặp lại số lần còn lại.

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

In bên phải của các khuôn mặt (bên trái của chúng tôi khi chúng ta nhìn thấy chúng). Chúng bao gồm chuỗi (đảo ngược)ʖ͜ °͡ ( lặp lại tối đa hai lần, và sau đó chuỗi đó không có hai ký tự đầu tiên lặp lại số lần còn lại.

Những người quan sát nhiều hơn sẽ nhận thấy rằng khuôn mặt giữa có mũi được tạo ra hai lần, đó là lý do tại sao tôi in theo cách mà chúng trùng nhau.

Python 3 , 80 ký tự, 86 byte

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

Hãy thử trực tuyến!

Để đặt đầu vào, thay đổi 3 thành bất kỳ đầu vào nào bạn muốn, để lại -1.

Nếu bất cứ ai biết một cách tốt hơn để làm đầu vào sẽ làm giảm số lượng char cho tôi biết.

Không có gì lạ mắt xảy ra ở đây, chỉ cần cắt chuỗi và lạm dụng booleans