Paul是您的比利时熟人之一，他希望您创建一个程序，该程序至少输出以下五个字符串之一：

12496=>14288=>15472=>14536=>14264

14264=>12496=>14288=>15472=>14536

14536=>14264=>12496=>14288=>15472

15472=>14536=>14264=>12496=>14288

14288=>15472=>14536=>14264=>12496

它代表了他最骄傲的朋友，并且他想和他们一起吃饭。保罗还认为数字6是完美的，这是唯一值得使用的数字。因此，您不能在代码中使用“ 6”以外的任何其他数字（禁止使用0到5和7到9）。您的程序不能接受任何输入。输出可以在字符串之前和/或之后包含垃圾，但应至少包含上述字符串之一。

例如，这是一个有效的输出：

220frefze
f**14288=>15472=>14536=>14264=>12496**fczfe fz**15472=>14536=>14264=>12496=>14288**zfe
fzehth

我“虔诚”地在问题中暗示了我希望如何解决该问题，但又怎么知道呢？也许有更好的方法...希望您玩得开心。

这是代码高尔夫球：最低得分（以字节为单位）获胜。

05AB1E，18 17字节

•w[•Y·FDѨO})„=>ý

在线尝试！

说明

•w[•                # base 214 encoding of 12496
    Y·F             # loop 2*2 times
       D            # duplicate top of stack
        Ñ           # push divisors
         ¨          # remove the last element (itself)
          O         # sum
           }        # end loop
            )       # wrap in list
             „=>ý   # join list on "=>"

简而言之，我们将每个数字计算为 f(n+1) = sum(divisors(f(n)) - f(n)

Pyke，16个字节

wヰw$VDlsh)J"=>

在这里尝试！

wヰ             -  12496
  w$            -   4
    V    )      -  repeat ^:
     D          -   duplicate(^)
      l         -     factors(^)
       s        -    sum(^)
        h       -   ^ + 1
          J     - v.join(^)
           "=>  -  "=>"

每当字符串文字位于程序末尾时，它都将其与之前的令牌交换，在这种情况下节省1个字节。派克factors函数既不包含数字本身也不包含1。如果允许数字，则可以通过替换w$为1字节来保存1个字节。4

Pyke，21个字节

uバ㟐㱰㣈㞸J"=>

在这里尝试！

创建所需数字的列表并将其加入。除了使用字符串的技巧之外，还不是很有趣。

MATLAB，44字节

['','=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'-6-6]

在线尝试！

我还没有在数字中找到一种模式（由于我无法使用数字，因此无论如何都很难使用该模式），所以我只会采用简单的方法。

'=>@EBIJ=@>DDIJ=A@C>IJ=@A?BIJ=@>B@'是将'12496=>14288=>15472=>14536=>14264'12添加到ASCII值时的字符串。现在，输入该字符串，减去6+6，然后与空字符串连接''以将其转换为字符数组。

JavaScript（ES6），57个字节/ 47（UTF-8）个字符

感谢user5090812节省了10 B

_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`

说明

首先，我们创建一个数组，并用字符串中的字符填充它バ㟐㱰㣈㞸。然后，我们遍历字符串（a具有当前元素的值），并将字符更改为其字符代码。然后，通过将所有值连接到数组中=>。

旧：67个字节

_=>[6,6,6,6,6].map((_,a)=>`バ㟐㱰㣈㞸`.charCodeAt(a)).join`=>`

说明

首先，我们创建一个长度为5的数组。然后，针对字符串中相同索引处的字符的字符代码，在每个索引处更改数组的值，这些值是バ㟐㱰㣈㞸按顺序排列的所有Paul朋友的编号。当我们得到这些时，我们将数组连接在一起，并=>用作分隔符。

用法

要使用它，只需运行以下命令：

f=_=>[...'バ㟐㱰㣈㞸'].map(a=>a.charCodeAt()).join`=>`;alert(f())

输出量

12496=>14288=>15472=>14536=>14264

Ruby，36个字节（26个字符）

p"バ㟐㱰㣈㞸".unpack("U*")*"=>"

因为，为什么不呢。很无聊。

较旧的版本-53字节

p %w(jol mld oim n6b mke).map{|x|x.to_i ~-6*~-6}*'=>'

说明：以25为底的数字编码会给出5个六自由字符串，要对其进行解码，我只需要使用6来表示数字25：（6-1）（6-1）=>〜- 6〜-6

Perl 6的，63 59个字节

{$/=6;$/--;join "=>",<JOL MLD OIM N6B MKE>».parse-base($/*$/)}

{join "=>",<JOL MLD OIM N6B MKE>».parse-base(--($_=6)*$_)}

解码以25为底的数字，因为这是.parse-base（2到36）支持的唯一数字，其中没有一个数字无效。

感谢Neil的-3个字节。

Perl 6的，82 75个字节

{my \a="BXS".parse-base(6*6);join "=>",(a,{sum grep $_%%*,^$_}...^{$_==a if $++})}

{my \a="BXS".parse-base(6*6);join "=>",({$/=$_//a;sum grep $/%%*,^$/}...a)}

解码号码 15472在基数36中，然后通过将每个数字计算为先前数字的适当除数之和来生成序列。

Perl 6，69个字节（47个字符）-无竞争

{"{١٢۴۹6}=>{١۴۲۸۸}=>{١۵۴۷۲}=>{١۴۵۳6}=>{١۴۲6۴}"}

不使用任何禁止的ASCII数字，而是使用阿拉伯语-印度语块中的Unicode数字（每个2字节）！的{ }字符串插值确保他们解析为Perl 6的号码文字，然后字符串化对应的ASCII码表示。

好吧，这是作弊-这就是为什么我不使用它作为主要答案... :)

果冻，5 4字节

ȷṗȷỌ

打印所有五个字符串。利用允许“垃圾”输出的事实，将五个字符串埋入10 ^3003中字符的输出中。

怎么运行的

ȷṗȷỌ  Main link. No arguments.

ȷ     Set the return value to 1000.
 ṗȷ   Cartesian power; form all arrays of length 1000 that consist of integers in
      [1, ..., 1000].
   Ọ  Unordinal; convert all integers to characters.

C，94 84 77字节

笨蛋简单。特别感谢@Neil

g(){char*m="!mnpuryzmpnttyzmqpsnyzmpqoryzmpnrp";for(;*++m;)putchar(*m-66+6);}

f（）{printf（“％d =>％d =>％d =>％d =>％d”，'〜''r'-'d'， '〜''d'-'h'，' 〜” 'R' - 'L'， '〜' 'Z' + 'd'， '〜' * 'T' - 'P'）;}

PHP，73 63 60字节

for(;$c="|`*X6H-$*@"[$i];)echo!!$i&++$i?"=>".!!6:"",ord($c);

用运行-nr。

少一点懒：把字符串列表=>1(ascii)(ascii)
，即：124，96，=>1，42，88，=>1，54，72，=>1，45，36，=>1，42，64，按字符串索引
打印=>1，附加ascii代码

分解

            # loop through string with index $i
for(;$c="|`*X6H-$*@"[$i];)echo
            # string ascii values: 124,96,42,88,54,72,45,36,42,64
    !!$i        # true if $i>0
    &++$i       # odd if (old) $i is 0,2,4,6,8
                # -> true for 2,4,6,8
        ?"=>".!!6   # if true, print "=>1"
        :"",        # else print nothing
    ord($c);    # print ascii value

C ++，92个字节

#include <cstdio>
int main(){for(char c:"UVX]ZabUXV\\abUYX[VabUXYWZabUXVZX")putchar(c-6*6);}

PHP，53字节

<?=join('=>',unpack('v*',gzinflate('�`p������s')));

十六进制转储：

00000000: 3c3f 3d6a 6f69 6e28 273d 3e27 2c75 6e70  <?=join('=>',unp
00000010: 6163 6b28 2776 2a27 2c67 7a69 6e66 6c61  ack('v*',gzinfla
00000020: 7465 2827 bb60 70c1 bcc0 e684 c50e 7300  te('.`p.......s.
00000030: 2729 2929 3b                             ')));

输出：

12496=>14288=>15472=>14536=>14264

说明：

五位整数部分中的每一个均被编码为无符号的短小端字节序，然后串联在一起，并将结果压缩。碰巧会产生一个没有冒犯性数字字符的字节流，然后将其硬编码为字符串。要提取，解压缩流，解压缩两个字节的短裤，将每个字符串解释为字符串，然后使用进行连接>=。

Java 8，134字节

打高尔夫球：

()->{String s="";for(String a:new String[]{"JOL","MLD","OIM","N6B","MKE"}){if(!s.isEmpty())s+=("=>");s+=Long.valueOf(a,25);}return s;}

完整的程序：

import java.util.function.*;

public class FindFiveFriendsToEatChickenWithPaul {

  public static void main(String[] args) {
    System.out.println(toString(() -> {
      String s = "";
      for (String a : new String[] { "JOL", "MLD", "OIM", "N6B", "MKE" }) {
        if (!s.isEmpty()) s += ("=>");
        s += Long.valueOf(a, 25);
      }
      return s;
    }));

  }

  private static String toString(Supplier<String> s) {
    return s.get();
  }

}

批次，191个字节

@set/as=n=66*(66+66+66+6*6)+66/6+66/6+6,u=6/6
@call:t
@call:t
@echo %s: ==^>%
@exit/b
:t
@call:c
:c
@for /l %%i in (%u%,%u%,%n%)do @set/an-=%%i*!(%n%%%%%i)
@set/an=-n
@set s=%s% %n%

我估计，仅使用6s 来计算每个数字将至少需要32个字节，再加上32个字节来全部打印出来，这已经是192个字节，因此我通过计算友好链而获胜。另外，我认为连续五秒%对我来说是一个记录。此外，还可以使用整洁的Batch技巧：在评估循环%n%之前将替换for为，因此循环会计算的所有因子n，并从中减去它们n，从而导致对所需结果的求反。

果冻，12字节

“<ọ’ÆṣÐĿj“=>

打印第四个字符串，不输出其他任何内容。

在线尝试！

怎么运行的

“<ọ’ÆṣÐĿj“=>  Main link. No arguments.

“<ọ’          Yield the 1-based indices of '<' and 'ọ' in Jelly's code page, i.e.,
              [61, 222], and convert the array from base 250 to integer.
              This yields 15472.
      ÐĿ      Iteratively call the link to the left until the results are no longer
              unique and return the array of all unique results.
    Æṣ        Compute the proper digit sum of the previous value (initially 15472).
        j“=>  Join, separating by the string "=>".

Python 2，78 72字节

print''.join(chr(ord(x)-6-6)for x in'=@>DDIJ=A@C>IJ=@A?BIJ=@>B@IJ=>@EB')

编辑 -感谢Stewie Griffin节省了6个字节！

同样，另一种解决方案是输出所有可能的排列。OP说垃圾很好。

from itertools import permutations
print str(list(permutations(''.join(str(x)+'.'for x in range(int('9'*5)).replace(',','').replace('\'','') 
# also 9 and 5 need to be converted using ord and chr

有从转换冗员过多int或list到str。我想这在某些深奥的语言中会比较容易，但是我都不知道。