Stavo attraversando un bizzarro thread su Reddit e mi sono imbattuto in questo:

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

Rappresenta un gruppo di persone che sorridono un po 'sospettosamente.

(Nella sfida di seguito, però, gli spazi a sinistra degli occhi a destra sono stati lasciati cadere in qualche modo mentre stavo scrivendo la sfida. Nota le specifiche).

Il tuo obiettivo è quello di creare un gruppo di volti sorridenti di Lenny in nprofondità con le seguenti regole:

1. Alla profondità uno, ( ͡° ͜ʖ ͡°)viene mostrata una faccia intera ( ).
2. Alla profondità due, vengono mostrate le mezze facce. Sul lato sinistro, ( ͡° ͜ʖviene rappresentata poco più della metà della faccia ( ). A destra, tuttavia, viene mostrato il lato destro e la bocca viene omessa ( ʖ ͡°))
3. Qualsiasi più profondo, e vengono mostrati solo i lati della testa e degli occhi ( ( ͡°e ͡°). C'è uno spazio tra l'occhio e il lato sinistro della testa, ma non ci sono, nonostante le apparenze, spazi sul lato destro. La spaziatura è dovuta al ͡personaggio che fa un po 'casino con le cose.

Ingresso:

• n, mostrando quanti strati profondi di facce mostrare.
• nsarà sempre nella gamma 0 <= n <= 500. Non è necessario gestire nulla al di fuori di questo intervallo.
• npuò essere sfalsato di 1 in modo che 0 significhi una faccia anziché nessuna faccia. Tuttavia, dovrai gestire -1.

Produzione:

• Una stringa, o array di caratteri, o qualsiasi cosa paragonabile a distanza (come un elenco di stringhe a carattere singolo in Python / Javascript). Può anche essere stampato direttamente. Lo spazio bianco finale va bene.

È possibile inviare un programma completo o una funzione.

Dal momento che è difficile vedere quali personaggi sono coinvolti, eccolo qui esposto 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]

Casi test:

face_crowd(0)
''

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

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

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

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

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

Ecco un'implementazione di riferimento ricorsiva straordinariamente ingenua (pubblicata sul mio Github). Ho cercato di renderlo il più semplice possibile per chiarezza; ma ci sono molte duplicazioni

L'ho pubblicato esternamente perché volevo inserirlo in uno spoiler nel caso in cui le persone non volessero vedere un riferimento, ma ciò complica la copia del codice. Immagino che non sia davvero importante per la sfida, quindi non è un grosso problema se va giù, posso incollarlo qui se è ritenuto importante.

Questo è code-golf, quindi vince il minor numero di byte in ogni lingua.

Haskell , 89 87 80 byte

7 byte di sconto grazie a xnor

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

Provalo online!

Per iniziare, assegniamo (͡ ° ͜ʖ ͡ °) a una stringa xper comodità.

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

Quindi creiamo un elenco delle risposte e lo indicizziamo per trovare la soluzione. Questo viene fatto hardcodizzando le prime due risposte come i primi due elementi dell'elenco e quindi ripetendo una funzione che aggiunge i primi 4 caratteri e gli ultimi 4 caratteri all'inizio e alla fine della stringa attraverso la terza risposta.

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

Abbiamo anche la funzione speciale (#)che aggiunge una quantità specificata di (͡ ° ͜ʖ ͡ °) alla parte anteriore e posteriore di una stringa:

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

JavaScript (ES6), 66 byte

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

Provalo online!

Oppure provalo con il frammento seguente per un rendering migliore.

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>

Commentate

Nel codice seguente, utilizziamo il set di caratteri "eEMN"(rispettivamente sopracciglio, occhio, bocca e naso) per preservare la formattazione.

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

Provalo online!

-6 byte grazie a xnor

Excel, 85 byte

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

Soluzione ingenua per n>1. È richiesta una seconda ripetizione per gestire la 0testcase.

Retina 0.8.2 , 56 byte

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

Provalo online!Spiegazione:

.+
$*< $&$*>

Genera le guance, ma usa <s e >s perché( s e) s dovrebbero essere citati. Uno spazio nel mezzo finisce tra il naso dell'uomo medio e l'occhio sinistro.

 >>
 >ʖ >

Se l'uomo nel mezzo ha un uomo alla sua sinistra, dai a quell'uomo un naso e uno spazio tra esso e l'occhio sinistro.

<(?=<? )
< ͜ʖ

Aggiungi la bocca e il naso all'uomo nel mezzo e l'uomo alla sua destra, se presente. Non vediamo l'occhio sinistro dell'uomo alla sua destra, quindi non ha bisogno di uno spazio, e abbiamo dato all'uomo nel mezzo uno spazio al primo livello.

<
( ͡°

Ripara le guance giuste e aggiungi gli occhi giusti.

>
͡°)

Ripara le guance sinistra e aggiungi gli occhi sinistri.

Perl 5 -p , 96 byte

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

Provalo online!

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

Questo sfrutta il sovraccarico della funzione di Inform 7: verrà eseguito il sovraccarico più specifico e la funzione che accetta un numero (qualsiasi numero intero) in quanto il suo argomento è meno specifico della funzione che accetta il numero due (e solo due) come argomento .

Ci sono alcuni bit ripetuti di testo, come "([x]", che potrebbero essere astratti come funzioni proprie - ma I7 è così dettagliato, la definizione di una nuova funzione richiede più byte di quanti ne salverebbe! Gli unici posti che definiscono un la nuova funzione sembra salvare i byte è per i caratteri non ASCII, poiché la sintassi per stamparli è ancora più dettagliata della sintassi per le definizioni delle funzioni.

Boilerplate per eseguire questo:

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

Sostituisci 7 con un numero intero non negativo a tua scelta.

Stax , 42 byte

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

Esegui ed esegui il debug

Penso che sembra non funzionare in Firefox in Windows. Ma questo è solo perché il carattere predefinito FF per monospace è Courier, che sembra non supportare questi modificatori Unicode fantasiosi o altro. Credo.

C ++ (gcc) , 102 byte

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

Provalo online!

Porta spudorata della soluzione JavaScript di 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]

Provalo online!

Japt , 47 byte (UTF-8)

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

Salvataggio di un byte grazie a Shaggy

Provalo

Java 7, 133 90 89 byte

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

La risposta JavaScript ricorsiva di Port of @ Arnauld , poiché è più breve del mio primo tentativo iniziale di utilizzare un lambda Java 8+.

Provalo online.

Spiegazione:

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:]

Provalo online!

L'idea di calcolo dell'indice è presa in prestito da @xnor nella soluzione di @ Jitse .

Tela , 46 byte

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

Provalo qui!

Carbone , 41 byte

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

Provalo online! Il deverbosificatore tenta di citare la seconda stringa per qualche motivo, ma non sembra essere necessario, ma ecco la versione dettagliata se lo desideri. Spiegazione:

Ｎθ

Inserisci il numero di facce.

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

Stampa i lati sinistro delle facce (alla nostra destra come le vediamo). Questi consistono nella stringa ʖ ͡°)ripetuta fino a due volte, e quindi quella stringa senza i primi due caratteri ha ripetuto il numero rimanente di volte.

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

Stampa i lati destra delle facce (alla nostra sinistra come le vediamo). Questi consistono nella stringa (invertita)ʖ͜ °͡ ( ripetuta fino a due volte, e poi quella stringa senza i primi due caratteri ripetuta il numero rimanente di volte.

Il più attento tra voi avrà notato che la faccia media ha il naso generato due volte, motivo per cui sto stampando in modo tale che si sovrappongano.

Python 3 , 80 caratteri, 86 byte

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

Provalo online!

Per mettere l'input, cambia il 3 in qualunque input tu voglia, lasciando solo -1.

Se qualcuno conosce un modo migliore per fare input che ridurrebbe il conteggio dei caratteri fammelo sapere.

Non c'è niente di speciale qui, solo il taglio delle corde e l'abuso di booleani