Una Quat è una combinazione di una quina e il popolare programma per gatti esolang .

Sfida

La sfida è scrivere un programma cat standard. Qualunque sia l'input dell'utente, il programma farà eco all'input su stdout.
Tuttavia, quando la lunghezza dell'ingresso è maggiore di 0 e un multiplo di 4, il programma dovrebbe generare il proprio codice sorgente. Quat viene dal quatro portoghese , che si traduce in "quattro".

Regole

• Scappatoie standard applicano
• Non è possibile leggere il codice sorgente da un file
• Un input vuoto dovrebbe produrre un output vuoto

indennità

Se la lunghezza dell'input è un multiplo di 4, puoi guadagnare un bonus del 25% stampando il quine length/4 tempi di . Un altro bonus del 5% se si separa l'output in base agli spazi (nessuno spazio finale consentito).

Casi test

I seguenti casi di test si applicano al programma in%4=0?cat:self(non una lingua reale).

<empty input> -> <empty output>
input -> input
1234 -> in%4=0?cat:self
12345678 -> in%4=0?cat:self 0% di bonus
12345678 -> in%4=0?cat:selfin%4=0?cat:self 25% di bonus
12345678 -> in%4=0?cat:self in%4=0?cat:self 30% bonus

punteggio

Questo è code-golf . Vince il codice più breve in byte.

CJam, 23 * 0,75 = 17,25 byte

Quine generalizzate standard ...

{`"_~"+q:Q,4md@@*Q\?}_~

o

{`"_~"+q_,4md@@]:\*?}_~

Provalo qui.

Spiegazione

{`"_~"+  e# Generalised quine framework. Leaves the source code on the stack.
  q:Q    e# Read input and store it in Q.
  ,      e# Get its length.
  4md    e# Divmod 4.
  @      e# Pull up the source code.
  @      e# Pull up the div.
  *      e# Repeat the source code that many times.
  Q\     e# Push the input and swap it below the repeated source.
  ?      e# Pick the right output based on the modulo.
}_~

L'altra versione evita l'uso di una variabile usando il trucco di rotazione dello stack ]:\.

Scherzi a parte, 8 9 byte

Q,ó;l4@%I

Provalo online

(Premi invio una volta nella casella di input per testare l'input vuoto.)

Il primo bonus può essere fatto in 12 byte (16 * .75):

Q,ó;l;4@\(*)4@%I

Spiegazione:

Q                   Push program source to stack
 ,ó                 Push input string, and terminate if it's empty
   ;l               Push length of input
     4@%            Take the length mod 4.
        I           Pick the next stack element (input) if nonzero,
                    else the next next (program source)

Poiché ad alcune persone non piace l'uso del quining integrato di Seriously, fornisco questa versione da 22 byte che non utilizza Qcome riferimento:

`è";ƒ"(+,ó;l4@%I`;ƒ

Se sei una di quelle persone, considera questa la versione definitiva (per ora) e poi avvia un meta thread sull'uso dei built-in nei quines.

Pyth, 33 * .75 = 24.75

?%lz4z*/lz4jN*2]"?%lz4z*/lz4jN*2]

Test Suite

Pyth quine standard usando join. Questo è solo un vero quine sull'interprete online, che non aggiunge una nuova riga finale finale.

Ottenere i bonus finali predefiniti con un punteggio di 39 * .7 = 27.3:

?%lz4zjd*/lz4]jN*2]"?%lz4zjd*/lz4]jN*2]

Vitsy , 18 17 byte

Così vicino . Yus. Ora sto vincendo tra quiners non costruiti! guarda seriamente

zl4M([&'rd3*8\}]Z
z                 Grab ALL THE INPUT! :D
 l4M([         ]  If the input is a multiple of four, do the stuff in brackets.
      &           Generate a new stack and move to it.
       'rd3*      Standard quine.
            8\}   Push the bottom 8 items of the stack to the top.
                Z Output the current stack.

Non ho motivo di perseguire i bonus: avrebbero buttato su molti più byte.

Cheating quine version, 12 byte:

zl4M([&iG`]Z
zl4M([&   ]Z  Same as above.
       i      Push -1.
        G     Get the name of the file with this index of use (-1 is self)
         `    Read the file with the given name and push its contents to the stack.

Emacs Lisp (323 * 0.75 = 242.25)

((lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s))))))) (quote (lambda (s) (let* ((a (read-string "")) (l (string-bytes a))) (if (> (% l 4) 0) (message a) (dotimes (v (/ l 4)) (prin1 (list s (list (quote quote) s)))))))))

Questo utilizza la meccanica di quotazione di Lisp per fornire il codice sorgente come input a se stesso.

Vecchia versione barare

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args))(set'b(buffer-string))(set's(read-string""))(set'l(string-bytes s))(if(>(% l 4)0)(message s)(dotimes(v(/ l 4))(message"%s"b)))

Ungolfed:

:; exec emacs -Q -script $0
(find-file(nth 2 command-line-args)) ; open self
(set'b(buffer-string))               ; read own code to string
(set's(read-string""))               ; read input
(set'l(string-bytes s))              ; length of input
(if(>(% l 4)0)                       ; l % 4 > 0 ?
    (message s)                      ; output input
  (dotimes(v(/ l 4))                 ; (implicit else) repeat l/4 times
    (message"%s"b)))                 ; output own code

JavaScript, 57 56 72 byte * 0,75 = 54

Grazie a @Neil per un risparmio di un byte!

(f=_=>alert(!(p=prompt())||(l=p.length)%4?p:`(f=${f})()`.repeat(l/4)))()

La soluzione più breve che ho trovato è stata piuttosto semplice.

Quindi, ecco un paio di soluzioni bonus (più interessanti):

JavaScript, 82 81 byte * 0,75 = 60,75

f=_=>{try{p=prompt();a=`f=${f};f()`.repeat(p.length/4)}catch(e){a=p}alert(a)};f()

Questo abusa repeatdella funzionalità di generare un'eccezione se viene passato un numero intero.

JavaScript, 83 byte * 0,70 = 58,1

(f=_=>alert((a=(p=prompt()).split(/.{4}/)).pop()?p:a.fill(`(f=${f})()`).join` `))()

Quest'ultimo è sicuramente il mio preferito, dividendo l'input su ogni quattro caratteri usando il regex /.{4}/. Se ci sono caratteri rimasti alla fine della stringa quando noi pop, non è divisibile per 4, quindi avvisa l'input. Altrimenti, ilpop lunghezza dell'array è ridotta di uno, quindi a questo punto la lunghezza dell'array è uguale alla lunghezza di input / 4. In questo caso, basta fillcon il quine e joincon gli spazi.

Perl, 68 65 * 0,75 = 48,75 byte

perl -e'$_=q{print+($l=($~=<>)=~y///c)%4?$~:"\$_=q{$_};eval"x($l/4)};eval'

Vedi la suite di test online qui.

Suddiviso

perl -e'
    $_=q{                      # store source code in $_
        print+(
            $l=($~=<>)=~ y///c # read STDIN into $~, assign length to $l
        )%4 ?                  # if length is a multiple of 4
             $~ :              # print $~
             "\$_=q{$_};eval"  # otherwise, print source code
             x($l/4)           # length/4 times
    };
    eval'                      # eval $_ to execute its contents

Mathematica, 229 byte

($RecursionLimit = Infinity; WriteString[$Output, If[Mod[StringLength[a = (If[(a = InputString[]) === EndOfFile, "", StringJoin["\n", a, #0[]]] & )[]], 4] == 1, ToString[#0, InputForm][], If[a == "", "", StringDrop[a, 1]]]]) & []

Tutto lo spazio bianco è destinato InputFormal programma affinché corrisponda al suo codice attuale.

Javascript ES6, 45 byte

$=(_=prompt())=>_.length%4?_:`$=${$};$()`;$()

Estensione del mio Bling Quine a 21 byte. Spero che promptsia consentito l'output di missaggio e funzione.

JavaScript, 33 byte

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(l/4)

• +44 byte
• -25% di bonus

Altre soluzioni:

44 36 byte

f=(i,l=i.length)=>l%4?i:("f="+f).repeat(!!l)

f=(i,l=i.length)=>l%4?i:l?("f="+f):i

38,5 byte

f=(i,l=i.length)=>l%4?i:Array(l/4).fill("f="+f).join` `

• +55 byte
• -25% bonus
• -5% di bonus