您应该编写一个程序或函数，该程序或函数接收一个正整数N作为输入并打印出N代码的第一个字符。如果N大于代码长度，则应继续循环输出代码。

禁止以任何方式读取源代码以及从文件，stdio等中进行读取。

例子

（假设您的代码是yourcode）

输入=>输出：

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

澄清度

您的程序应至少为1个字节长。

Python 2，61字节

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

在线尝试！

> <>，49个字节

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

一半的代码将输入从字符串转换为int。如果允许我们使用从STDIN读取的单个char的代码点代替，那么此程序将缩短21个字节：

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

说明

我将使用第二个程序进行解释。

'开始字符串解析，推送每个字符，直到找到结束引号。由于该行的其余部分没有'引号，因此除首字母之外的每个字符都'被压入堆栈。

但是> <>是2D环形语言，因此，在该行结束之后，指令指针会回绕到起点，'再次击中并停止字符串解析。结果是我们将除了引号外的所有必要内容都推送了，即

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

'是ASCII 39，因此我们通过按来推送初始引号3d* = 3*13 = 39。然后，我们将堆栈右移（}）和反转（r），得到：

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

现在我们都准备开始打印。i读取输入的一个字符，但> <>字符基本上是整数。在第一个程序中，i替换为一个循环，该循环将数字字符串从STDIN转换为整数。

然后，我们执行以下循环以打印出前N个字符：

:?!;               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字节

这可以打很多球。

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

代码扩展：

{`"_~"+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";

最后，堆栈上的所有内容都会自动打印到STDOUT

在这里在线尝试

Python 2，117字节

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(")

生活提示：不要执行list(itertools.cycle(x))。由于某种原因，我无法想象为什么，它使解释器崩溃。

JavaScript（ES6），65 52 50 47 41 39

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

使用ES6 repeat()克隆代码，然后切片。使用硬编码的长度。

旧版本（50）：

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

创建一个q带有单个参数的函数。

它对函数文本进行字符串化，如果n大于文本的长度，则以递归方式调用函数。否则，它将返回文本的子字符串。

非ES6版本（65）：

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

J-24个字符

接受一个正整数参数，然后输出一个字符串。

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

J没有任何自引用技巧，因此我们只是采用奎因方式。爆炸解释：

  ],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)&

$J中的二元运算符循环地从其右参数获取项目以适合左侧指定的尺寸。当维是单个数字时，这是一个简单的一维字符列表，因此我们完全按照问题的要求进行操作。

在tryj.tk上尝试一下。

k2-7个字符

{x#$_f}

用英语来说，这是一个带有参数x的函数，其定义为“ xtake string self”。

• 自我（名词_f）是当前执行的最内部功能。这是功能{x#$_f}。
• 字符串（一元$）将其参数转换为字符串。对于函数，它将创建具有函数原始定义的字符串。
• Take（dyadic #）将right-arg中的左参数项从列表中取出。对于字符串，项目是字符，因此这正是我们想要的。

这不会在开源科纳工作，因为它似乎会产生黑洞，它们专吃所有试图使用它们作为参数传递给任何东西。我不确定正确的k3语义，但它们可能不太友善。

在Q中，这是{x#string .z.s}和在k4中{x#2_$.z.s}。我们不得不使用2_k4中的两个初始字符，原因是只有一位母亲会喜欢。

Ruby，66 64 63字节

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

使用避免调用函数的函数要gets长一些（81个字节）：

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

相同的Lambda版本分别为69和65字节：

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个字节

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

为了使它成为合适的包装盒，需要所有空格，包括结尾的包装盒。这是一个纯函数，可以按以下方式使用：

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

哪个打印

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

不幸的是，应用ToString的功能不会产生正是你输入函数的方式，所以我不能缩短这个通过删除空白，缩短#1到#或使用前缀符号函数调用。

MATLAB， 319141个字符

我设法从原始字节压缩了几个字节：

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个字节

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

递归函数，它重复编码n时间，然后对结果进行切片。

Japt，2个字节

îî

在线尝试！

第一种î是采用一个参数并将其重复为length的数字方法n。因为它是第一种方法，所以n成为输入。第二个î被转换为字符串，然后重复。

这会转换为：

n.î("î")->重复"î"直到达到长度n

8字节解决方案

îQi"îQi"

在线尝试！

îQi"îQi" 转换为 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字节

当N = 203时，代码将完全打印自己。

(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)

当N = 50时，代码会自动修剪。

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

当N = 300时，代码会部分重复。

(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);

最后一行的初始1索引（而不是0）是因为Matlab的函数type引入了初始换行，应将其删除。感谢Dennis的修正（最后一个索引）和他的建议（nnz比短numel）。

一元（1-8版本），23855字节

将输入作为1的一元，代码为23855'1'（,[.,]）

Japt，40 28字节

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

第一次写一个quine，所以可以将其缩短很多。另一方面，我很高兴我完全可以使用它。

故意换行，第二行是数据，其余行解包数据，然后重复整个结果字符串，直到其长度等于输入。

多亏了Oliver，减少了12个字节。

在线尝试！

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;}

解释 除了转义字符，其他所有字符也被打印出来。main方法在字符串s内，在main内部建立完整的字符串并打印到stdout

Pyth, 15 13 14 bytes

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

Try it online!

Modified version of the standard Pyth quine.

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))))))))

Set f to the program's code as a tape, but with "k" for itself. Split the tape at character 5, setting variables [p=left q=right]. Weld together the strings p, the original string f, and everything after the 1st character of q. Repeat that string n times, then return the first n characters of it.

Doing this was slightly hampered by Hoon's stdlib not having a format function or find-and-replace...Also, I'm not sure why we need another cast after the scag, since it should keep type information. So it goes.

Jstx, 7 bytes

/£↕:1Fn

Try it online!

Perl 5 with -pa, 48 bytes

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

Try it online!

Gol><>, 12 bytes

"r2ssIFLko|;

Try it online!

How it works

"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 can wrap any number of times, so we don't need to duplicate the whole stack depending on the input.

SmileBASIC, 106 66 bytes

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

KSFTgolf - 4 chars, 6 bytes

KSFTgolf if a language I've been attempting to design for code golf. I've been changing it a lot, so this probably shouldn't actually count.

☃\@2

Stax, 24 bytes

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

Run and debug it

Adaption of the "34bL"34bL quine.

J, 41 Bytes

Now that was a brain teaser!

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

Explanation:

((,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

Examples:

   ((,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

Try it 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);}

Explanation:

Try it 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:

• The var s contains the unformatted source code.
• %s is used to input this String into itself with the s.format(...).
• %c, %1$c and the 34 are used to format the double-quotes.
• s.format(s,34,s) puts it all together.

Challenge part:

• for(int i=n;i>n;i/=176) loops ceil(n/176) times, where 176 is the length of the source code.
• s+=s; exponentially increases the size of the source code String. (ab becomes abab; abab becomes abababab; abababab becomes abababababababab; etc.)
• s.subtring(0,n); takes the first n characters of the String.

><>, 22 19 bytes

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

Try it online!

Takes input through the -v flag.

Stax, 8 bytes

",:m",:m

Run and debug it