恶魔数字是一个正整数，其十进制表示形式仅包含6。恶魔数字列表以6、66、666、6666开头。

给定正整数，输出最接近的恶魔数字。如果有两个，则输出较大的一个。

测试用例：

n   output
1   6
2   6
3   6
6   6
35  6
36  66
37  66
100 66
365 66
366 666
666 666
999 666

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

Python 2，28个字节

lambda n:'6'*len(`-~n*3/11`)

JavaScript（ES6），31个 29字节

f=(x,s='6')=>x<3+s?s:f(x,s+6)

f=(x,s='6')=>x<3+s?s:f(x,s+6)

;[1,2,3,6,35,36,37,100,365,366,666,999,1000].forEach(x=>console.log(x,f(x)))

“这就是为什么我对弱点感到高兴……因为当我变弱时，我就会变得坚强。”

Brachylog，8个字节

;I≜+{6}ᵐ

在线尝试！

说明

;I          The list [Input, I]
  ≜         Assign a value to I: 0, then 1, then -1, then 2, etc.
   +        Sum Input with I
    {6}ᵐ    All its digits must be 6

Java 7，96 93 66字节

String c(int n){String r="";for(n*=11/3;n>1;r+=6,n/=10);return r;}

@orlp的端口惊人的Python 2答案。

在这里尝试。

我猜我的66字节数也是一个恶魔。;）
（不是最简短的 Java答案，请参阅@JollyJoker的答案。

果冻，9 个字节

Ẇa6ḌạÐṂ⁸Ṫ

单子链接。

在线尝试！-此链接几乎没有意义（见下文）！

怎么样？

在真正的高尔夫球手的风格，这是真正的低效率-它击中了60年代超时在TIO为365的测试用例！在本地完成此操作的时间为37秒。

Ẇa6ḌạÐṂ⁸Ṫ - Main link: n
Ẇ         - all sublists - this has an implicit make_range on it's input
          -   so, for example, an input of 3 yields [[1],[2],[3],[1,2],[2,3],[1,2,3]]
          -   the important things are: that it contains both a list of the length of the
          -   decimal number, and a list 1 shorter; and that it's lists only contain
          -   non-zero numbers and are monotonically increasing in length.
  6       - literal 6
 a        - and (vectorises), this changes all the values to 6s
          -    so, the example above becomes [[6],[6],[6],[6,6],[6,6],[6,6,6]]
   Ḍ      - convert to decimal (vectorises)  [ 6,  6,, 6,  66,   66,   666   ]
       ⁸  - link's right argument, n
     ÐṂ   - filter keep those with minimal:
    ạ     -   absolute difference (for 366 this keeps 66 AND 666; same goes for 3666; etc.)
        Ṫ - tail - get the rightmost result (for 366 keeps 666, since it's longer)

为了使相同的算法在TIO上的365和366的60s限制内运行的补丁，是为了避免Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ（try that）的隐式矢量化，但是对于输入999，这现在将出现段错误（Triangle（999）仅499,500，但每个都是整数列表，至少在Python中，总共Tetrahedral（999）= 166,666,500个整数，内存效率不高。

果冻，10字节

RD6ṁḌạÐṂ¹Ṫ

在线尝试！

C，118字节

在线尝试

a;b;d(n,m){return(m*6)+(n>0?d(n-1,m*10):0);}
f(n){a=d((int)log10(n)-1,1);b=d((int)log10(n),1);return(n-a<(b-a)/2)?a:b;}

JavaScript（ES6），41个字节

f=(n,i=0,j=6)=>n*2<j?i||6:f(n-j,i+j,j*10)

测试用例

f=(n,i=0,j=6)=>n*2<j?i||6:f(n-j,i+j,j*10)

console.log(f(1))   // 6
console.log(f(2))   // 6
console.log(f(3))   // 6
console.log(f(6))   // 6
console.log(f(35))  // 6
console.log(f(36))  // 66
console.log(f(37))  // 66
console.log(f(100)) // 66
console.log(f(365)) // 66
console.log(f(366)) // 666
console.log(f(666)) // 666
console.log(f(999)) // 666

Mathematica，36字节

纯功能：

Max[NestList[6+10#&,6,#]~Nearest~#]&

说明：

    NestList[6+10#&,6,#]

使用NestList遵循6+10x(previous_value)从值开始的模式，迭代创建一个长度等于输入的列表6。

                        ~Nearest~#

然后在此列表中找到最接近输入的值。

Max[                              ]

最后，从最近值列表中取最大值。

尽管列表长度效率极低，因为mathematica可以使用任意精度的长度数字工作，但该程序仅受物理内存限制。

认为有害的模板，118个字节

Fun<Ap<Fun<If<lt<A<1>,Add<A<2>,A<3>>>,A<3>,Ap<A<0>,A<1>,Mul<A<2>,I<10>>,Add<Mul<A<3>,I<10>>,I<6>>>>>,A<1>,I<30>,I<6>>>

在线尝试！

取消高尔夫：

Fun<Ap<Fun<If<lt<A<1>, Add<A<2>, A<3>>>,
           A<3>,
           Ap<A<0>, A<1>, Mul<A<2>, I<10>>, Add<Mul<A<3>, I<10>>, I<6>>>>>,
       A<1>, I<30>, I<6>>>

05AB1E，10 9字节

-1字节感谢赖利

6׌ΣI-Ä}¬

在线尝试！

上面的代码可能会出现性能问题，这是一个效率更高的版本，只有10个字节：TIO替代

说明

6׌ΣI-Ä}¬   Main link. Argument n
6×          Push string containing '6' n times
  Π        Push substrings
   Σ   }    Sort by result of code
    I-Ä     Absolute difference between n
        ¬   Head, implicit output

Mathematica，76个字节

Max[Take[LinearRecurrence[{11,-10},{0,6},IntegerLength[#]+1],-2]~Nearest~#]&

Neim，12 10字节（非竞争）

-1字节感谢steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

说明：

               Implicit input: [366]
𝐥               Push the length of the input
                [3]
  𝐈             Inclusive range
                [[1, 2, 3]]
   Γ            For each
       ℝ         Repeat
    6            6
     Θ           currently looped value times
                 [[6, 66, 666]]
          )     End for each
             𝕔  Get the closest value to
           ₁    The first line of input...
            >   ...incremented by one
                [666]
                Implicitly print entire stack

不幸的是，𝕔如果两个数字具有相同的差值，将返回列表中的较低值，因此我们不得不添加2个字节来解决这个问题。

在询问此问题后添加了非竞争性>，<并ℝ添加了该𝐥字符（并且已固定为使用数字，而不仅仅是列表）

注意：对于长度等于或大于19的数字将不起作用-因为它们太大而无法处理Java的长度。（但这是一个很大的值，应该可以）

试试吧

Java 8，37字节

 n->(""+-~n*3/11).replaceAll(".","6");

以Kevin Cruijssen的示例为例，只是返回一个String。

进行* 3/11技巧以获取正确的长度，然后将所有内容替换为六。

QBIC，37 27字节

≈!@36`!<=:|A=A+!6$]?_sA,2,a

现在，它不再使用Maths™，而是使用字符串操作来查找“恶魔域”中的中断（36、366，...）。受@ eush77的JS答案启发。

说明

≈         |  WHILE <condition> 
 !    !        a numerical cast of
  @  `         the string literal A$
   36          starting out as "36"
       <=    is smaller than or equal to
         :   cmd line argument 'a'
A=A+ 6       Add a 6 to the end of A$ (36 ==> 366 ==> 3666)
    ! $         as a string-cast
]            WEND (ends the WHIOLE loop body)
?_sA         PRINT a substring of A$            n=37, A$ = 366
  ,2           starting at index 2                          ^
  ,a           running well past the end of the string      66

直流电，46字节

dsxZ1-10r^d11*2-3/dsylx[0r-]s.<.3*ly+d[6]s.0=.

在线尝试！

dsxZ1-10r^d11*2-3/dsylx[0r-]s.<.3*ly+d[6]s.0=.
   Z1-10r^                                      Nearest power of 10
           11*2-3/                              The number in between 6ⁿ and 6ⁿ6
          d          lx[0r-]s.<.                Check which side we're on
                                3*ly+           Get the answer for x≥3
                                     d[6]s.0=.  Return 6 for x<3

C＃，142个字节

a=>{var c=(a+"").Length;return int.Parse(a<int.Parse(3+new string('6',c==1?2:(c==10?1:c)))?new string('6',c-1):new string('6',c==10?c-1:c));};

它利用这样的事实，我们需要在每36666处跳到下一个重音数字...以更易读的形式：

var c = (a + "").Length; 
    return int.Parse(a < int.Parse(3 + new string('6', 
        c == 1 ? 2 : (c == 10 ? 1 : c))) 
        ? new string('6', c - 1) 
        : new string('6', c == 10 ? c - 1 : c));

脑力激荡，15个字节

;3*11/z+[6:10/]

使用orlp的Python解决方案中的算法：

;                   Read an integer from stdin
 3*11/              Multiply by 3 and divide by 11
      z+            If result is zero, add one
        [6:10/]     While not zero, print '6' and divide by 10

我在Feed中没有看到这个问题，只是偶然发现了这个问题。无论如何，这是我的答案：

JavaScript（ES6），34个字节

n=>`${-~n*3/11|0}`.replace(/./g,6)

为数字答案添加1个字节。最初基于此未解决的ES7答案（37个字节，已经是数字）：

n=>(10**(Math.log10(-~n*3/11)|0)*2-2)/3

令人讨厌的是，OP希望36比6更接近66。说明：11/3 = 3.666 ...，因此用该比例将范围7..36、37..366等缩放为范围1..9.9、10 ..99.9等。这完全可以通过数值解决，方法是比下一个较高的10的幂小2/3，但要截断，转换为字符串然后将所有字符更改为数字6，这是高尔夫球手的事情。不像那个真正聪明的递归答案那样。

CJam，25个字节

不像乔纳森·艾伦（Jonathan Alan）的果冻提交那样慢，但是需要O（n²）内存，其中n是输入数字。是的

ri)__{)'6*i}%f-_:z_:e<#=-

这等效于以下Python：

num = int(input()) + 1                                      # CJam: ri)__
demondiffs = [int("6" * (i + 1)) - num for i in range(num)] # CJam: {)'6*i}%f-
absdiffs = [abs(i) for i in demondiffs]                     # CJam: _:z
mindex = absdiffs.index(min(absdiffs))                      # CJam: _:e<#
print(num - demondiffs[mindex])                             # CJam: =-

替代解决方案，12字节

ri)3*B/s,'6*

这是orlp的算法到CJam的翻译。

说明：

ri           e# Read integer:       | 36
  )          e# Increment:          | 37
   3*        e# Multiply by 3:      | 111
     B/      e# Divide by 0xB (11): | 10
       s     e# Convert to string:  | "10"
        ,    e# String length:      | 2
         '6  e# Push character '6': | 2 '6
           * e# Repeat character:   | "66"
e# Implicit output: 66

PHP，49字节

修剪角色6

for(;trim($x=$argn+$i,6)>"";)$i=($i<1)-$i;echo$x;

在线尝试！

trim($x=$argn+$i,6)>""您可以使用正则表达式解决方案!preg_match("#^6+$#",$x=$argn+$i)+11字节或等于6比较数strlen($x=$argn+$i)-strspn($x,6)+10字节的字符串长度来代替

LOLCODE 1.4，471个字节

HAI 1.4
CAN HAS STRING?
I HAS A i
GIMMEH i
I HAS A l ITZ I IZ STRING'Z LEN YR i MKAY
I HAS A s ITZ "3"
IM IN YR a
BOTH SAEM I IZ STRING'Z LEN YR s MKAY AN l
O RLY?
YA RLY
GTFO
OIC
s R SMOOSH s AN 6
IM OUTTA YR l
I HAS A o
DIFFRINT i AN BIGGR of i AN 4
O RLY?
YA RLY
VISIBLE 6
NO WAI
BOTH SAEM i AN SMALLR of i AN s
O RLY?
YA RLY
o R DIFF OF l AN 1
NO WAI
o R l
OIC
I HAS A f
IM IN YR b UPPIN YR k TIL BOTH SAEM k AN o
f R SMOOSH f AN 6
IM OUTTA YR b
VISIBLE f
OIC
KTHXBYE

哇。这是没有意义的和解释的：

HAI 1.4
CAN HAS STRING?
I HAS A input
GIMMEH input
I HAS A length ITZ I IZ STRING'Z LEN YR input MKAY BTW this is using the length function of the STRING library.
I HAS A sixes ITZ "3" BTW the average of for example [6...] and 6[6...] is 3[6...].
IM IN YR foreverloop BTW this loop fills the sixes variable.
    BOTH SAEM I IZ STRING'Z LEN YR sixes MKAY AN length # In LOLCODE, a statement containing only an expression assigns the implicit variable IT.
    O RLY? # Tests the current value in IT.
      YA RLY
        GTFO
    OIC
    sixes R SMOOSH sixes AN 6 BTW SMOOSH automatically casts things to YARN. It also does not need a MKAY unless there's something after it on the line.
IM OUTTA YR foreverloop
I HAS A outputlength
DIFFRINT input AN BIGGR of input AN 4 BTW LOLCODE doesn't have a built-in inequality operator. This just means input < 4
O RLY?
  YA RLY
    VISIBLE 6 BTW If it's less than 4, the algorithm of comparing to the nearest 3.6*10^n.
  NO WAI
    BOTH SAEM input AN SMALLR of input AN sixes BTW input<=sixes
    O RLY? BTW This if statement makes sure that if the input is less than 3.6*10^length, it goes to the previous place value's demon number.
      YA RLY
        outputlength R DIFF OF length AN 1
      NO WAI
        outputlength R length
    OIC
    I HAS A final
    IM IN YR forloop UPPIN YR iterator TIL BOTH SAEM iterator and outputlength
        final R SMOOSH final AN 6
    IM OUTTA YR forloop
    VISIBLE final
OIC
KTHXBYE

仍然哇。这是为您准备的一些伪javascrython。

hello()
import string
var i
i=input()
var l=string.len(i)
var s="3"
while True:
  if(string.len(s)==l):
    break
  s=s+6
var o
if(i!=max(i,4)): # Basically if(i<4)
  print 6
else:
  if(i==min(i,s)): # Basically if(i<=s)
    o=l-1
  else:
    o=l
  var f
  for(var k=0;k<o;k++):
    f=f+6
  print(f)
exit()

还是不明白吗？该程序基本上只是（不包括输入1-3）将输入与3.6 * 10 ^ n进行比较，n是输入的长度。如果小于该数字，则打印的6s数比长度少一。如果大于或等于该数字，则六位数为当前长度。

希望能帮您打高尔夫球！

Haxe，70个字节

function(x){x*=3;x/=11;do{Sys.print('6');}while((x=Std.int(x/10))>0);}

输入必须作为类型传递，Float尽管它是一个整数，否则Haxe会抱怨试图对整数进行除法（是的，如果将整数除以任何东西，haxe将拒绝编译）

与所有其他答案相同。乘以3，除以11，6每位输出1 。

Brainfuck，315字节

,+>+++[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<+++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]+<[>-]>[<+>->]++++++[<+++++++++>-]<<<[-]++++++++++>[>.<[<<+>>-]<<[>[<<+<+>>>-]<<<[>>>+<<<-]>[<+>>-[<<[-]<+>>>-]<<<[>>>+<<<-]>[>-[>>>-<<<[-]]+<-]>-]>>>+<<]>>]

在这里运行。选择一个可以处理3 *（n + 1）值的像元大小，因此对于所有测试用例，请选择16。动态（无限）内存必须打开才能起作用。这样可以使磁带向左扩展。要输入整数，请输入类似\366n = 366的输入。

取消高尔夫：

使用与此解决方案相同的算法。每个步骤所使用的算法均来自此页面。使用的所有算法都是非包装的，因此对于较大的输入，程序不会中断。

,+ # n = n plus 1
>+++ # 3
[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-] # n = n*3
<+++++++++++ # 10
<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>] # n = n/10
<[-]+<[>-]>[<+>->] # if (n == 0) { n = n plus 1 }
++++++[<+++++++++>-] # '6' (54)
<<<[-]++++++++++> # 10
[ # while (n above 0)
  >.< # print '6'
  [<<+>>-]<<[>[<<+<+>>>-]<<<[>>>+<<<-]>[<+>>-[<<[-]<+>>>-]<<<[>>>+<<<-]>[>-[>>>-<<<[-]]+<-]>-]>>>+<<]>> # n = n/10
]

05AB1E，7个字节

6s×ηs.x

在线尝试！

Program # Input ====================|> 2
--------#---------------------------+--------
6s×     # Push N 6's as a string.   | 66
   ηs   # Prefixes of this.         | [6, 66]
     .x # Closest element to input. | 6

Japt，9个字节

_ì e¥6}cU

试试吧

C＃，102个字节

string a(int j,int k=0)=>(j+"|"+(k=k==0?j:k)).Split('|').Where(s=>s.All(c=>c=='6')).Max()??a(j+1,k-1);

Kinda对它的长度感到失望，它可以与Java中的简短答案完全一样，但是我并没有真正理解它，因为我是一个懒惰，愚蠢的.NET开发人员:)