Я переглядав химерну нитку на Reddit, і натрапив на це:

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

Він представляє групу людей, які посміхаються дещо підозріло.

(Однак, у нижченаведеному виклику, пробіли ліворуч від правого ока якимось чином були скинуті, коли я писав виклик. Зверніть увагу на специфікацію).

Ваша мета - створити групу усміхнених линницьких облич 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

Спробуйте в Інтернеті!

Для початку ми призначаємо (assign ° ͜ʖ ͡ °) рядку xдля зручності.

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

Тоді ми будуємо список відповідей та індексуємо його, щоб знайти рішення. Це робиться шляхом жорсткого кодування перших двох відповідей як перших двох елементів списку, а потім ітерації функції, яка додає перші 4 символи та останні 4 символи до передньої та задньої частини рядка через третю відповідь.

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

Також у нас є спеціальна функція, (#)яка додає задану кількість (͡ ° ͜ʖ ͡ °) до передньої та задньої частини рядка:

(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. Другий повтор, необхідний для обробки 0тесту.

Сітківка 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 настільки багатослівний, що визначення нової функції займає більше байтів, ніж це дозволить заощадити! Єдині місця, що визначають Здається, нова функція збереження байтів призначена для символів, що не належать до ASCII, оскільки синтаксис для їх друку навіть більш багатослівний, ніж синтаксис для визначень функцій.

Котельня для запуску цього:

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

Замініть 7 на невід'ємне ціле число на ваш вибір.

Стакс , 42 байти

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

Запустіть і налагоджуйте його

Я думаю, що це не працює в Firefox в Windows. Але це тільки тому, що шрифтом FF за замовчуванням для монопростору є Courier, який, здається, не підтримує ці фантазійні модифікатори Unicode чи що завгодно. Я думаю.

C ++ (gcc) , 102 байти

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

Спробуйте в Інтернеті!

Безсоромний порт JavaScript-рішення Arnauld.

Джулія 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]

Спробуйте в Інтернеті!

Japt , 47 байт (UTF-8)

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

Збережено байт завдяки Шаггі

Спробуй це

Ява 7, 133 90 89 байт

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

Порт рекурсивної відповіді JavaScript @ Arnauld , оскільки він коротший, ніж моя перша спроба використання лямбда Java 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 

Python 3 , 66 байт

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

Спробуйте в Інтернеті!

Ідея обчислення індексу запозичена у @xnor у рішенні @ Jitse .

Полотно , 46 байт

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

Спробуйте тут!

Вугілля деревне , 41 байт

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

Спробуйте в Інтернеті! Deverbosifier чомусь намагається процитувати другий рядок, але це, здається, не потрібно, але ось вербальна версія якщо ви цього хочете. Пояснення:

Ｎθ

Введіть кількість граней.

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

Роздрукуйте ліві сторони граней (праворуч так, як ми їх бачимо). Вони складаються з рядка, ʖ ͡°)повтореного до двох разів, а потім цей рядок без перших двох символів повторюється решту кількість разів.

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

Роздрукуйте праві сторони граней (ліворуч так, як ми їх бачимо). Вони складаються з (зворотного) рядкаʖ͜ °͡ ( повтореного до двох разів, а потім цей рядок без перших двох символів повторюється решту кількість разів.

Більш спостережливі серед вас зауважили, що середнє обличчя утворило ніс удвічі, тому я друкую так, що вони перекриваються.

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 на будь-який вхід, який ви хочете, залишивши -1 у спокої.

Якщо хтось знає кращий спосіб зробити вклад, який би зменшив кількість знаків, дайте мені знати.

Тут нічого фантазійного не відбувається, просто нарізка рядків та зловживання булевими