Stampa i primi N caratteri del tuo codice

21

È necessario scrivere un programma o una funzione che riceve un numero intero positivo Ncome input e stampa i primi Ncaratteri del codice. Se Nè maggiore della lunghezza del codice, è necessario continuare a generare il codice ciclicamente.

La lettura del codice sorgente in qualsiasi modo e la lettura da file, stdio, ecc. Non sono consentite.

Esempi

(supponendo che il tuo codice sia yourcode)

Input => Output:

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

Una precisazione

Il programma dovrebbe essere lungo almeno 1 byte.

code-golf  quine 
— randomra
fonte
15
Congratulazioni per aver pubblicato la sfida del 2000 ° codice golf! :)
— Martin Ender,
3
— Luis Mendo,
1
@ MartinBüttner In realtà, ci sono oltre 300 domande cancellate [code-golf]. Ma abbastanza vicino;)
— Maniglia della porta
11
@ MartinBüttner Grazie. Solo 48 per andare fino a un numero rotondo!
— randomra,
5
Forse è ora che tu accerti esplicitamente che i programmi vuoti non sono validi?
— Martin Ender,

Risposte:

10

> <> , 49 byte

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

La metà del codice sta convertendo l'input da una stringa a un int. Se invece ci fosse permesso usare il punto di codice di un singolo carattere letto da STDIN, allora questo programma sarebbe molto più breve a 21 byte:

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

Spiegazione

Userò il secondo programma per la spiegazione.

'avvia l'analisi delle stringhe, spingendo ogni carattere fino a quando non viene trovata una citazione di chiusura. Poiché il resto della riga non ha 'virgolette, ogni carattere tranne l'iniziale 'viene inserito nello stack.

Ma> <> è un linguaggio toroidale 2D, quindi dopo che la linea è finita il puntatore dell'istruzione torna all'inizio, colpendo di 'nuovo e interrompendo l'analisi delle stringhe. Il risultato è che abbiamo spinto tutto il necessario tranne la citazione iniziale, vale a dire

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

'è ASCII 39, quindi spingiamo la citazione iniziale premendo 3d* = 3*13 = 39. Spostiamo quindi lo stack a destra ( }) e reverse ( r), dando:

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

Ora siamo pronti per iniziare a stampare. ilegge un carattere di input, ma i caratteri> <> sono sostanzialmente numeri interi. Nel primo programma, il iviene sostituito con un ciclo che converte una stringa di cifre da STDIN in un numero intero.

Quindi eseguiamo il seguente ciclo per stampare i primi N caratteri:

:?!;               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 :
— SP3000
fonte
9

CJam, 34 17 16 byte

Questo può essere giocato molto a golf ..

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

Espansione del codice :

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

Infine, qualsiasi cosa in pila viene stampata automaticamente su STDOUT

Provalo online qui

— Optimizer
fonte
5

Python 2, 117 byte

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

Salvagente: non eseguire list(itertools.cycle(x)). Per qualche ragione, non riesco a immaginare perché, si blocca l'interprete.

— QuadmasterXLII
fonte
1
itertools.cycle()è un generatore infinito, quindi a meno che il tuo computer non abbia memoria infinita avrai problemi :)
— Sp3000,
5

JavaScript (ES6), 65 52 50 47 41 39

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

Utilizza ES6 repeat()per clonare il codice, quindi ridimensiona. Utilizza una lunghezza codificata.

Vecchia versione (50):

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

Crea una funzione q, prendendo un singolo parametro.

Stringe il testo della funzione e chiama ricorsivamente la funzione se nè maggiore della lunghezza del testo. Altrimenti, restituisce una sottostringa del testo.

Versione non ES6 (65):

function q(n){return t=q+'',l=t.length,n>l?t+q(n-l):t.slice(0,n)}
— Scimonster
fonte
1
usare la ricorsione, anziché ES6 .repeat, per i requisiti ciclici era semplicemente geniale.
— Jacob,
1
In realtà, sembra che l'utilizzo repeat()mi abbia permesso di ridurlo in blocco, quindi l'ho usato invece.
— Scimonster,
Non l'ho visto. Comunque - questa è una risposta molto bella
— Jacob
perché il /39+1? perché non lasciare una stringa abbastanza lunga?
— l4m2
1
q=n=>('q='+q).repeat(n).slice(0,n)funziona bene su Firefox
— l4m2
5

J - 24 caratteri

Accetta un singolo argomento intero positivo e sputa una stringa.

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

J non ha trucchi di autoreferenziazione, quindi lo facciamo solo nel modo più semplice. Spiegato dall'esplosione:

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

L' $operatore diadico in J prende ciclicamente gli oggetti dal suo argomento destro per adattarsi alle dimensioni specificate a sinistra. Quando la dimensione è un singolo numero, questo è un semplice elenco 1D di caratteri, quindi facciamo esattamente ciò che la domanda pone.

Provare per credere a tryj.tk .

— algorithmshark
fonte
Qual è lo scopo generale del quoteverbo?
— randomra,
@randomra La sua definizione nella libreria standard è ''''&,@(,&'''')@(#~ >:@(=&'''')), o in inglese, "raddoppia qualsiasi 'carattere, quindi aggiungine uno all'inizio e alla fine". J usa letterali di stringhe simili ad Ada in modo da sfuggire alla stringa.
— algoritmo
4

k2 - 7 caratteri

{x#$_f}

In inglese, questa è una funzione con argomento la xcui definizione è " xprendere la stringa self".

  • Il sé (il nome _f) è la funzione più interna attualmente in esecuzione. Ecco la funzione {x#$_f}.
  • String (monadic $) converte il suo argomento in una stringa. Nel caso di una funzione, crea una stringa con la definizione originale della funzione.
  • Take (diadico #) prende gli elementi left-arg dalla lista in right-arg . Nel caso di una stringa, gli elementi sono caratteri, quindi questo sta facendo esattamente quello che vogliamo.

Questo non funzionerà nella Kona open source, perché sembra creare buchi neri che divorano tutti i tentativi di usarli come argomenti per qualsiasi cosa. Non sono sicuro della corretta semantica k3 ma probabilmente non sono molto più gentili.

In Q, questo è {x#string .z.s}e in k4 {x#2_$.z.s}. Dobbiamo usare 2_per eliminare due caratteri iniziali in k4, per motivi che solo una madre potrebbe amare.

— algorithmshark
fonte
3

Rubino, 66 64 63 byte

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

Lo stesso utilizzo di una funzione per evitare di chiamare getsè un po 'più lungo (81 byte):

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

Le versioni Lambda dello stesso sono 69 e 65 byte:

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)*'')}
— Denis de Bernardy
fonte
1
.cycleè pulito, devo ricordarlo. :) Probabilmente si può accorciare .joina*'' .
— Martin Ender,
Puoi salvare alcuni caratteri usando al String#formatposto dell'interpolazione:eval s="$><<('eval s=%p'%s).chars.cycle.take(gets.to_i)*''"
— Ventero
3

Mathematica, 65 byte

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

Tutti gli spazi sono necessari per rendere questo un vero quine, compreso quello finale. Questa è una funzione pura, che puoi usare come segue:

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

quale stampa

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

Purtroppo, l'applicazione ToStringa una funzione non produce esattamente il modo in cui hai inserito la funzione, quindi non posso accorciare questo rimuovendo gli spazi bianchi, accorciando #1al #o utilizzando la notazione prefisso per le chiamate di funzione.

— Martin Ender
fonte
"accorciare #a #1"?
— undergroundmonorail,
@undergroundmonorail viceversa, grazie
— Martin Ender il
3

MATLAB, 319 141 caratteri

Sono riuscito a spremere alcuni byte da quello originale:

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));
— knedlsepp
fonte
Bella risposta...! Non ho idea di come funzioni :-)
— Luis Mendo il
3

JavaScript, 34 byte

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

Funzione ricorsiva che ripete i ntempi del codice , quindi suddivide il risultato.

— Yair Rand
fonte
3

Japt , 2 byte

îî

Provalo online!

Il primo îè un metodo numerico che accetta un parametro e lo ripete per la lunghezza n. Perché è il primo metodo, ndiventa l'input. Il secondo îviene lanciato in una stringa e viene ripetuto.

Questo traspila a:

n.î("î")-> Ripetere "î"fino a raggiungere la lunghezzan

Soluzione a 8 byte

îQi"îQi"

Provalo online!

îQi"îQi" traspila a n.î(Qi"îQi")

n.î(Qi"îQi")
      "îQi"    // String "îQi"          -> îQi
    Qi         // Insert "              -> îQi"
n.î            // Repeated to length n  -> îQi"îQi"îQi"  (n=12)
— Oliver
fonte
1
Bello nella sua semplicità!
— Shaggy,
2

R, 203 byte

Quando N = 203, il codice si stampa completamente da solo.

(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, il codice si ritaglia automaticamente.

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

Quando N = 300, il codice si ripete parzialmente.

(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 = "\
— Kun Ren
fonte
Prova questo:(f=function(N){s=paste0("(f=",paste0(capture.output(f),collapse=""),")");cat(rep(s,N%/%nchar(s)),substr(s,1,N%%nchar(s)),sep="")})(200)
— Thomas,
2

Matlab (57)

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

L' 1indice iniziale (anziché 0) nell'ultima riga è perché la funzione di Matlab typeintroduce un avanzamento riga iniziale, che dovrebbe essere rimosso. Grazie a Dennis per la sua correzione (ultimo indice) e per il suo suggerimento ( nnzpiù breve di numel).

— Luis Mendo
fonte
Temo che questo non faccia ciò che mi aspetterei (f (4) restituisce "divertimento"), la buona notizia è che puoi risolverlo salvando 2 caratteri. (rimuovere il -1). - Penso che si può anche rimuovere il secondo a capo e di swap fuori numelper nnz.
— Dennis Jaheruddin,
@Dennis Grazie per queste due idee! Ho modificato per incorporare entrambi
— Luis Mendo il
Hm, non voglio essere un buzzkill, ma la type fparte non si scontra con il requisito La lettura del codice sorgente in alcun modo e la lettura da file, stdio, ecc. Non sono vietate ?
— Knedlsepp,
@knedlsepp Penso che tu abbia ragione. Anch'io avevo quel sospetto. typeprobabilmente accede al disco rigido. Pensi che dovrei rimuovere la risposta?
— Luis Mendo,
@LuisMendo: non penso che a nessuno importi davvero. :-) Volevo solo provare questo problema ieri, dato che non avevo già prodotto un quine simile a questo alcune volte prima. E ovviamente ho dovuto verificare se esisteva già una soluzione Matlab. :-) Alla fine questo mi ha dato abbastanza motivazione per scavare abbastanza in profondità in questo da produrre finalmente una soluzione. (Ho rubato la tua modidea -indexing tra l'altro.)
— knedlsepp
2

Unario (versione 1-8) , 23855 byte

Prende l'input come unario di '1's, e il codice è 23855' 1's ( ,[.,])

— l4m2
fonte
1
Che brainfuck traduce anche questo?
— DJMcMayhem
@DJMcMayhem È un gatto
— l4m2
Ora trova una lingua che ha un input unario e qualche programma di 1 carattere fa cat
— l4m2
2

Japt , 40 28 byte


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

La prima volta che scrivo un quine, quindi questo può probabilmente essere abbreviato un po '. D'altra parte, sono abbastanza felice di averlo fatto funzionare.

Inizialmente intenzionalmente newline, la seconda riga sono i dati e il resto srotola i dati, quindi ripete l'intera stringa risultante fino a raggiungere una lunghezza pari all'input.

Rasato ben 12 byte grazie a Oliver .

Provalo online!

— lendine
fonte
Bello :) puoi sostituirlo tTUcon ¯Ue puoi usarlo îal posto di pspostandolo in avanti: provalo online
— Oliver
A pensarci bene, non penso che sia necessario tagliarlo affatto. îR+Q+V+Q+R+Vdovrebbe funzionare bene.
— Oliver,
@Oliver Oh, è intelligente, non lo sapevo î, è molto utile. Molte grazie!
— Nit
Io non sono troppo buono con quines sia, ma io credo che questo dovrebbe funzionare per 24 byte.
— Shaggy,
1

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

Spiegazione Oltre al carattere di escape, tutti gli altri personaggi vengono stampati. Il metodo principale è all'interno della stringa se all'interno della stringa intera viene costruita e stampata su stdout

— bacchusbeale
fonte
1

Pyth, 15 13 14 byte

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

Provalo online!

Versione modificata dello standard Pyth quine .

— hakr14
fonte
@ l4m2 In che modo? Per favore, spiega, non vedo nulla di sbagliato ...
— hakr14
29 dovrebbe essere <jN*Q]"<jN*Q]<jN*Q]"<jN*Q]<jNsbagliato?
— l4m2
@ l4m2 Ah, hai ragione. L'ho risolto.
— hakr14
<jN*Q]"<jN*Q]"sembra funzionare?
— l4m2
Sì, l'ho capito. Grazie per l'aiuto a proposito!
— hakr14
1

Hoon , 185 byte

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

Impostato fsul codice del programma come nastro, ma con "k" per se stesso. Dividi il nastro sul carattere 5, impostando le variabili [p=left q=right]. Salda insieme le stringhe p, la stringa originale fe tutto ciò che segue il 1 ° carattere di q. Ripeti i ntempi di quella stringa , quindi restituisci i primi ncaratteri.

In questo modo è stato leggermente ostacolato dal fatto che Hoon stdlib non avesse una funzione di formattazione o trova e sostituisci ... Inoltre, non sono sicuro del motivo per cui abbiamo bisogno di un altro cast dopo il scag, poiché dovrebbe mantenere le informazioni sul tipo. Così è andata.

— RenderSettings
fonte
1

Gol> <> , 12 byte

"r2ssIFLko|;

Provalo online!

Come funziona

"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 può avvolgere un numero qualsiasi di volte, quindi non è necessario duplicare l'intero stack a seconda dell'input.

— bubbler
fonte
1

SmileBASIC, 106 66 byte

INPUT N?MID$(("+CHR$(34))*3,23,N)INPUT N?MID$(("+CHR$(34))*N,23,N)
— 12Me21
fonte
0

KSFTgolf - 4 caratteri, 6 byte

KSFTgolf se una lingua che stavo cercando di progettare per il golf del codice. L'ho cambiato molto, quindi probabilmente questo non dovrebbe davvero contare.

☃\@2
— KSFT
fonte
Che lingua è questa ? Qualche link? Spec? spiegazione ..
— Ottimizzatore
@Optimizer Ah, right. I forgot about that. It's a language I've been designing for code golf. This is finally a challenge where (if I fix all the bugs) it could actually win.
— KSFT
1
Moreover, as far as I can see, the language was created like 10 minutes back, so technically, this is a non-competing answer :) . Also, I suppose this is the block corresponding to your ☃ code, which totally looks like something that has been specifically done for this challenge (as there are no other unicode based code blocks in your whole file).
— Optimizer
@Optimizer That instruction was actually in the language before (although a commit that changed it slightly was pushed after the challenge was posted), which was created a few days ago. Because I don't think this would work in the version of the language that was public when the challenge was posted, though, I don't think this answer should actually count, as I stated in my answer.
— KSFT
4
Do you want to build a snowman?
— flawr
0

J, 41 byte

Ora quello era un rompicapo!

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

Spiegazione:

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

Esempi:

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

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

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

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

   ((,quote,')$~'"_)'((,quote,'')$~''"_)')$~ 50
((,quote,')$~'"_)'((,quote,'')$~''"_)')$~((,quote,
— Bolce Bussiere
fonte
0

Java 10, 193 176 byte

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

Spiegazione:

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

  • Il var scontiene il codice sorgente non formattato.
  • %sè usato per inserire questa stringa in se stessa con s.format(...).
  • %c, %1$cE la 34vengono utilizzati per formattare le virgolette.
  • s.format(s,34,s) mette tutto insieme.

Parte sfida:

  • for(int i=n;i>n;i/=176)cicli ceil(n/176)volte, dove 176è la lunghezza del codice sorgente.
  • s+=s;aumenta esponenzialmente la dimensione della stringa del codice sorgente. ( abdiventa abab; ababdiventa abababab; ababababdiventa abababababababab; ecc.)
  • s.subtring(0,n);prende i primi ncaratteri della stringa.
— Kevin Cruijssen
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.