Un Quat es una combinación de un quine y el popular programa de gato esolang .

Reto

El desafío es escribir un programa estándar para gatos. Cualesquiera que sean las entradas del usuario, el programa hará eco de la entrada en stdout.
Sin embargo, cuando la longitud de la entrada es mayor que 0 y un múltiplo de 4, el programa debe generar su propio código fuente. Quat proviene del quatro portugués , que se traduce como 'cuatro'.

Reglas

• Se aplican lagunas estándar
• No puede leer el código fuente de un archivo
• Una entrada vacía debería producir una salida vacía

Prima

Si la longitud de su entrada es un múltiplo de 4, puede ganar un bono del 25% imprimiendo los length/4tiempos de quine . Otro 5% de bonificación si separa la salida por espacios (no se permite espacio final).

Casos de prueba

Los siguientes casos de prueba aplican para el programa in%4=0?cat:self(no es un lenguaje real).

<empty input> -> <empty output>
input -> input
1234 -> in%4=0?cat:self
12345678 -> in%4=0?cat:self 0% de bonificación
12345678 -> in%4=0?cat:selfin%4=0?cat:self 25% de bonificación
12345678 -> in%4=0?cat:self in%4=0?cat:self 30% de bonificación

Tanteo

Este es el código de golf . El código más corto en bytes gana.

CJam, 23 * 0.75 = 17.25 bytes

Quine generalizado estándar ...

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

o

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

Pruébalo aquí.

Explicación

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

La otra versión evita el uso de una variable mediante el uso del truco de rotación de la pila ]:\.

En serio, 8 9 bytes

Q,ó;l4@%I

Pruébalo en línea

(Presione enter una vez en el cuadro de entrada para probar la entrada vacía).

El primer bono se puede hacer en 12 bytes (16 * .75):

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

Explicación:

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)

Debido a que a algunas personas no les gusta el uso de las funciones integradas de Quining de Seriously, proporciono esta versión de 22 bytes que no se usa Qcomo referencia:

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

Si usted es una de esas personas, considere esta la versión definitiva (por ahora) y luego comience un metaproceso sobre el uso de elementos integrados en quines.

Pyth, 33 * .75 = 24.75

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

Banco de pruebas

Pyth quine estándar usando join. Esto es solo una verdadera frase en el intérprete en línea, que no agrega una nueva línea final.

Obteniendo los resultados finales de bonificación en una puntuación de 39 * .7 = 27.3:

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

Vitsy , 18 17 bytes

Tan cerca . Yus ¡Ahora estoy ganando entre quiners no construidos! mira en serio

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.

No hay razón para que yo vaya tras las bonificaciones: arrojarían muchos más bytes.

Versión de trampa quine, 12 bytes:

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

Esto utiliza la mecánica de citas de Lisp para proporcionar el código fuente como entrada para sí mismo.

Antigua versión de trampa

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

Sin golf:

:; 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 bytes * 0.75 = 54

¡Gracias a @Neil por un ahorro de un byte!

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

La solución más corta que pude encontrar fue bastante sencilla.

Entonces, aquí hay un par de soluciones adicionales (más interesantes):

JavaScript, 82 81 bytes * 0.75 = 60.75

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

Éste abusa repeatde la funcionalidad de lanzar una excepción si se pasa un no entero.

JavaScript, 83 bytes * 0.70 = 58.1

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

Este último es definitivamente mi favorito, dividiendo la entrada en cada cuatro caracteres usando la expresión regular /.{4}/. Si quedan caracteres al final de la cadena cuando nosotros pop, no es divisible por 4, entonces alerta la entrada. De lo contrario, popreduce la longitud de la matriz en uno, por lo que en este punto la longitud de la matriz es igual a la longitud de entrada / 4. En este caso, solo fillcon la quine y joincon espacios.

Perl, 68 65 * 0.75 = 48.75 bytes

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

Vea el conjunto de pruebas en línea aquí.

Desglosado

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 bytes

($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]]]]) & []

Todo el espacio en blanco es para que InputFormel programa coincida con su código real.

Javascript ES6, 45 bytes

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

Extensión de mi Bling Quine de 21 bytes. Espero que promptse permita la mezcla y la salida de funciones.

JavaScript, 33 bytes

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

• +44 bytes
• -25% de bonificación

Otras soluciones:

44 36 bytes

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 bytes

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

• +55 bytes
• -25% bonificación
• -5% de bonificación