Descrição do Desafio

Em alguns canais de um site popular de streaming, twitch.tv, uma mensagem comum é a de que as pessoas enviam spam em chats para atrair pessoas a enviar "LUL".

One more LUL and I'm out

LUL é um emote popular usado para expressar que algo engraçado aconteceu no fluxo.

Logo, memes úmidos mostraram seu potencial e uma paródia da cópia-massa se seguiu:

One more "One more LUL and I'm out" and I'm out

Qual é a mesma mensagem aninhada em si mesma. Dado um número inteiro não negativo N, produza os Ntempos aninhados da massa LUL em si, seguindo o padrão abaixo.

Aplicam-se as regras de código-golfe padrão , o código mais curto em bytes vence.

Entrada / saída de amostra

0: One more LUL and I'm out
1: One more "One more LUL and I'm out" and I'm out
2: One more "One more "One more LUL and I'm out" and I'm out" and I'm out
...
7: One more "One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out

Notas

• Novas linhas iniciais / finais são permitidas
• A capitalização deve ser preservada
• Seu código pode ser um programa completo ou uma função
• Em vez de imprimir, você pode retornar uma string ou seu equivalente no idioma de sua escolha
• Você pode indexar em 1vez de0

Python 2 , 56 bytes

lambda x:('"One more '*x+'LUL'+' and I\'m out"'*x)[1:-1]

Experimente online!
É 1 indexado

JavaScript, 57 56 54 52 bytes

f=q=>`One more ${q?`"${f(q-1)}"`:"LUL"} and I'm out`

Snippet de teste:

f=q=>`One more ${q?`"${f(q-1)}"`:"LUL"} and I'm out`

<input type=number min=0 oninput=o.textContent=f(+this.value)>

<p id=o>

Por alguma razão, o snippet de lanche está com erros quando a entrada é 0, mas isso funciona de outra maneira. Chame assim f(4).

Explicação

f=q=>                      //declares a function f with argument q
`One more ... and I'm out` //hardcoded string
 ${q?`"${f(q-1)}"`:"LUL"}  // does recursion based on q
                           // if q is true, ie not 0, recurse
                           // else return "LUL"

Befunge, 91 bytes

&:00p10p>"tuo m'I dna "1v
09p00-1<^g09p01-1_v#:g0<<vg
>>00g:#^_$>:#,_@  >$"LUL">" erom enO"

Experimente online!

Este é um detalhamento do código-fonte com as várias partes do componente destacadas.

Começamos lendo a contagem de repetições N e armazenando duas duplicatas na memória.
Em seguida, fazemos a contagem regressiva do primeiro N , empurrando várias cópias de "e estou fora" na pilha ao contrário. Cada cópia adicional é separada da cópia anterior com uma cotação. A cotação é gerada com a sequência 90g(basicamente lendo uma cópia da primeira linha da fonte), pois essa é a maneira mais curta de fazer isso.
Quando esse primeiro loop é concluído, pressionamos "LUL" na pilha (tecnicamente, isso é o inverso, mas obviamente não faz diferença quando é um palíndromo).
Depois, temos outro loop, passando pela borda direita, para a esquerda do campo de jogo e depois novamente. Desta vez, estamos contando o segundo N, colocando várias cópias de "Mais um" na pilha (novamente no sentido inverso). E, novamente, cada cópia adicional é separada da cópia anterior com uma cotação.
Depois que o segundo loop estiver concluído, a frase inteira estará agora na pilha (no sentido inverso), por isso precisamos simplesmente escrevê-la.

05AB1E , 30 29 bytes

…LULIF“"One€£ ÿ€ƒ I'm€Ä"“}}¦¨

Experimente online!

Diferentes tipos de string não parecem se misturar bem, então, por algum motivo, preciso finalizar o loop duas vezes.

C ++, 118 + 16 = 134 bytes

auto L(int x){std::string k="One more LUL and I'm out",r=k;for(int i=0;i++<x;)r.replace(i*10-1,3,'"'+k+'"');return r;}

#include<string> - +16

substitui "LUL" para toda a cadeia N vezes.

Alguém tem melhores golfe?

Experimente online!

Enorme graças ao Kritixi Lithos e hvd , para, uh, ajuda maciça.

Javascript (ES6), 68 bytes

f=(x,y="LUL")=>~x?f(--x,`"One more ${y} and I'm out"`):y.slice(1,-1)

Ligue como f(n).

Você também pode chamá-lo como f(n, "LUL")e substituir LUL por qualquer palavra que desejar.

V , 39 37 bytes

Dois bytes com a ajuda de @KritixiLithos para criar o método de substituição

iOne more LUL and I'm outÀñÓLUL/"."

Experimente online!

Hexdump:

00000000: 694f 6e65 206d 6f72 6520 4c55 4c20 616e  iOne more LUL an
00000010: 6420 4927 6d20 6f75 741b c0f1 d34c 554c  d I'm out....LUL
00000020: 2f22 122e 22                             /".."

Java, 79 77 bytes

Golfe:

String f(int l){return"One more "+(l<1?"LUL":'"'+f(l-1)+'"')+" and I'm out";}

Sem Golfe, com teste:

public class OneMoreLulAndImOut {

  public static void main(String[] args) {
    OneMoreLulAndImOut obj = new OneMoreLulAndImOut();
    for (int i = 0; i < 8; ++i) {
      System.out.println(Integer.toString(i) + ": " + obj.f(i));
    }
  }

  String f(int l) {
    return "One more " + (l < 1 ? "LUL" : '"' + f(l - 1) + '"') + " and I'm out";
  }    
}

Saída do programa:

0: One more LUL and I'm out
1: One more "One more LUL and I'm out" and I'm out
2: One more "One more "One more LUL and I'm out" and I'm out" and I'm out
3: One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out
4: One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
5: One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
6: One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out
7: One more "One more "One more "One more "One more "One more "One more "One more LUL and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out" and I'm out

Python, 79 bytes

Eu só queria fazer uma solução recursiva, mesmo que seja mais longa que outras respostas.

x='"One more %s and I\'m out"'
f=lambda n,s=x:n and f(n-1,s%x)or(s%"LUL")[1:-1]

Experimente online

C #, 125 bytes

n=>{string f="One more {0} and I'm out",s=f;for(int i=0;i++<n;)s=string.Format(s,$"\"{f}\"");return string.Format(s,"LUL");};

C, 140 111 bytes

Minha primeira tentativa de fazer uma pergunta sobre golfe.

#define F printf(
#define P 1&&putchar(34)
int a=0;void q(n){a=a?a:n,n?n>0?F"One more "),n-P:n?n+P,F" and I'm out"):0:F"LUL"),n+a?q(n-1):0;}

Eu vim a perceber que é a saída errada, já que q (0) apenas fornece LUL. A próxima tentativa:

#define o(Q) O(Q,n?34:0);
#define O printf
void q(int n){o("One more %c")n?q(n-1):O("LUL"),o("%c and I’m out")}

Exemplo de programa (testado com o GCC no OSX):

#define o(Q) O(Q,n?34:0);
#define O printf
void q(int n) {o("One more %c")n?q(n-1):O("LUL"),o("%c and I’m out")}

int main() {
    q(0),putchar('\n');
    q(1),putchar('\n');
    q(2),putchar('\n');
    q(3),putchar('\n');

    return 0;
}

Dá saída

One more LUL and I’m out
One more "One more LUL and I’m out" and I’m out
One more "One more "One more LUL and I’m out" and I’m out" and I’m out
One more "One more "One more "One more LUL and I’m out" and I’m out" and I’m out" and I’m out

Mathematica, 69 68 bytes

Agradecemos a Martin Ender por economizar 1 byte difícil de encontrar!

""<>Nest[{q="\"",{"One more ",#," and I'm out"},q}&,"LUL",#+1][[2]]&

Função sem nome, usando um argumento inteiro não negativo e retornando uma string. Nestaplica uma função repetidamente a um argumento inicial; nesse caso, a função é cercar seu argumento pelas palavras e aspas apropriadas. Começamos "LUL"e repetimos os N+1tempos; isso resulta em aspas indesejadas que encerram a frase inteira, mas [[2]]mantém apenas o conteúdo entre elas. No final, ""<>transforma a lista fortemente aninhada resultante em uma única sequência.

Submissão anterior:

""<>Nest[{o,q="\"",#,q,a}&,{o="One more ","LUL",a=" and I'm out"},#]&

C #, 119 85 71 bytes

string m(int n)=>$"One more {(n<1?"LUL":$"\"{m(--n)}\"")} and I'm out";

Guardado 14 bytes graças a @Luc

Retina , 51 bytes

.+
$*00LUL1$&$*
0
"One more 
1
 and I'm out"
^"|"$

Experimente online!

R, 97 bytes

function(n){s="One more LUL and I'm out";while(n){s=sub("LUL",paste0('"',s,'"'),s);n=n-1};cat(s)}

Ungolfed:

function(n) {
  s = "One more LUL and I'm out";
  while(n) {
    s = sub("LUL", paste0('"', s, '"'), s);
    n = n - 1
  };
  cat(s)
}

R, 100 97 92 bytes

"Mais uma função recursiva e estou fora"

f=function(n)paste("One more",`if`(n<1,"LUL",paste0('"',f(n-1),'"')),"and I'm out");cat(f(scan()))

Edit: Acontece que uma abordagem não recursiva é um pouco mais curta:

x="One more ";y=" and I'm out";cat(x,rep(c('"',x),n<-scan()),"LUL",rep(c(y,'"'),n),y,sep="")

Japonês , 39 bytes

Obrigado @ETHproductions por ajudar.

`"O Ú `p°U +"LUL"+` d I'm t"`pU)s1J

Experimente aqui!

Ruby, 51 bytes

Um indexado. Experimente online

->n{['One more ']*n*?"+'LUL'+[" and I'm out"]*n*?"}

PowerShell , 72 67 bytes

"$('"One more '*($c=1+"$args"))LUL$(' and I''m out"'*$c)".Trim('"')

Experimente online!

Lua, 101 bytes

i,f,g='"One more ',' and I\'m out"',io.read()+1 print((i:rep(g).."LUL"..f:rep(g)):sub(2,g*24-(g-2)))

Tentativa óbvia de cordas. Repete "One moree and I'm out"insira exatamente + 1 vezes, com um LULintervalo, e remove a primeira e a última cotação.

Haskell, 51 bytes

Índices de 1.

f 0="LUL";f n="One more \""++f(n-1)++"\" and I'm out"

Ruby, 70 bytes

def l x,t="LUL";x.times{t='"One more %s and I\'m out"'%t};t[1..~1];end

Simplesmente faça um loop pelo valor que é dado, envolvendo a última string por meio de uma string de formato a cada vez.

O índice começa em um.

Empilhados, 54 bytes

('"One more ' ' and I''m out"')*'LUL'join'^.|.$'εrepl

Experimente aqui! Exemplo de uso de "função":

1
('"One more ' ' and I''m out"')*'LUL'join'^.|.$'εrepl
out

Um para 56 bytes:

@n'One more LUL and I''m out':@o['LUL' '"'o'"'+ +repl]n*

Python 3, 68 bytes

def f(a):return('"One more '*a+'LUL'+(' and I%sm out"'%"'")*a)[1:-1]

CJam, 51 49 bytes

" and I'm out\"""\"One more "li1+_@*"LUL"+1>@@*W<

Experimente online

Ungolfed:

" and I'm out\""   "\"One more " // Push two strings to the stack
     l i 1 +                     // Read a number and add 1
     _ @                         // Copy number and rise '"One more ' to the top
     *                           // Multiply '"One more ' by a number
     "LUL" +                     // Add "LUL"
     1>                          // Chop the first quote
     @@                          // Push the result down
     *                           // Multiply ' and I\'m out"' by a number
     W<                          // Chop the last quote

Groovy, 54 bytes

{x->('"One more '*x+'LUL'+' and I\'m out\"'*x)[1..-2]}

Bem simples, o mesmo que a resposta python, mas 2 bytes mais curto. Também é indexado em 1.

Experimente Online!

Mathematica, 65 63 bytes

Nest["\"One more "<>#<>" and I'm out\""&,"LUL",#]~StringTrim~_&

Dois bytes de diferença ao perceber o desafio, permite a indexação 1.

PHP

Olá, eu encontrei até agora duas maneiras de fazer isso.

A maneira de substituição indexada em 1 (121 bytes) .

function f($x){$v='One more LUL and i\'m out';$t=$v;for($i=1;$i<=$x;$t=str_replace('LUL','"'.$t.'"',$v),$i++);return $t;}

O caminho recursivo (86 bytes) .

function r($n){$v=($n==0)?'LUL':'"'.r($n-1).'"';return'One more '.$v.' and i\'m out';}

C ++, 80 + 16 = 96 bytes

std::string L(int c){return"One more "+(c?'"'+L(--c)+'"':"LUL")+" and I'm out";}

#include<string> - +16

Ungolfed:

std::string LUL(int count) {
    return "One more " + (count? ('"' + LUL(--count) + '"') : "LUL") + " and I'm out";
}

Chama a si próprio recursivamente e usa adição de string. Bem direto. Quero dizer, o que mais posso dizer? Mesmo a versão não-gasta é essencialmente uma linha.

Experimente online!

Queijo Cheddar , 71 bytes

i->('One more "'*i).slice(0,-1)+'LUL '+('and I\'m out" '*i).slice(0,-2)

Experimente online!