Você deve escrever um programa ou função que receba um número inteiro positivo Ncomo entrada e imprima os primeiros Ncaracteres do seu código. Se Nfor maior que o comprimento do seu código, você deve continuar produzindo seu código ciclicamente.

A leitura do código-fonte de qualquer forma e a leitura do arquivo, do stdio etc. não são permitidas.

Exemplos

(supondo que seu código seja yourcode)

Entrada => Saída:

5=> yourc
10=> yourcodeyo
22=>yourcodeyourcodeyour

Esclarecimento

Seu programa deve ter pelo menos 1 byte de comprimento.

Python 2, 61 bytes

def f(n):a='def f(n):a=%r;print(a%%a*n)[:n]';print(a%a*n)[:n]

Experimente online!

> <> , 49 bytes

'3d*}r0ff+0i:&0(?.~~a*&"0"-+60.&~:?!;1-&:o}&" "0.

Metade do código está convertendo a entrada de uma string para um int. Se for permitido usar o ponto de código de uma única leitura de char do STDIN, esse programa será muito menor em 21 bytes:

'3d*}ri:?!;1-&:o}&60.

Explicação

Vou usar o segundo programa para a explicação.

'inicia a análise de string, pressionando cada caractere até que uma cotação de fechamento seja encontrada. Como o restante da linha não tem 'aspas, todos os caracteres, exceto o inicial, 'são empurrados para a pilha.

Mas> <> é uma linguagem 2D toroidal; portanto, depois que a linha termina, o ponteiro de instruções volta ao início, pressionando 'novamente e para a análise de cordas. O resultado é que colocamos tudo o que é necessário, exceto a cotação inicial, a saber

3d*}ri:0=?;1-&:o}&60.

'é ASCII 39, então pressionamos a cotação inicial pressionando 3d* = 3*13 = 39. Em seguida, deslocamos a pilha para a direita ( }) e invertemos ( r), dando:

.06&}o:&-1;?=0:ir}*d3'

Agora estamos prontos para começar a imprimir. ilê um caractere de entrada, mas> <> chars são basicamente números inteiros. No primeiro programa, o ié substituído por um loop que converte uma sequência de dígitos de STDIN em um número inteiro.

Em seguida, executamos o seguinte loop para imprimir os primeiros N caracteres:

:?!;               If the top of the stack (N) is 0, then terminate
                   Otherwise...
1-                 Subtract 1 from N
&                  Move N to the register temporarily
:o                 Output the next char in the program
}                  Shift the stack right
&                  Put N back on the stack
60.                Repeat loop by jumping back to the first :

CJam, 34 17 16 bytes

Isso pode ser muito jogado ..

{`"_~"+ri_@*<}_~

Expansão do código :

{`"_~"+ri_@*<}_~
{            }_~      "Put this code block on stack, take a copy and execute the copy";
 `                    "When executed, this block will the top element on stack to a string";
  "_~"                "Then put this string on stack";
      +               "Concat it to the the previous string on stack which ` created";
       ri             "Read an integer from STDIN";
         _@           "Copy the integer and put the concatinated string on top of stack";
           *          "Repeat the string input number of times";
            <         "Take the first input number of characters from the repeated string";

Finalmente, qualquer coisa na pilha é impressa no STDOUT automaticamente

Experimente online aqui

Python 2, 117 bytes

b=input();a=lambda x:(b*(2*(x+chr(34))+')'))[:b];print a("b=input();a=lambda x:(b*(2*(x+chr(34))+')'))[:b];print a(")

Protip de vida: não execute list(itertools.cycle(x)). Por alguma razão, não consigo imaginar o porquê, trava o intérprete.

JavaScript (ES6), 65 52 50 47 41 39

q=n=>('q='+q).repeat(n/39+1).slice(0,n)

Usa o ES6 repeat()para clonar o código e, em seguida, corta. Usa um comprimento codificado.

Versão antiga (50):

q=n=>n>(l=(t='q='+q).length)?t+q(n-l):t.slice(0,n)

Cria uma função q, usando um único parâmetro.

Ele especifica o texto da função e chama recursivamente a função se nfor maior que o comprimento do texto. Caso contrário, ele retornará uma substring do texto.

Versão não ES6 (65):

function q(n){return t=q+'',l=t.length,n>l?t+q(n-l):t.slice(0,n)}

J - 24 car

Pega um único argumento inteiro positivo e cospe uma string.

($],quote)&'($],quote)&'

J não tem nenhum truque de auto-referência, então fazemos da maneira certa. Explicado por explosão:

  ],quote                 NB. right arg prepended to quotation of right arg (quine)
 $                        NB. cyclically take left-arg characters from that
(        )&'($],quote)&'  NB. preload right arg with  ($],quote)&

O $operador diádico em J usa ciclicamente itens do seu argumento da direita para ajustar as dimensões especificadas à esquerda. Quando a dimensão é um único número, esta é uma lista 1D simples de caracteres, por isso fazemos exatamente o que a pergunta faz.

Tente você mesmo no tryj.tk .

k2 - 7 car

{x#$_f}

Em inglês, esta é uma função com argumento xcuja definição é " xpegar a própria corda".

• Self (o substantivo _f) é a função atualmente em execução mais interna. Aqui está a função {x#$_f}.
• String (monádica $) converte seu argumento em uma string. No caso de uma função, ele cria uma string com a definição original da função.
• Take (diádico #) leva os itens do lado esquerdo da lista no lado direito . No caso de uma string, os itens são caracteres, portanto, isso está fazendo exatamente o que queremos.

Isso não funcionará no Kona de código aberto, porque parece criar buracos negros que consomem todas as tentativas de usá-los como argumentos para qualquer coisa. Não tenho certeza da semântica adequada do k3, mas elas provavelmente não são muito mais gentis.

Em Q, este é {x#string .z.s}e em k4 {x#2_$.z.s}. Temos que usar 2_para soltar dois caracteres iniciais no k4, por razões que apenas uma mãe poderia amar.

Ruby, 66 64 63 bytes

eval s=%q(puts"eval s=%q(#{s})".chars.cycle.take(gets.to_i)*'')

O mesmo usando uma função para evitar chamadas getsé um pouco mais longo (81 bytes):

def f(i);eval s=%q(puts"def f(i);eval s=%q(#{s});end".chars.cycle.take(i)*'');end

As versões lambda dos mesmos são 69 e 65 bytes:

l=->i{eval s=%q(puts"l=->i{eval s=%q(#{s})}".chars.cycle.take(i)*'')}
->i{eval s=%q(puts"->i{eval s=%q(#{s})}".chars.cycle.take(i)*'')}

Mathematica, 65 bytes

Print[StringTake[StringJoin @@ Table[ToString[#0], {#1}], #1]] & 

Todos os espaços são necessários para torná-lo uma solução adequada, incluindo a traseira. Esta é uma função pura, que você pode usar da seguinte maneira:

Print[StringTake[StringJoin @@ Table[ToString[#0], {#1}], #1]] & [75]

que imprime

Print[StringTake[StringJoin @@ Table[ToString[#0], {#1}], #1]] & Print[Stri

Infelizmente, a aplicação ToStringde uma função não produz exatamente do jeito que você inseriu a função, por isso não pode encurtar este removendo espaços em branco, encurtando #1a #ou usando a notação de prefixo para chamadas de função.

MATLAB, 319144 caracteres

Consegui espremer alguns bytes do original:

function d=g(n);d='gvodujpo!e>h)o*<e>(<e>\e)2;2:*.2-e-e)2:;foe*.2^<e>e)2,npe)1;o.2-252**<';d=[d(1:19)-1,d,d(19:end)-1];d=d(1+mod(0:n-1,141));

JavaScript, 34 bytes

f=n=>n&&('f='+f+f(n-1)).slice(0,n)

Função recursiva que repete os ntempos do código e, em seguida, corta o resultado.

Japonês , 2 bytes

îî

Experimente online!

O primeiro îé um método numérico que pega um parâmetro e o repete no comprimento n. Por ser o primeiro método, ntorna-se a entrada. O segundo îé moldado em uma corda e repetido.

Isso transpila para:

n.î("î")-> Repita "î"até atingir o comprimenton

Solução de 8 bytes

îQi"îQi"

Experimente online!

îQi"îQi" transpiles para n.î(Qi"îQi")

n.î(Qi"îQi")
      "îQi"    // String "îQi"          -> îQi
    Qi         // Insert "              -> îQi"
n.î            // Repeated to length n  -> îQi"îQi"îQi"  (n=12)

R, 203 bytes

Quando N = 203, o código é totalmente impresso.

(f <- function(N){
str <- paste0("(f <- function(N)", paste0(as.character(body(f)), collapse = "\n"), ")}(", N, ")")
cat(rep(str, floor(N/nchar(str))), sep = "")
cat(substr(str, 1, N%%nchar(str)))})(203)

Quando N = 50, o código se apara.

(f <- function(N){
str <- paste0("(f <- function(N

Quando N = 300, o código se repete parcialmente.

(f <- function(N){
str <- paste0("(f <- function(N)", paste0(as.character(body(f)), collapse = "\n"), ")}(", N, ")")
cat(rep(str, floor(N/nchar(str))), sep = "")
cat(substr(str, 1, N%%nchar(str))))}(300)(f <- function(N){
str <- paste0("(f <- function(N)", paste0(as.character(body(f)), collapse = "\

Matlab (57)

function s=f(n);s=evalc('type f');s=s(mod(1:n,nnz(s))+1);

O 1índice inicial (em vez de 0) na última linha é porque a função do Matlab typeintroduz um avanço de linha inicial, que deve ser removido. Agradecemos a Dennis por sua correção (último índice) e por sua sugestão ( nnzmenor que numel).

Unário (versão 1-8) , 23855 bytes

Assume a entrada como unário de '1's e o código é 23855' 1's ( ,[.,])

Japonês , 40 28 bytes

"îR+Q+V+Q+R+V"
îR+Q+V+Q+R+V

Primeira vez que escrevemos um quine, então isso provavelmente pode ser bastante reduzido. Por outro lado, estou muito feliz por ter conseguido funcionar.

Levando a nova linha intencional, a segunda linha é data e o restante desembrulha os dados, depois repete toda a sequência resultante até atingir o comprimento igual à entrada.

Raspou uns impressionantes 12 bytes graças a Oliver .

Experimente online!

C ++, 305

int L=305;string s="int main(){string t=\"string s=\";int n;cin>>n;t+=s;t+=\"\";\";t+=s;while(n>0){if(n>L){cout<<t;n-=L;}else{cout<<t.substr(0,n);}return 0;}";
int main(){string t="int L=305;string s=\"";int n;cin>>n;t+=s;t+="\";";t+=s;while(n>0){if(n>L){cout<<t;}else{cout<<t.substr(0,n);}n-=L;}return 0;}

Explicação Além do caractere de escape, todos os outros caracteres são impressos. O método principal está dentro da string se, dentro da main, a string completa é criada e impressa em stdout

Pitão, 15 13 14 bytes

<jN*Q]"<jN*Q]"

Experimente online!

Versão modificada do Pyth quine padrão .

Hoon , 185 bytes

=/(f "=/(f k |=(n=@ =+((trim 5 f) `tape`(scag n `tape`(zing (reap n :(weld p <f> (slag 1 q))))))))" |=(n=@ =+((trim 5 f) `tape`(scag n `tape`(zing (reap n :(weld p <f> (slag 1 q))))))))

Defina fo código do programa como uma fita, mas com "k" para si mesmo. Divida a fita no caractere 5, configurando variáveis [p=left q=right]. Solde as cordas p, a corda original fe tudo depois do primeiro caractere de q. Repita esse ntempo da sequência e retorne os primeiros ncaracteres.

Fazer isso foi um pouco dificultado pelo fato de o stdlib de Hoon não ter uma função de formato ou encontrar e substituir ... Além disso, não sei por que precisamos de outra conversão após a scag, pois ela deve manter as informações de tipo. Assim vai.

Jstx , 7 bytes

/£↕:1Fn

Experimente online!

Perl 5 com -pa, 48 bytes

$_=q{$_=substr"\$_=q{$_}:eval"x"@F",0,"@F"};eval

Experimente online!

Gol> <> , 12 bytes

"r2ssIFLko|;

Experimente online!

Como funciona

"r2ssIFLko|;

"..."   Push the chars in reverse order
r2ss    Reverse the stack, then push `"`
IF...|  Input n, and repeat the following n times...
  L     Push the loop counter (0 to n-1)
   k    Pop x and copy x-th from the top
    o   Pop and print as char
;       Halt

k pode quebrar várias vezes, portanto, não precisamos duplicar a pilha inteira, dependendo da entrada.

SmileBASIC, 106 66 bytes

INPUT N?MID$(("+CHR$(34))*3,23,N)INPUT N?MID$(("+CHR$(34))*N,23,N)

KSFTgolf - 4 caracteres, 6 bytes

KSFTgolf se um idioma que eu estou tentando criar para o código de golfe. Eu tenho mudado bastante, então isso provavelmente não deve contar.

☃\@2

Stax , 24 bytes

"34bLNca*]$("34bLNca*]$(

Execute e depure

Adaptação do "34bL"34bLquine.

J, 41 bytes

Agora isso foi um quebra-cabeças!

((,quote,')$~'"_)'((,quote,'')$~''"_)')$~

Explicação:

((,quote,')$~'"_)'((,quote,'')$~''"_)')$~  | Expression taking 1 argument
                                       $~  | Reshape left argument to fit right, taking cyclically.
(                                     )    | One large expression that evaluates to a string
                 '((,quote,'')$~''"_)'     | String literal containing the code to the left of it
 (,quote,'$)~'"_)                          | A 4-Hook:
         '$)~'"_                           | The string '$)~'
   quote,                                  | Appended to the quoted version of the string
  ,                                        | Appended to the raw string

Exemplos:

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 10
((,quote,'

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 20
((,quote,')$~'"_)'((

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 30
((,quote,')$~'"_)'((,quote,'')

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 41
((,quote,')$~'"_)'((,quote,'')$~''"_)')$~

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 50
((,quote,')$~'"_)'((,quote,'')$~''"_)')$~((,quote,

Ly , 28 bytes

"r(34)<ns>l[p&:l,s]p<[>o<,]p

Experimente online!

Java 10, 193 176 bytes

n->{var s="n->{var s=%c%s%1$c;s=s.format(s,34,s);for(int i=n;i>0;i/=176)s+=s;return s.substring(0,n);}";s=s.format(s,34,s);for(int i=n;i>0;i/=176)s+=s;return s.substring(0,n);}

Explicação:

Experimente online.

n->{                       // Method with integer parameter and String return-type
  var s="n->{var s=%c%s%1$c;s=s.format(s,34,s);for(int i=n;i>0;i/=176)s+=s;return s.substring(0,n);}";
                           //  Unformatted source code
  s=s.format(s,34,s);      //  Create the formatted quine
  for(int i=n;i>0;         //  Loop `i` as long as it's not 0
      ;                    //    After every iteration:
       i/=176)             //     int-divide `i` by the hardcoded length of the source code
    s+=s;                  //   Exponentially enlarge the source code
  return s.substring(0,n);}//  Return the first `n` characters of the source code

quine -part:

• O var scontém o código fonte não formatado.
• %sé usado para inserir esta String em si mesma com o s.format(...).
• %c, %1$cE 34são usados para formatar as aspas.
• s.format(s,34,s) coloca tudo junto.

Parte do desafio:

• for(int i=n;i>n;i/=176)loops ceil(n/176)vezes, onde 176é o comprimento do código fonte.
• s+=s;aumenta exponencialmente o tamanho do código-fonte String. ( abtorna- se ; torna- se abab; ababtorna- se ; etc.)abababababababababababababababab
• s.subtring(0,n);pega os primeiros ncaracteres da String.

> <> , 22 19 bytes

'rd3*$:?!;1-$:o}50.

Experimente online!

Recebe a entrada através da -vbandeira.

Stax , 8 bytes

",:m",:m

Execute e depure