25
\$\begingroup\$

I was going through a bizarre thread on Reddit, and came across this:

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

It's representing a group of people smiling somewhat suspiciously.

(In the challenge below though, spaces to the left of the right eyes were dropped somehow while I was writing the challenge. Note the spec).


Your goal is to create a group of smiling lenny faces n deep with the following rules:

  1. At depth one, a full face (( ͡° ͜ʖ ͡°)) is shown.
  2. At depth two, half faces are shown. On the left side, a little over half the face (( ͡° ͜ʖ) is represented. On the right however, the right side is shown, and the mouth is omitted (ʖ ͡°))
  3. Any deeper, and only the sides of head and eyes are shown (( ͡° and ͡°). There's a space between the eye and left side of the head, but there are, despite appearances, no spaces on the right side. The spacing is due the ͡ character which messes with things a bit.

Input:

  • n, showing how many layers deep of faces to show.
  • n will always be in the range 0 <= n <= 500. You are not required to handle anything outside of this range.
  • n may be offset by 1 so that 0 means one face instead of no faces. You'll need to handle -1 then though.

Output:

  • A string, or character array, or anything remotely comparable (like a list of single-character strings in Python/Javascript). It can also be printed directly. Trailing white-space is fine.

You can submit a complete program, or a function.


Since it's difficult to see what characters are involved, here's it laid out in 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]

Test Cases:

face_crowd(0)
''

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

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

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

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

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

Here's an extraordinarily naive recursive reference implementation (posted on my Github). I tried to keep it as plain as possible for clarity; but there's a lot of duplication

I posted it externally because I wanted to wrap it in a spoiler in case people don't want to see a reference, but that complicates copying the code. I figure it's not important to the challenge really, so it isn't a big deal if it goes down I can paste it here if it's deemed important.


This is code-golf, so the least number of bytes in each language wins.

\$\endgroup\$
  • 11
    \$\begingroup\$ It looks even more suspicious when rendered on TIO. :p \$\endgroup\$ – Arnauld Aug 15 at 22:13
  • \$\begingroup\$ The spec and the test cases seem to be inconsistent; the spec has a space at the beginning of the right part of the latter depths, while the test cases do not. \$\endgroup\$ – tjjfvi Aug 15 at 22:14
  • \$\begingroup\$ @Arnauld Oh wow. Ya, everywhere seems to show it a little differently. \$\endgroup\$ – Carcigenicate Aug 15 at 22:15
  • 3
    \$\begingroup\$ Related \$\endgroup\$ – Shaggy Aug 15 at 22:19
  • 1
    \$\begingroup\$ @Arnauld I love URL edition too: -͡-͜ʖ-͡ \$\endgroup\$ – val says Reinstate Monica Aug 17 at 10:11

16 Answers 16

14
\$\begingroup\$

Haskell, 89 87 80 bytes

7 bytes off thanks to xnor

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

Try it online!

To start we assign ( ͡° ͜ʖ ͡°) to a string x for convenience.

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

Then we build a list of the answers and index it to find the solution. This is done by hardcoding the first two answers as the first two elements of the list and then iterating a function that adds the first 4 characters and the last 4 characters to front and back of the string across the third answer.

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

We also have the special function (#) which adds a specified amount of ( ͡° ͜ʖ ͡°) to the front and back of a string:

(a#b)y=take a x++y++drop b x
\$\endgroup\$
8
\$\begingroup\$

JavaScript (ES6), 66 bytes

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

Try it online!

Or try it with the following snippet for a better rendering.

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>

Commented

In the following code, we use the character set "eEMN" (eyebrow, eye, mouth and nose respectively) in order to preserve the formatting.

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
\$\endgroup\$
6
\$\begingroup\$

Python 3, 75 bytes

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

Try it online!

-6 bytes thanks to xnor

\$\endgroup\$
  • 6
    \$\begingroup\$ I did some brute-force searching and found that 4+3*(i<3) can be 7+~2%~i and 8-2*(i<3) can be 6+2%i. \$\endgroup\$ – xnor Aug 16 at 10:53
  • \$\begingroup\$ @xnor Brilliant, thanks! \$\endgroup\$ – Jitse Aug 16 at 10:57
6
\$\begingroup\$

Excel, 85 bytes

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

Naive solution for n>1. Second repeat required to handle 0 testcase.

\$\endgroup\$
  • \$\begingroup\$ Do you need the last REPT? \$\endgroup\$ – Neil Aug 16 at 19:31
  • \$\begingroup\$ The last REPT is required to handle the 0 case. \$\endgroup\$ – Wernisch Aug 19 at 8:44
5
\$\begingroup\$

Retina 0.8.2, 56 bytes

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

Try it online! Explanation:

.+
$*< $&$*>

Generate the cheeks, but use <s and >s because (s and )s would need to be quoted. A space in the middle ends up between the middle man's nose and left eye.

 >>
 >ʖ >

If the man in the middle has a man on his left, give that man a nose and a space between it and his left eye.

<(?=<? )
< ͜ʖ

Add the mouth and nose to the man in the middle and the man to his right if any. We don't see the left eye of the man to his right so he doesn't need a space, and we gave the man in the middle a space on the first stage.

<
( ͡°

Fix the right cheeks and add the right eyes.

>
͡°)

Fix the left cheeks and add the left eyes.

\$\endgroup\$
  • 1
    \$\begingroup\$ @Arnauld Phew, it took me some time, but I think I managed to fix it for only a single extra byte! \$\endgroup\$ – Neil Aug 16 at 19:28
4
\$\begingroup\$

Perl 5 -p, 96 bytes

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

Try it online!

\$\endgroup\$
4
\$\begingroup\$

Inform 7, 262 bytes

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

This takes advantage of Inform 7's function overloading: the most specific overload will be run, and the function that takes a number (any integer) as its argument is less specific than the function that takes the number two (and only two) as its argument.

There are some repeated bits of text, like "( [x]", which could potentially be abstracted as functions of their own—but I7 is so verbose, defining a new function takes more bytes than this would save! The only places defining a new function seems to save bytes is for the non-ASCII characters, since the syntax for printing them is even more verbose than the syntax for function definitions.

Boilerplate to run this:

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

Replace 7 with a non-negative integer of your choice.

\$\endgroup\$
  • \$\begingroup\$ Nice to see an Inform answer! \$\endgroup\$ – Flounderer Aug 17 at 13:29
3
\$\begingroup\$

Stax, 42 bytes

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

Run and debug it

I think it appears not to work in Firefox in Windows. But that's just because the FF default font for monospace is Courier, which seems not to support these fancy unicode modifiers or whatever. I think.

\$\endgroup\$
3
\$\begingroup\$

C++ (gcc), 102 bytes

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

Try it online!

Shameless port of Arnauld's JavaScript solution.

\$\endgroup\$
  • 1
    \$\begingroup\$ Maybe you have to include #include <string> # 103 \$\endgroup\$ – AZTECCO Aug 19 at 0:54
  • \$\begingroup\$ Indeed, thanks for reminding me :) \$\endgroup\$ – G. Sliepen Aug 19 at 5:52
2
\$\begingroup\$

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]

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Japt, 47 bytes (UTF-8)

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

Saved a byte thanks to Shaggy

Try it

\$\endgroup\$
  • \$\begingroup\$ 47 bytes? \$\endgroup\$ – Shaggy Aug 16 at 10:12
  • \$\begingroup\$ The expected output for U=0 is an empty string so you may want to ask for confirmation on outputting a space instead. \$\endgroup\$ – Shaggy Aug 16 at 16:10
2
\$\begingroup\$

Java 7, 133 90 89 bytes

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

Port of @Arnauld's recursive JavaScript answer, since it's shorter than my initial first attempt using a Java 8+ lambda.

Try it online.

Explanation:

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 
\$\endgroup\$
2
\$\begingroup\$

Python 3, 66 bytes

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

Try it online!

The index calculation idea is borrowed from @xnor in @Jitse's solution.

\$\endgroup\$
1
\$\begingroup\$

Canvas, 46 bytes

b*5USy{↖qYq⇵≡„a¹„┬Hc+
⁷m;⁷±m±└++
H?34⁸]]⁷]57⁸}

Try it here!

\$\endgroup\$
1
\$\begingroup\$

Charcoal, 41 bytes

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

Try it online! The deverbosifier tries to quote the second string for some reason, but it doesn't seem to be necessary, but here's the verbose version if you want it. Explanation:

Nθ

Input the number of faces.

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

Print the left sides of the faces (on our right as we see them). These consist of the string ʖ ͡°) repeated up to twice, and then that string without the first two characters repeated the remaining number of times.

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

Print the right sides of the faces (on our left as we see them). These consist of the (reversed) string ʖ͜ °͡ ( repeated up to twice, and then that string without the first two characters repeated the remaining number of times.

The more observant among you will have noticed that the middle face has its nose generated twice which is why I'm printing in such a way that they overlap.

\$\endgroup\$
1
\$\begingroup\$

Python 3, 80 chars, 86 bytes

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

Try it online!

To put input, change the 3 to whatever input you want, leaving the -1 alone.

If anyone knows a better way to do input that would reduce the char count let me know.

Nothing fancy going on here, just string slicing and abuse of booleans

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.