在四元一个的组合奎因和流行esolang 猫节目。

挑战

挑战在于编写标准的cat程序。无论用户输入了什么，程序都会将输入回显到stdout。
但是，当输入的长度大于0 且是4的倍数时，程序应输出其自己的源代码。Quat来自葡萄牙语quatro，翻译为“四个”。

规则

• 适用标准漏洞
• 您可能无法从文件中读取源代码
• 空输入应产生空输出

奖金

如果您输入的长度是4的倍数，则可以通过打印quine length/4时间来获得25％的奖金。如果您用空格分隔输出（不允许尾随空格），则另外5％的奖金。

测试用例

以下测试用例适用于该程序in%4=0?cat:self（不是真实语言）。

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

计分

这是代码高尔夫球。以字节为单位的最短代码获胜。

CJam，23 * 0.75 = 17.25字节

标准广义奎尼...

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

要么

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

在这里测试。

说明

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

另一个版本通过使用stack-rotation技巧避免使用变量]:\。

认真地，8 9个字节

Q,ó;l4@%I

在线尝试

（在输入框中单击一次以测试空输入。）

一等奖可以用12个字节（16 * .75）完成：

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

说明：

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)

由于某些人不喜欢使用内置的Seriously quining，因此我提供了这个22字节的版本，该版本不用Q作参考：

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

如果您是这些人中的一员，请考虑将其视为最终版本（现在），然后开始一个关于在藜中使用内置函数的元线程。

Pyth，33 * .75 = 24.75

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

测试套件

使用连接的标准Pyth quine。这只是在线解释器上的一个真正的线索，不会添加最后的尾随换行符。

获得最终奖金的结果是39 * .7 = 27.3：

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

Vitsy，18 17字节

好亲近。嗯 我现在在非内置式quiners中获胜！认真地瞪着眼睛

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.

我没有理由追求奖金-他们会浪费更多的字节。

作弊quine版本，12个字节：

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

这使用Lisp的报价机制将源代码作为其自身的输入。

旧作弊版

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

取消高尔夫：

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

感谢@Neil节省了一个字节！

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

我能找到的最短的解决方案非常简单。

因此，这里有一些额外的（更有趣的）解决方案：

JavaScript，82 81字节* 0.75 = 60.75

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

repeat如果传递了非整数，则会滥用抛出异常的功能。

JavaScript，83字节* 0.70 = 58.1

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

最后一个绝对是我的最爱，使用regex将输入每四个字符分割一次/.{4}/。如果我们在字符串末尾还剩下任何字符pop，则不能将其整除为4，因此请警惕输入。否则，将pop数组的长度减少一，因此在这一点上，数组的长度等于输入长度/4。在这种情况下，仅将fill其与五角形和join空格一起使用。

Perl，68 65 * 0.75 = 48.75字节

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

请参阅此处的在线测试套件。

分解

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个字节

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

程序的所有空白都InputForm与其实际代码相匹配。

Javascript ES6，45个字节

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

我的21字节Bling Quine的扩展。希望prompt允许混合和功能输出。

JavaScript，33个字节

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

• +44字节
• -25％奖金

其他解决方案：

44 36字节

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字节

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

• +55字节
• -25％奖金
• -5％奖金