Reddit'teki tuhaf bir konudan geçiyordum ve şuna rastladım:

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

Şüpheli bir şekilde gülen bir grup insanı temsil ediyor.

(Yine de aşağıdaki meydan okumada, meydan okumayı yazarken, sağ gözlerin solundaki boşluklar bir şekilde düştü.

Amacınız naşağıdaki kurallarla derinlemesine yüz yüze gelen gülümseyen bir grup oluşturmaktır :

1. Birinci derinlikte, tam bir yüz ( ( ͡° ͜ʖ ͡°)) gösterilir.
2. İkinci derinlikte, yarım yüzler gösterilir. Sol tarafta, yüzün yarısından biraz fazlası ( ( ͡° ͜ʖ) temsil edilir. Ancak sağda, sağ taraf gösterilir ve ağız atlanır ( ʖ ͡°)).
3. Daha derin ve sadece başın ve gözlerin yanları gösterilir ( ( ͡°ve ͡°). Başın gözü ile sol tarafı arasında boşluk vardır, ancak görünüşe rağmen sağ tarafta boşluk yoktur. Boşluk ͡karakterden kaynaklanmaktadır. işleri biraz karıştırır.

Giriş:

• nyüzlerin derinliğini gösteren kaç katman gösteriliyor.
• nher zaman menzilde olacak 0 <= n <= 500. Bu aralığın dışındaki hiçbir şeyi kullanmanız gerekmez.
• n1 ile ofset yapılabilir, böylece 0, yüz yerine bir yüz anlamına gelir. Yine de -1 ile başa çıkmanız gerekecek.

Çıktı:

• Bir dize, karakter dizisi veya uzaktan karşılaştırılabilir herhangi bir şey (Python / Javascript'teki tek karakterli dizelerin listesi gibi). Ayrıca doğrudan basılabilir. Beyaz boşluk takip ediyor.

Tam bir program veya bir işlev gönderebilirsiniz.

Hangi karakterlerin dahil olduğunu görmek zor olduğu için, Python'da ortaya konmuştur:

>> [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 Durumları:

face_crowd(0)
''

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

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

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

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

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

İşte olağanüstü derecede saf özyinelemeli referans uygulaması (Github'ımda yayınlanan). Netlik için mümkün olduğunca sade tutmaya çalıştım; ama çok fazla çoğaltma var

Dışarıdan gönderdim çünkü insanların referans görmek istememeleri durumunda bir spoilerde sarmak istedim ama bu kodun kopyalanmasını zorlaştırıyordu. Gerçekten zorluğun önemli olmadığını düşünüyorum, bu yüzden eğer düşerse önemli değil, buraya yapıştırabilirim.

Bu kod golf, yani her dilde en az bayt kazanıyor.

Haskell , 89 87 80 bayt

Xnor sayesinde 7 byte kapalı

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

Çevrimiçi deneyin!

Başlamak xiçin kolaylık sağlamak için bir dizgiye (͡ ° ͜ʖ ͡ °) atadık .

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

Sonra cevapların bir listesini yaparız ve çözümü bulmak için dizine ekleriz. Bu, ilk iki cevabı listenin ilk iki unsuru olarak kodlamak ve daha sonra ilk 4 karakteri ve son 4 karakteri dizenin önüne ve arkasına üçüncü cevap boyunca ekleyen bir fonksiyonu tekrarlamak suretiyle yapılır.

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

Ayrıca (#)bir dizginin önüne ve arkasına belirli miktarda (͡ ° ͜ʖ ͡ °) ekleyen özel bir işleve sahibiz:

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

JavaScript (ES6), 66 bayt

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

Çevrimiçi deneyin!

Veya daha iyi bir görüntü elde etmek için aşağıdaki pasajla deneyin.

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>

Yorumlananlar

Aşağıdaki kodda, "eEMN"biçimlendirmeyi korumak için karakter setini (sırasıyla kaş, göz, ağız ve burun) kullanıyoruz.

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 bayt

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

Çevrimiçi deneyin!

Xnor sayesinde -6 bayt

Excel, 85 bayt

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

İçin saf çözüm n>1. 0Test çantası işlemek için ikinci tekrar gerekli .

Retina 0.8.2 , 56 bayt

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

Çevrimiçi deneyin! Açıklama:

.+
$*< $&$*>

Yanakları oluşturun, ancak <s ve >s'yi kullanın çünkü (s ve )s'nin alıntılanması gerekir. Ortadaki boşluk, orta adamın burnu ile sol göz arasında biter.

 >>
 >ʖ >

Ortadaki adamın solunda bir erkek varsa, o adama bir burun ve sol gözüyle arasında bir boşluk verin.

<(?=<? )
< ͜ʖ

Ağız ve burnu ortadaki adama, varsa sağa sokun. Adamın sol gözünü sağında görmüyoruz, o yüzden bir alana ihtiyacı yok ve ortadaki adama ilk etapta bir boşluk verdik.

<
( ͡°

Doğru yanakları düzeltin ve doğru gözleri ekleyin.

>
͡°)

Sol yanakları düzeltin ve sol gözleri ekleyin.

Perl 5 -p , 96 bayt

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

Çevrimiçi deneyin!

Bilgilendirme 7 , 262 bayt

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

Bu, Inform 7'nin fonksiyon aşırı yüklenmesinden faydalanır: en spesifik aşırı yüklenme çalıştırılır ve bağımsız değişken olarak bir sayı (herhangi bir tam sayı) alan işlev, bağımsız değişken olarak iki sayıyı (ve sadece iki tane) alan işlevden daha az belirgindir .

Potansiyel olarak kendi işlevleri olarak soyutlanabilen "([x]" gibi bazı tekrarlanan metin parçaları vardır - ancak I7 çok ayrıntılıdır, yeni bir işlev tanımlamak, kurtaracağınızdan daha fazla bayt alır! Yeni işlev baytları kurtarıyor gibi görünüyor ASCII olmayan karakterler içindir, çünkü bunları yazdırmak için kullanılan sözdizimi, işlev tanımları için kullanılan sözdiziminden daha ayrıntılıdır.

Bunu çalıştırmak için kazan plakası:

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

Seçtiğiniz negatif olmayan bir tamsayı ile 7 değiştirin.

Stax , 42 bayt

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

Koş ve hata ayıkla

Sanırım Windows'ta Firefox'ta çalışmıyor gibi görünüyor. Ancak bu, monospace için FF varsayılan yazı tipinin Courier olması nedeniyle, bu süslü unicode değiştiricileri veya her neyse onu desteklemiyor gibi görünüyor. Bence.

C ++ (gcc) , 102 bayt

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

Çevrimiçi deneyin!

Arnauld'un JavaScript çözümünün utanmaz limanı.

Julia 1.0 , 85 bayt

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

Çevrimiçi deneyin!

Japt , 47 bayt (UTF-8)

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

Shaggy sayesinde bir bayt kaydedildi

Dene

Java 7, 133 90 89 bayt

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

@ Arnauld limanı özyinelemeli JavaScript cevabı , çünkü Java 8+ lambda kullanmaya başladığım ilk girişimden daha kısa.

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Endeks hesaplama fikri @ Jitse'nin çözümünde @xnor'dan ödünç alınmıştır .

Tuval , 46 bayt

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

Burada dene!

Kömür , 41 bayt

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

Çevrimiçi deneyin! Deverbosifier bazı nedenlerden dolayı ikinci dizgiyi alıntılamaya çalışır, ancak gerekli görünmüyor, ancak eğer istersen ayrıntılı sürüm . Açıklama:

Ｎθ

Yüz sayısını girin.

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

Yüzlerin sol taraflarını yazdırın (gördüğümüz gibi sağımızda). Bunlar, ʖ ͡°)iki defa tekrarlanan dizgeden oluşur ve sonra ilk iki karakter olmadan bu dize kalan sayıda tekrarlanır.

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

Yüzlerin sağ taraflarını yazdırın (gördüğümüz gibi solumuzda). Bunlar, ʖ͜ °͡ (iki defaya kadar tekrarlanan (tersine çevrilmiş) dizgeden oluşur ve ardından ilk iki karakterin olmadığı dizgenin kalan sayısı tekrarlanır.

Aranızdan daha fazla gözlemci, orta yüzün burnunun iki kez üretildiğini fark etmiş olacak, bu yüzden üst üste gelecek şekilde baskı yapıyorum.

Python 3 , 80 karakter, 86 bayt

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

Çevrimiçi deneyin!

Girdiyi koymak için, 3'ü istediğiniz giriş olarak değiştirin, -1 işaretini bırakın.

Kimse girdi yapmanın daha iyi bir yolunu biliyorsa, bu char sayısını düşürür.

Burada hiçbir şey olmaz, sadece dilimleme ve booleanların istismarı