Tri-interquine-三个程序在一个循环中互相输出

10

相关：Interquine

程序A在运行时输出程序B的代码，B输出C的源代码，而C输出A的源代码。

这次您不能交换两个字符并再次交换:)

要求：

  • 所有程序中只有一种语言
  • 适用标准漏洞限制
  • 所有程序都不同。输出自身的一个程序没有资格。互相输出的两个也没有资格。
  • 所有程序都是非空的，或者长度至少为1个字节。
  • 没有什么阅读，因为标准输入连接到/dev/null（你可以，如果你滥用该规则可以）。输出进入标准输出。
  • 不要使用会产生随机结果的函数。

额外：

  • 如果可能，给出解释

得分是最短程序的长度（您可以从短程序中生成长程序吗？）。请写下所有程序的长度，并突出显示最小的数字。尾随换行符不计算在内。最低分获胜。

code-golf  quine 
— iBug
source
2
有关。（同样的东西，不同的语言。）
— 马丁·恩德

Answers:

19

Python 3，50个字节

s='s=%r;print(s%%(s,%i*2%%7))';print(s%(s,1*2%7))

在线尝试！

最后一个表达式去从1*2%7到2*2%7到4*2%7，然后回1*2%7。

— 漏尼姑
source
6
看起来像是n-interquine的通用解决方案。您只需要用（2 ^ n）-1替换7。
— iBug
4
在Python 2中，该映射使用1-2/_组成一个3周期(1,-1,3)，无需为进行转义，从而节省了一个字节%。
— xnor
@iBug甚至更短一些n，s='s=%r;print(s%%(s,-~%i%%3))';print(s%(s,-~1%3))取而代之的3是n
— PurkkaKoodari
4

RProgN 2，12 8个字节

1
«\2*7%

解释

1   # Push the digit to the stack.

«\2*7%
«       # Define a function from here to the matching ». As there is no matching », define it from here to the end of the program, and continue running.
 \      # Flip the function under the constant number.
  2*    # Multiply by 2.
    7%  # Modulo 7.

由于RProgN默认输出方式的便利性，因此在第一行留下数字，该数字在1、2和4之间循环，而在第二行保留该函数的字符串化版本。灵感来自@LeakyNun的Python答案

在线尝试！

— 阿塔科
source
4

CJam，17个字节

{sZZe\6Ye\"_~"}_~


{s6Ze\ZYe\"_~"}_~


{sZ6e\ZYe\"_~"}_~

在线尝试！

可能不是最优的，但这是我对先前挑战的方法的一种修改。

基本思想是相同的，但是我们执行两次交换，其中之一始终是无操作。受影响的指数2，3并且6：

1:     {sZZe\6Ye\"_~"}_~
ZZe\             does nothing
       {sZZe\6Ye\"_~"}_~
6Ye\     \   /
          \ /
           X
          / \
         /   \
2:     {s6Ze\ZYe\"_~"}_~
6Ze\      \  /
           \/    doesn't really do anything
           /\
          /  \
       {s6Ze\ZYe\"_~"}_~
ZYe\     \/
         /\
3:     {sZ6e\ZYe\"_~"}_~
Z6e\      \  /
           \/
           /\
          /  \
       {sZZe\6Ye\"_~"}_~
ZYe\     \/      doesn't really do anything 
         /\
1:     {sZZe\6Ye\"_~"}_~
— 马丁·恩德
source
3

CJam，14个字节

{_]3/W="_~"}_~


{_]3/W="_~"}{_]3/W="_~"}_~


{_]3/W="_~"}{_]3/W="_~"}{_]3/W="_~"}_~

在线尝试！

其他程序分别为26和38个字节长。

说明

还有另一种方法！

{       e# Again, the usual quine framework. In this case, there might
        e# be one or two additional copies of the block on the stack.
  _     e#   Duplicate the top copy of the block.
  ]     e#   Wrap all copies in an array.
  3/    e#   Split into chunks of 3. For the first two programs, this will
        e#   just wrap all of them in an array. For the third program, this
        e#   splits the fourth copy off from the first three.
  W=    e#   Select the last chunk. So `3/W=` does nothing for the first
        e#   two programs, but discards three copies once we get to four.
  "_~"  e#   Push the remainder of the program.
}_~
— 马丁·恩德
source
2

Python 3、127、127和127字节

a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(b%(b,a,c))

版画

b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';print(c%(c,a,b))

版画

c='c=%r;a=%r;b=%r;print(a%%(a,b,c))';a='a=%r;b=%r;c=%r;print(b%%(b,a,c))';b='b=%r;a=%r;c=%r;print(c%%(c,a,b))';print(a%(a,b,c))

这是基于我对Interquine问题的回答，该问题是基于普通的Python quine的。当我遇到一个四对角线问题时，我确切地知道该怎么做;）

— aaay aaay
source
1

CJam，14个字节

0{\)3%\"_~"}_~


1{\)3%\"_~"}_~


2{\)3%\"_~"}_~

在线尝试！

说明

0{      e# Again, the standard CJam quine framework, but this time we have a zero
        e# at the bottom of the stack.
  \     e#   Bring the 0 to the top.
  )     e#   Increment.
  3%    e#   Mod 3 to loop from 2 back to 0.
  \     e#   Put the result underneath the block again.
  "_~"  e#   Push the remainder of the source.
}_~
— 马丁·恩德
source
1

Javascript（ES6），63 55字节

eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0)
eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)
eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)

o1.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=0) 
o2.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=1)
o3.innerText = eval(c="`eval(c=${JSON.stringify(c)},n=${++n%3})`",n=2)
<pre id="o1"></pre>
<pre id="o2"></pre>
<pre id="o3"></pre>
展开摘要

使用的替代解决方案Function.prototype.toString（欺诈，30个字节）

(f=n=>`(f=${f})(${++n%3})`)(1)
— 赫尔曼·L
source
1

Lambda微积分，38个字符，44字节

一个基于所有奎因之母的简单解决方案：y-combinator：

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)

使用beta减少量，我们看到这确实是一个三联体：

(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λy.y)(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λz.z)(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
(λx.(λy.y)(λz.z)xx)(λx.(λy.y)(λz.z)xx)
etc.
— 国防部
source
0

Java 8，118字节

v->{int i=0;String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";return s.format(s,++i%3,34,s);}

仅int i=0;是功能/输出之间差值（它要么0，1或2）。

说明：

在线尝试。

v->{                       // Method with empty unused parameter and String return-type
  int i=0;                 //  Integer, starting at 0, 1 or 2 depending on the version
                           //  (this is the only variation between the functions/outputs)
  String s="v->{int i=%d;String s=%c%s%2$c;return s.format(s,++i%%3,34,s);}";
                           //  String containing the unformatted source code
  return s.format(s,++i%3,s);}
                           //  Quine to get the source code, which we return as result
                           //  ++i%3 is used to cycle 0→1→2→0

附加说明：

奎因 -part：

  • String s 包含未格式化的源代码
  • %s 用于将String本身放入 s.format(...)
  • %c，%2$c和34用于格式化双引号（"）
  • %% 用于格式化模数符号（%）
  • s.format(s,...,34,s) 放在一起

输出/功能的差异：

与大多数其他答案相同的方法：

  • int i开始在任0，1或2
  • ++i%3此变换到下一个（0→1; 1→2; 2→0）
— 凯文·克鲁伊森
source
0

> <>，15个字节

1'~r2*7%nd3*>o<

在线尝试！

使用与其他> <> quines相同的一般形式，但前面有一个额外的字符，该字符在1、2和4之间循环。

— 乔·金
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.