编写一个产生输出的程序，使得：

1. 至少出现三个不同的字符。
2. 每个字符的出现次数是3的倍数。

例如，A TEA AT TEE是一个有效的输出由于各4个不同的字符，A，E，T和(space)，发生3次。

当然，关于数字3的挑战需要有第三个要求。所以：

3. 该程序本身还必须遵循前两个要求。（这意味着您的程序将至少有9个字节长。）

您必须编写完整的程序，而不是函数。确保在答案中显示程序的输出。

此外，为使事情有趣，我们强烈建议您：

• 如果可以帮助，不要使用评论来满足要求3
• 产生的输出不仅仅是重复3次的字符串
• 使输出与程序本身有所不同（对于可以自动输出其自己程序内容的语言，您可以对此社区Wiki做出贡献）。

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

Brain-Flak，Flakcats，Brain-Flueue，Brain-Flak Classic，Miniflak和Fλak18字节

事实证明是最佳的！

((([()][()][()])))

在线尝试！

说明

脑气弹，脑气弹，迷你气弹和Fλak

   ([()][()][()]) Push -3
  (              ) Copy
 (                ) Copy

打印：

-3
-3
-3

（后面有换行符）

经典机智

Brain-Flak Classic是Brain-Flak的原始版本，与现代Brain-Flak有一些重要区别。在BFC中[...]打印其内容而不是否定它。

   [()] Print 1
       [()] Print 1
           [()] Print 1
  (            ) Push 3
 (              ) Push 3
(                ) Push 3

在执行结束时，将3 3 3打印堆栈的内容（）。

打印：

1
1
1
3
3
3

（后面有换行符）

k猫

Flakcats与其他4个flaks完全不同，我很惊讶这在Flakcats中有效。这里的三个运算符与Brain-Flak使用的运算符几乎相同。

Flakcats之间在此特定程序中的主要区别是(...)算子，该算子在Flakcats中等效([{}]...)于Brain-Flak。但是，这对我们没有影响，因为它会拾取零，因此其操作方式与Brain-Flak相同。

这是编译成Brian-Flak的程序：

([{}]([{}]([{}][()][()][()])))

打印：

-3
-3
-3

（后面有换行符）

脑弹和迷你弹的最优性证明

这不是正式的证明，而是非正式的证明，必须对其进行扩展以使其更加严格

由于存在限制，因此Brain-Flak程序必须为平衡字符串，并且程序长度必须为3的倍数，任何有效提交的长度都必须为6的倍数。这意味着任何小于18的解决方案都必须为长度12。

由于输出尾随换行符，因此堆栈的最终高度必须为三的倍数，否则我们将打破对输出的限制。

任何有效的长度为12的提交都必须使用两种花括号（少用大括号会破坏对不同字符数量的限制，而多则表示多于12个字符）。由于程序产生输出，因此必须进行推送。

这使我们可以选择其他大括号。选项包括：

<...>/<>

失败之所以失败，是因为我们需要生成“值”以创建除零以外的任何数字，我们必须放弃a ()来创建一个使得不可能两次以上推送的数字。

[...]/[]

失败的原因与上次失败相同。方括号真的很难创造价值。该[]单子可以创造价值，但我们首先需要推动的数字，我们再没有足够的括号遗留推三次。

{...}/{}

这个很有希望，我们可以创建一个循环并使用它()来多次推送，但是遗憾的是这是不可能的。

为了使循环结束，在某个时刻堆栈上必须为零，为了使我们具有正确的输出，我们必须在程序结束时在堆栈上提供除零以外的值。因为我们既没有[]，也没有<>在循环结束零一定是从堆栈底部的隐含为零。这意味着循环无法将任何新数字添加到堆栈中，从而使其无效。

由于没有括号选项可以创建长度为12的程序，因此不存在。

由于Miniflak是Brain-Flak的子集，因此任何较短的Miniflak程序也将是较短的Brain-Flak程序，因此不存在。

脑烟道最优性的证明

Brain-Flueue是一种基于Brain-Flak的笑话语言。两者是如此相似，除了两行外，其他地方的解释都是相同的。顾名思义，两者之间的区别在于Brain-Flueue将其数据存储在队列中，而Brain-Flak将其数据存储在堆栈中。

首先，我们对Brain-Flak创建的程序大小有相同的限制，因此我们正在寻找大小为12的程序。此外，我们将需要a (...)来创建任何输出和另一对。在<>和[]对不脑Flueue他们不脑高射炮工作的确切同样的原因工作。

现在我们知道我们的程序必须由字符组成((())){{{}}}。

通过前面证明中使用的相同方法，我们可以证明最终程序中必须存在一个循环。

现在这里的证明有所不同，因为Brain-Flueue跨队列而不是堆栈操作，程序可以退出队列中包含值的循环。

为了退出循环，我们需要在队列中添加一个零（或一个空队列，但是如果队列为空，则会遇到与Brain-Flak相同的问题），这意味着我们将不得不打开程序({})来创建零。我们将需要在循环内部进行推送，以将必要数量的项目推送到队列中。我们还需要在循环之前加一个非零的数字，以便我们完全可以进入循环。这将使我们的成本降至最低(())。现在，我们使用了更多的paren。

因此，没有Brain-Flueue程序可以执行12字节的任务，而且我们的程序是最佳的。

Flakcats和Brain-Flak Classic的最佳解决方案

以下解决方案在Flakcats和Brain-Flak Classic中是最佳的。

((([][][])))

说明

    [][][] -3
 (((      ))) push 3 times

替代的24字节Brain-Flak解决方案

(<((<((<(())>)())>)())>)

在线尝试！

((<((<((<>)())>)())>)())

在线尝试！

((((((()()()){}){}){})))

在线尝试！

果冻，9 个字节

**‘‘‘888*

完整程序可打印700227072（888立方）。

TryItOnline！

怎么样？

**‘‘‘888* - Main link: no arguments
          - implicit L=R=0
*         - power       A = L ^ R = 1
  ‘       - increment   B = L + 1 = 1
 *        - power       C = A ^ B = 1
   ‘      - increment   D = C + 1 = 2
    ‘     - increment   E = D + 1 = 3
     888  - literal     F = 888
        * - power           F ^ E = 700227072

多种文字答案的多语种，9个字节

333111222

这是一个社区Wiki帖子，用于收集答案，这些答案只是所讨论语言自动打印出来的文字。因为它是社区Wiki，所以可以随时对其进行编辑以在其工作时添加更多语言。

该程序适用于：

• 的PHP
• HTML（可以说不是语言）
• 果冻（和M）
• 7（更有趣，因为程序的解释为数据和代码；第一个3打印数据，其余的程序是无用的堆栈操作）
• 贾姆
• 杰普特
• 胡萝卜
• R（R显示屏还输出[1]作为元数据）
• RProgN
• 实际上（尽管它实际上可以打印2\n2\n2\n1\n1\n1\n3\n3\n3\n）
• ///
• 诺德尔
• TI基本
• SimpleTemplate
• ReRegex
• 稻壳
• 资源（尽管这会输出相反的字符串）

忽略最后的换行符，这在多种语言中仍然有效：

• 05AB1E
• 2貂皮
• 高尔夫脚本
• 电源外壳
• m4（任何版本，程序均可移植）
• 腐霉菌
• 玛特
• 点子
• 萨克斯
• 墨
• 桶

大多数链接都可以在线尝试！

C＃，114个 111 118 102字节

如果我们不在乎使用适当的单词：（102个字节）

class CCcddiilMMmmnrrSSsttvvWWyy{static void Main(){{System.Console.Write(("A TEA AT TEE"));;;}}}///".

如果我们关心适当的单词：（120个字节）

class erebeWyvern{static void Main(){int embedWildbanana;{System.Console.Write(("A TEA AT TEE"));;}}}///CC Myst mvcSMS".

我的原始提交内容-不区分大小写：（113个字节）

class EreBeWyvern{static void Main(){int embedwildbanana; {System.Console.Write(("A TEA AT TEE"));;}}}/// vyt".

我知道此评论并非真的符合CG的精神，但这是我可以在有限的时间内提出的所有意见，我将看看我是否可以在一整天内改进它。当然，我必须至少获得一些加分才能点头冒险。

编辑：谢谢roberto06赶上丢失的字母！

JavaScript，36 33字节

alert(((alert|alert||333111222)))

警报333111222。之所以有效，是因为|将其两个操作数都转换为32位整数，并且任何看起来不像整数的值（例如函数alert）都将转换为0。0|0是0，因此||运算符返回其右操作数，或者333111222

一些更有趣的版本：

(a="(trelalert)\\\"")+alert(a+=a+=a)

输出(trelalert)\"(trelalert)\"(trelalert)\"。

.repeat多亏了shared，使用的解决方案的长度是相同的aert：

alert("(trpp.all)\\\"".repeat(3.33))

输出(trpp.all)\"(trpp.all)\"(trpp.all)\"。

利用多余的反斜杠来消除l和p 几乎起作用：

a\x6cert("(trax.cc)\"".re\x70eat(6.00677))

这个输出(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"(trax.cc)"。

CJam，9个字节

10,10,10,

产出 012345678901234567890123456789

在线尝试！

说明

10,       The range from 0 to 9
   10,    The range from 0 to 9
      10, The range from 0 to 9

头脑操，12字节

++[+...][][]

没有人说输出一定要短。除前2个字符外，这将输出每个ASCII字符的3个副本。

您可以证明这会尽可能短。您需要输出，因此您需要3'。需要有不同的输出，因此您需要3 [+-]，现在我们最多为6。必须打印9个字符，这意味着要再添加6个“。”。或添加一个循环，这将再添加6个字符。

在线尝试！

Python 2，36 30字节

由于不允许尾随换行符，因此它可能会变得很短：

print"\\\""*3;print;print;3**3

在线尝试

输出\"三遍，后跟三行。

以下程序不计入尾随的换行符，因此它们无效。

27个字节：

print"""printprint"""*3*3*3

在中打印每个字符的54 print。

在线尝试

长度相同，输出较短：

print"""printprint*3*3"""*3

产出 printprint*3*3printprint*3*3printprint*3*3

24个字节：

print~9;print~9;print~9;

Perl 6、15个字节

.say;.say;.say;

打印六个不同的字符，每个字符三遍：

（任何）
（任何）
（任何）

在线尝试！

这个怎么运作

• 裸方法调用针对当前主题进行$_。
• $_开出作为类型对象类型的Any，其say打印作为(Any)。

C，66字节

main(i){{for(i=0;i<3;i++){printf("""poop+fart=<3<3at0m=m0n""");}}}

输出量

poop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0npoop+fart=<3<3at0m=m0n    

旧版本72字节

main(i){for(i=0;i<3;i++){printf("poop+fart=<3<3 at {\"0m=m0\"}" "\n");}}

JavaScript（ES6），30个字节

+alert((({alert}+{alert}+{})))

输出[object Object][object Object][object Object]。

通过创建三个对象来工作：

• 前两个是{ "alert" : alert }使用ES6表示法的形式{alert}

• 第三个是一个简单的空对象

然后，它用于+将它们连接在一起，并且所有三个表达式都具有与字符串相同的表达式[object Object]。

开头+是无用的，仅出现即可填充+字符数，但对程序的输出无害。

PKod，9字节

sonsonson

输出：111222333

说明：

Background: PKod has only one variable that you mess with, with the code
This variable starts with default value of 0

s  -  Add next char to the variable, and jump over it. 
n  -  Print numeric value of variable

o具有十进制的ascii字符代码“ 111”。因此，s将111加到变量中，然后输出数字。第一个“儿子”将其制作为111，然后打印111。第二个“儿子”将其制作为111，然后打印222，最后将其制作为333，然后打印333。

红宝石，12字节

p$@;p$@;p$@;

输出

nil
nil
nil

在线尝试！

为了满足第二个“鼓励”标准，我需要15个字符：

p 1;p 3;p 1133;

产生

1
3
1133

也可以在线尝试！

Microscript II，9个字节

{{{~~~}}}

说明：创建一个代码块，但不调用它。执行结束时，隐式打印主寄存器（即此代码块）的内容。

六边形，9字节

x!!xx@@!@

在线尝试！

打印出来120120120。x可以替换为f-m（102-109）

说明

  x ! ! 
 x x @ @
! @ . . .

的xx@@仅仅是遵守规则的填料。主要流程是保存x到内存中（ASCII值为120），然后将其打印为3次。

C，111字节

（请注意，字节数也是三个相同的数字。哇。您不能做更多的元操作。）

#include<stdio.h>
#define b "<acdhlmoprsu>."
#define t "en"
main(){{{printf(("<acdhlmoprsu>." b b t t t));;;}}}

印刷品：

<acdhlmoprsu>.<acdhlmoprsu>.<acdhlmoprsu>.enenen

PHP，33字节

<?=($s="<?;<?=;'".'"').($s).($s);

选择了比没有PHP标记的9字节程序更有趣的功能。

产出 <?;<?=;'"<?;<?=;'"<?;<?=;'"

在线尝试！

99，15字节

9 9  9999
9
9
9

那是九个九，三个空格和三个换行符，输出是-1110-1110-1110。

在线尝试！

怎么样？

9 9  9999 - V(9)=V(9)-V(9999)=1-1111=-1110
9         - print V(9)
9         - print V(9)
9         - print V(9)

这两个空格被视为一个，第三个空格也可以是任何行上的尾随空格。

Bash + coreutils，15个 9字节

id;id;id;

在线尝试！

样本输出：

uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211
uid=1000 gid=1000 groups=1000 context=system_u:unconfined_r:sandbox_t:s0-s0:c19,c100,c173,c211

（如果您尝试这样做，它将打印您的uid，gid等3次。）

如果要避免重复相同的字符串3次（并且对每个人都具有相同的输出，这与我的第一个答案不同），那么我发现bash + Unix实用程序的最佳长度为15个字节：

dc<<<cczdzfzfdf

在线尝试第二个版本！

输出：

2
0
0
3
2
0
0
3
3
2
0
0

（程序中没有换行符，输出中有12个换行符。）

dc程序在此答案中的说明：

c Clears the stack.
Stack: (empty)

c Clears the stack.
Stack: (empty)

z Pushes the current size of the stack (0) onto the stack.
Stack: (top) 0

d Duplicates the item at the top of the stack.
Stack: (top) 0 0

z Pushes the current size of the stack (2) onto the stack.
Stack: (top) 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the first 3 lines of the output, 2 / 0 / 0 /)

z Pushes the current size of the stack (3) onto the stack.
Stack: (top) 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the next 4 lines of the output, 3 / 2 / 0 / 0 /)

d Duplicates the item at the top of the stack.
Stack: (top) 3 3 2 0 0

f Prints the stack, top to bottom, with a newline after each item printed (this prints the final 5 lines of the output, 3 / 3 / 2 / 0 / 0 /)

LOLCODE，273 240（360 286）个字节

HAI 1.2
I HAS A U
IM IN YR M UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "Y SUB.EK"
IM OUTTA YR M
IM IN YR T UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "Y SUB.EK"
IM OUTTA YR T
IM IN YR X UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IM"
IM OUTTA YR X
KTHXBYE

注意尾随的新行并在线尝试。第二行或多或少是任意的，可以用更短的命令代替，但是我刚刚为这个难题学习了LOLCODE。由于第一行需要版本号，因此我使用数字添加长度为1、2和0 mod 3的循环，以确保将打印正确的字符数。由此，我简单地计算了每个字符（使用此工具）。如果3次出现0 mod，则无需采取任何措施。如果3次出现1 mod，则将其添加到1和2循环中，以便在输出中出现3次。如果3次出现2 mod，则将角色添加到12循环中。编辑：通过替换第一个VISIBLE 有了一个分配（仍然没有用，但是必须有12个而不是11个新行），我能够剪切33个字节。

输出（60字节）：

Y SUB.EK
Y SUB.EK
Y SUB.EK
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM
IM

注意尾随新行。

与其他答案相比，此解决方案的好处在于，可以轻松操纵Output以输出一些有意义的文本。示例（286字节，后跟换行符）：

HAI 1.2
I HAS A U
IM IN YR MW UPPIN YR Q TIL BOTH SAEM Q 1
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR MW
IM IN YR STA UPPIN YR Q TIL BOTH SAEM Q 2
VISIBLE "YO SUB. EEEEK!"
IM OUTTA YR STA
IM IN YR XURG UPPIN YR Q TIL BOTH SAEM Q 12
VISIBLE "IMO U R SWAG! "
IM OUTTA YR XURG
KTHXBYE

在线尝试。输出（222字节，后跟换行符）：

YO SUB. EEEEK!
YO SUB. EEEEK!
YO SUB. EEEEK!
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 
IMO U R SWAG! 

可悲的是，我对字谜的理解不如我想象的好：'）

贝壳

开玩笑:)（9字节）

ls;ls;ls;

或更严重（24字节）

sed s/./sed.g./g <<< edg

结果：

sed.g.sed.g.sed.g.

PHP，24字节

<?=111?><?=222?><?=333?>

批处理，36 21字节

@echo
@echo
@echo

产出

ECHO is on.
ECHO is on.
ECHO is on.

编辑：由于@ P.Ktinos，节省了15个字节。

Japt，9个字节

000OoOoOo

印刷品undefinedundefinedundefined。在线测试！

说明

这段代码被转换为以下JavaScript：

000,O.o(O.o(O.o()))

O.o是一个输出没有尾随换行符的函数。如果不指定任何参数，它会打印出undefined，这可以看作是一个错误，但在这里很方便。它还返回undefined，因此所有三个调用都将打印undefined。

我相信还有很多其他方法可以做到这一点...

05AB1E，9个字节（我想你可以说这是一个PI）

-0字节归功于Emigna / ETHProductions，使解决方案更加正确。

žqžqžq???

备用版本：

ž[g-Q]ž[g-Q]ž[g-Q]???

[g-Q] -只要它们都匹配，就可以在此处放置任何字母aQ（请参见下文）。

在线尝试！

解释：

PI,PI,PI,SORT,JOIN,SORT,JOIN,SORT,JOIN.

结果：

...111111222333333333444555555555666777888999999999

它只有9个字节的原因是因为您不需要排序，我只是将它们放入以帮助说明。

导致的w / o {中的代码：

3.1415926535897933.1415926535897933.141592653589793

替代音色：

可以使用以下命令代替PI：

ž 23  > žg       push current year
        žh       push [0-9]
        ži       push [a-zA-Z]
        žj       push [a-zA-Z0-9_]
        žk       push [z-aZ-A]
        žl       push [z-aZ-A9-0_]
        žm       push [9-0]
        žn       push [A-Za-z]
        žo       push [Z-Az-a]
        žp       push [Z-A]
        žq       push pi
        žr       push e
        žu       push ()<>[]{}
        žy       push 128
        žz       push 256
        žA       push 512
        žB       push 1024
        žC       push 2048
        žD       push 4096
        žE       push 8192
        žF       push 16384
        žG       push 32768
        žH       push 65536
        žI       push 2147483648
        žJ       push 4294967296
        žK       push [a-zA-Z0-9]
        žL       push [z-aZ-A9-0]
        žM       push aeiou
        žN       push bcdfghjklmnpqrstvwxyz
        žO       push aeiouy
        žP       push bcdfghjklmnpqrstvwxz
        žQ       push printable ASCII character set (32-128)

Cubix，12个字节

答案确实有点无聊。输出10三秒，后跟换行符

N@N@NOoOoOo@

在线尝试！ 映射到多维数据集

    N @
    N @
N O o O o O o @
. . . . . . . .
    . .
    . .

N将10压入堆栈
Oox3输出10并换行以
@暂停程序

最初N@N@没有被击中。

Pepe，24位元组

rEeEEeeEEErreEErreEEreEE

在线尝试！

程序包含6个r，6个e和12个e。

说明：

rEeEEeeEEErreEErreEEreEE # full program

rEeEEeeEEE               # push '103' to the stack
          rreEErreEE     # output as int (r flag: preserve)
                    reEE # output as int

输出：

103103103

V，9个字节

12i12i12i

在线尝试！

输出12i24次：

12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i12i

Vim，12个字节

12i12i12i<ESC><ESC><ESC>

输出与V答案相同

堆叠，24字节

''''   'putput'3*3*3*put

在线尝试！输出和的54每个。p ut

Befunge 93，9个字节

...,,,@@@

蒂奥

打印0 0 0（尾随空格，后跟3个空字节）

因为Befunge的堆栈用0s 填充，所以我们可以同时打印具有该值的ASCII字符和整数本身。因为Befunge会在整数之后自动打印一个空格，所以我们剩下3个不同的字符。

.打印0（尾随空格），,打印一个空字节，然后@结束程序