Um Quat é uma combinação de um quine e o popular programa de gatos esolang .

Desafio

O desafio é escrever um programa padrão para gatos. Quaisquer que sejam as entradas do usuário, o programa fará o eco da entrada para stdout.
No entanto, quando o comprimento da entrada for maior que 0 e um múltiplo de 4, o programa deverá gerar seu próprio código-fonte. Quat vem do português quatro , que se traduz em 'quatro'.

Regras

• Aplicam-se brechas padrão
• Você não pode ler o código fonte de um arquivo
• Uma entrada vazia deve produzir uma saída vazia

Bônus

Se o tamanho da entrada for múltiplo de 4, você poderá ganhar um bônus de 25% imprimindo os length/4tempos de quine . Outro bônus de 5% se você separar a saída por espaços (não é permitido espaço à direita).

Casos de teste

Os seguintes casos de teste se aplicam ao programa in%4=0?cat:self(não é um idioma real).

<empty input> -> <empty output>
input -> input
1234 -> in%4=0?cat:self
12345678 -> in%4=0?cat:self 0% de bônus
12345678 -> in%4=0?cat:selfin%4=0?cat:self de 25% de bônus
12345678 -> in%4=0?cat:self in%4=0?cat:self de 30% de bônus

Pontuação

Isso é código-golfe . O menor código em bytes vence.

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

Teste padrão generalizado ...

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

ou

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

Teste aqui.

Explicação

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

A outra versão evita o uso de uma variável usando o truque de rotação de pilha ]:\.

Sério, 8 9 bytes

Q,ó;l4@%I

Experimente Online

(Pressione Enter uma vez na caixa de entrada para testar a entrada vazia.)

O primeiro bônus pode ser feito em 12 bytes (16 * .75):

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

Explicação:

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)

Como algumas pessoas não gostam do uso do quining interno da Seriously, eu forneço esta versão de 22 bytes que não usa Qcomo referência:

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

Se você é uma dessas pessoas, considere esta a versão definitiva (por enquanto) e, em seguida, inicie um meta thread sobre o uso de built-ins em quines.

Pitão, 33 * 0,75 = 24,75

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

Suíte de teste

Quine Pyth padrão usando join. Isso é apenas uma verdadeira solução para o intérprete on-line, que não adiciona uma nova linha final à direita.

Obter o bônus final resulta em uma pontuação de 39 * .7 = 27,3:

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

Vitsy , 18 17 bytes

Tão perto . Sim. Agora estou ganhando entre não construídos em quiners! olha 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.

Não há razão para eu ir atrás dos bônus - eles gastariam muito mais bytes.

Trapaça quine versão, 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)))))))))

Isso usa a mecânica de cotação do Lisp para fornecer o código fonte como entrada para si mesmo.

Versão antiga de trapaça

:; 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 bytes * 0,75 = 54

Graças a @ Neil por uma economia de um byte!

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

A solução mais curta que encontrei foi bem direta.

Então, aqui estão algumas soluções bônus (mais interessantes):

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

Este abusa repeatda funcionalidade de lançar uma exceção se for passado um não inteiro.

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

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

Este último é definitivamente o meu favorito, dividindo a entrada em cada quatro caracteres usando o regex /.{4}/. Se houver algum caractere no final da string quando nós pop, ele não é divisível por 4, então alerte a entrada. Caso contrário, o popcomprimento da matriz será reduzido em um, portanto, nesse ponto, o comprimento da matriz será igual ao comprimento de entrada / 4. Nesse caso, apenas fillcom o quine e joincom os espaços.

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

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

Veja o conjunto de testes online aqui.

Quebrado

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 o espaço em branco é para InputFormo programa corresponder ao seu código real.

Javascript ES6, 45 bytes

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

Extensão do meu Bling Quine de 21 bytes. Espero que a promptsaída de mixagem e função seja permitida.

JavaScript, 33 bytes

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

• +44 bytes
• -25% de bônus

Outras soluções:

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% de bônus
• -5% de bônus