Sie sollten ein Programm oder eine Funktion schreiben, die eine positive Ganzzahl Nals Eingabe empfängt und die ersten NZeichen Ihres Codes ausgibt. Wenn Ngrößer als die Länge Ihres Codes ist, sollten Sie Ihren Code weiterhin zyklisch ausgeben.

Das Lesen Ihres Quellcodes in irgendeiner Weise und das Lesen von Dateien, Stdio usw. ist nicht gestattet.

Beispiele

(vorausgesetzt, Ihr Code ist yourcode)

Eingabe => Ausgabe:

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

Klärung

Ihr Programm sollte mindestens 1 Byte lang sein.

Python 2, 61 Bytes

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

Probieren Sie es online!

> <> 49 Bytes

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

Der halbe Code konvertiert die Eingabe von einer Zeichenfolge in eine Ganzzahl. Wenn wir stattdessen den Codepunkt eines einzelnen aus STDIN gelesenen Zeichens verwenden dürfen, wäre dieses Programm mit 21 Byte viel kürzer:

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

Erläuterung

Ich werde das zweite Programm für die Erklärung verwenden.

'Startet das Parsen der Zeichenfolgen und drückt jedes Zeichen, bis ein schließendes Anführungszeichen gefunden wird. Da der Rest der Zeile kein 'Anführungszeichen enthält, wird jedes Zeichen außer dem Anfangsbuchstaben 'auf den Stapel geschoben.

Aber> <> ist eine toroidale 2D-Sprache. Nachdem die Zeile überstrichen ist, springt der Anweisungszeiger zum Anfang zurück und trifft 'erneut und stoppt das Parsen der Zeichenfolgen. Das Ergebnis ist, dass wir bis auf das ursprüngliche Zitat alles Nötige getan haben, nämlich

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

'ist ASCII 39, also drücken wir das anfängliche Anführungszeichen, indem wir drücken 3d* = 3*13 = 39. Wir verschieben dann den Stapel nach rechts (} ) und umgekehrt ( r) und geben:

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

Jetzt können wir mit dem Drucken beginnen. iLiest ein Zeichen der Eingabe ein, aber> <> Zeichen sind im Grunde genommen ganze Zahlen. Im ersten Programm wird das idurch eine Schleife ersetzt, die eine Ziffernfolge von STDIN in eine Ganzzahl umwandelt.

Wir führen dann die folgende Schleife aus, um die ersten N Zeichen auszudrucken:

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

Dies kann viel golfen werden ..

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

Code-Erweiterung :

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

Schließlich wird alles auf dem Stapel automatisch in STDOUT gedruckt

Probieren Sie es hier online aus

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

Lebensprotip: nicht ausführen list(itertools.cycle(x)). Aus irgendeinem Grund kann ich mir nicht vorstellen, warum der Interpreter abstürzt.

JavaScript (ES6), 65 52 50 47 41 39

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

Verwendet ES6 repeat(), um den Code zu klonen, und schneidet dann ab. Verwendet eine fest codierte Länge.

Alte Version (50):

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

Erstellt eine Funktion qunter Verwendung eines einzelnen Parameters.

Sie fasst den Funktionstext zusammen und ruft die Funktion rekursiv auf, wenn sie länger nals der Text ist. Andernfalls wird eine Teilzeichenfolge des Texts zurückgegeben.

Nicht-ES6-Version (65):

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

J - 24 Zeichen

Nimmt ein einzelnes positives ganzzahliges Argument und spuckt eine Zeichenfolge aus.

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

J hat keine Selbstreferenztricks, also machen wir es einfach so. Erklärt durch Explosion:

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

Der dyadische $Operator in J nimmt zyklisch Elemente aus seinem rechten Argument, um sie an die links angegebenen Dimensionen anzupassen. Wenn es sich bei der Dimension um eine einzelne Zahl handelt, handelt es sich um eine einfache 1D-Liste von Zeichen. Wir tun also genau das, was in der Frage gefragt wird.

Probieren Sie es selbst bei tryj.tk .

k2 - 7 Zeichen

{x#$_f}

Im Englischen ist dies eine Funktion mit Argument, xderen Definition " xtake string self" ist.

• Self (das Substantiv _f) ist die innerste derzeit ausgeführte Funktion. Hier ist es die Funktion {x#$_f}.
• String (monadisch)$ ) konvertiert sein Argument in einen String. Im Fall einer Funktion wird eine Zeichenfolge mit der ursprünglichen Definition der Funktion erstellt.
• Take (dyadisch #) nimmt links-arg Elemente aus der Liste in rechts-arg . Im Fall einer Zeichenfolge sind die Elemente Zeichen, und genau das tun wir, was wir wollen.

Das wird nicht in der Open-Source-Version von Kona funktionieren, da es schwarze Löcher zu erzeugen scheint, die alle Versuche aufzehren, sie als Argumente für irgendetwas zu verwenden. Ich bin mir nicht sicher, ob die K3-Semantik korrekt ist, aber wahrscheinlich sind sie nicht besonders nett.

In Q ist dies {x#string .z.s}und in k4 {x#2_$.z.s}. Wir müssen verwenden 2_, um zwei Anfangsbuchstaben in k4 abzulegen, aus Gründen, die nur eine Mutter lieben kann.

Ruby, 66 64 63 Bytes

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

Die Verwendung einer Funktion zur Vermeidung von Aufrufen getsist ebenfalls etwas länger (81 Byte):

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

Lambda-Versionen desselben sind 69 und 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]] & 

Alle Leerzeichen sind erforderlich, um dies zu einem korrekten Quine zu machen, einschließlich des nachfolgenden. Dies ist eine reine Funktion, die Sie wie folgt verwenden können:

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

welche druckt

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

Leider ToStringergibt die Anwendung auf eine Funktion nicht genau die Art und Weise, wie Sie die Funktion eingegeben haben. Daher kann ich diese nicht durch Entfernen von Leerzeichen, Verkürzen #1auf #oder Verwenden der Präfixnotation für Funktionsaufrufe verkürzen .

MATLAB, 319 141 Zeichen

Ich habe es geschafft, ein paar Bytes aus dem Original herauszuholen:

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)

Rekursive Funktion, die die Codezeiten wiederholt nund dann das Ergebnis aufteilt.

Japt , 2 Bytes

îî

Probieren Sie es online!

Die erste îMethode ist eine Zahlenmethode, die einen Parameter annimmt und auf Länge wiederholt n. Weil es die erste Methode ist, nwird die Eingabe. Die Sekunde îwird in eine Zeichenfolge geworfen und wiederholt.

Dies überträgt sich auf:

n.î("î")-> Wiederholen, "î"bis die Länge erreicht istn

8-Byte-Lösung

îQi"îQi"

Probieren Sie es online!

îQi"îQi" transpiles zu 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

Bei N = 203 wird der Code vollständig gedruckt.

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

Wenn N = 50 ist, schneidet sich der Code von selbst.

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

Wenn N = 300 ist, wiederholt sich der Code teilweise.

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

Der anfängliche 1Index (anstelle von 0) in der letzten Zeile ist, weil die Matlab-Funktion typeeinen anfänglichen Zeilenvorschub einführt, der entfernt werden sollte. Vielen Dank an Dennis für seine Korrektur (letzter Index) und für seinen Vorschlag ( nnzkürzer als numel).

Unary (1-8 Version) , 23855 Bytes

Nimmt Eingaben als unär von '1' an und der Code ist 23855 '1' ( ,[.,])

Japt , 40 28 Bytes

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

Schreiben Sie zum ersten Mal ein Quine, so kann dies wahrscheinlich ziemlich viel verkürzt werden. Andererseits bin ich ziemlich froh, dass ich es überhaupt zum Laufen gebracht habe.

Bei der zweiten Zeile handelt es sich absichtlich um Daten. Der Rest entpackt die Daten und wiederholt die gesamte resultierende Zeichenfolge, bis die Länge der Eingabe erreicht ist.

Dank Oliver satte 12 Bytes eingespart .

Probieren Sie es 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;}

Erklärung Außer dem Escape-Zeichen werden alle anderen Zeichen ausgedruckt. Die Hauptmethode befindet sich in der Zeichenfolge s, und in main wird die vollständige Zeichenfolge erstellt und nach stdout gedruckt

Pyth, 15 13 14 Bytes

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

Probieren Sie es online!

Modifizierte Version des 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))))))))

Stellen Sie fden Programmcode als Band ein, aber mit "k" für sich. Teilen Sie das Band bei Zeichen 5 und stellen Sie die Variablen ein [p=left q=right]. Schweißen Sie die Saiten p, die ursprüngliche Saite fund alles nach dem ersten Zeichen von zusammen q. Wiederholen Sie diese Zeichenfolge n, und geben Sie dann die ersten nZeichen davon zurück.

Dies wurde ein wenig behindert durch Hoons stdlib ohne Formatierungsfunktion oder Suchen und Ersetzen ... Ich bin mir auch nicht sicher, warum wir nach dem eine weitere Besetzung benötigen scag, da sie die Typinformationen behalten sollte. So geht es.

Jstx , 7 Bytes

/£↕:1Fn

Probieren Sie es online!

Perl 5 mit -pa48 Bytes

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

Probieren Sie es online!

Gol> <> , 12 Bytes

"r2ssIFLko|;

Probieren Sie es online!

Wie es funktioniert

"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 kann beliebig oft umbrochen werden, sodass wir nicht den gesamten Stapel abhängig von der Eingabe duplizieren müssen.

SmileBASIC, 106 66 Bytes

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

KSFTgolf - 4 Zeichen, 6 Bytes

KSFTgolf ist eine Sprache, die ich für Code Golf entworfen habe. Ich habe es sehr verändert, daher sollte dies wahrscheinlich nicht wirklich zählen.

☃\@2

Stax , 24 Bytes

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

Führen Sie es aus und debuggen Sie es

Anpassung der "34bL"34bLQuine.

J, 41 Bytes

Das war ein Rätsel!

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

Erläuterung:

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

Beispiele:

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

Probieren Sie es 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);}

Erläuterung:

Probieren Sie es online aus.

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

• Das var s enthält den unformatierten Quellcode.
• %s wird verwendet, um diesen String in sich selbst mit dem einzugeben s.format(...) .
• %c, %1$c Und die 34werden verwendet , um die doppelten Anführungszeichen zu formatieren.
• s.format(s,34,s) setzt alles zusammen.

Herausforderungsteil:

• for(int i=n;i>n;i/=176) Schleifen ceil(n/176) mal, wo 176ist die Länge des Quellcodes.
• s+=s;Erhöht die Größe des Quellcodes String exponentiell. ( abwird abab; ababwird abababab;abababab wird abababababababab; etc.)
• s.subtring(0,n);Nimmt die ersten nZeichen des Strings.

> <> , 22 bis 19 Bytes

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

Probieren Sie es online!

Übernimmt die Eingabe durch die -vFlagge.

Stax , 8 Bytes

",:m",:m

Führen Sie es aus und debuggen Sie es