Số quỷ là một số nguyên dương có biểu diễn thập phân chỉ bao gồm 6. Danh sách các số quỷ bắt đầu bằng 6, 66, 666, 6666.

Cho một số nguyên dương, xuất ra số quỷ gần nhất. Nếu có hai, đầu ra cái lớn hơn.

Testcase:

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

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Python 2, 28 byte

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

JavaScript (ES6), 31 29 byte

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

Đó là lý do tại sao, tôi thích thú với những điểm yếu [Vượt] Vì khi tôi yếu, thì tôi mạnh.

Brachylog , 8 byte

;I≜+{6}ᵐ

Hãy thử trực tuyến!

Giải trình

;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 byte

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

Cổng @orlp câu trả lời Python 2 tuyệt vời .

Hãy thử nó ở đây.

Tôi đoán số đếm 66 của tôi cũng là một con quỷ. ;)
(Không phải câu trả lời Java ngắn nhất btw, thay vào đó , hãy xem câu trả lời của @JollyJoker cho điều đó.

Thạch , 9 byte

Ẇa6ḌạÐṂ⁸Ṫ

Một liên kết đơn âm.

Hãy thử trực tuyến! - Hầu như không có điểm nào trong liên kết này (xem bên dưới)!

Làm sao?

Theo phong cách của những người chơi gôn thực sự, điều này thực sự không hiệu quả - nó đã hết thời gian 60 năm tại TIO cho trường hợp thử nghiệm 365 ! Tại địa phương này kết thúc trong 37s.

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

Một miếng vá để làm cho chạy thuật toán tương tự trong những năm 60 hạn chế cho 365 và 366 trên TIO là để tránh vectorisation ngầm của Ḍvới Ẇa6Ḍ€ạÐṂ⁸Ṫ( thử mà ), tuy nhiên điều này bây giờ sẽ seg-lỗi cho một đầu vào của 999 ( Triangle (999) chỉ là 499.500 nhưng mỗi số là một danh sách các số nguyên, tạo ra tổng số tứ diện (999) = 166.666.500 số nguyên, không hiệu quả về bộ nhớ, ít nhất là bằng Python).

Thạch , 10 byte

RD6ṁḌạÐṂ¹Ṫ

Hãy thử trực tuyến!

C, 118 byte

Thử trực tuyến

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 byte

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

Các trường hợp thử nghiệm

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

Toán học, 36 byte

Hàm thuần túy:

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

Giải trình:

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

Lặp lại tạo một danh sách độ dài bằng với đầu vào bằng cách sử dụng NestListtheo mẫu 6+10x(previous_value)bắt đầu từ giá trị của 6.

                        ~Nearest~#

Sau đó tìm giá trị trong danh sách này gần nhất với đầu vào.

Max[                              ]

Cuối cùng lấy giá trị tối đa từ danh sách các giá trị gần nhất.

Trong khi độ dài danh sách là siêu kém hiệu quả vì mathicala có thể hoạt động với các số độ dài chính xác tùy ý, chương trình này chỉ bị giới hạn bởi bộ nhớ vật lý.

Các mẫu được coi là có hại , 118 byte

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

Hãy thử trực tuyến!

Ung dung:

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 byte

- 1 byte nhờ Riley

6׌ΣI-Ä}¬

Hãy thử trực tuyến!

Đoạn mã trên có thể có vấn đề về hiệu năng, đây là phiên bản hiệu quả hơn một chút với 10 byte: TIO thay thế

Giải trình

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

Toán học, 76 byte

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

Neim , 12 10 byte (không cạnh tranh)

-1 byte nhờ steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Giải trình:

               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

Thật không may, 𝕔sẽ trả về giá trị thấp hơn trong danh sách nếu hai số có cùng mức chênh lệch, vì vậy chúng tôi đã phải thêm 2 byte vào tài khoản đó.

Không cạnh tranh như >, <và ℝđã được thêm sau khi câu hỏi này được hỏi (và 𝐥đã được sửa để làm việc với các số, không chỉ là danh sách)

Lưu ý: Sẽ không hoạt động đối với các số có độ dài bằng 19 trở lên - vì chúng quá lớn so với thời gian dài của Java để xử lý. (nhưng đây là một giá trị khá lớn và sẽ ổn thôi)

Thử nó

Java 8, 37 byte

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

Đi theo ví dụ của Kevin Cruijssen và chỉ cần trả về một Chuỗi.

Thực hiện thủ thuật * 3/11 để có độ dài phù hợp, sau đó thay thế tất cả bằng sáu.

QBIC , 37 27 byte

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

Thay vì sử dụng Maths ™, giờ đây sử dụng thao tác chuỗi để tìm các ngắt trong Miền quỷ (36, 366, ...). Lấy cảm hứng từ câu trả lời JS của @ eush77.

Giải trình

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

dc , 46 byte

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

Hãy thử trực tuyến!

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 byte

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

Nó sử dụng thực tế, rằng chúng ta cần phải nhảy sang số deamonic tiếp theo ở mỗi 36666 ... Trong một hình thức dễ đọc hơn:

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

braingasm , 15 byte

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

Sử dụng số học từ giải pháp Python của orlp :

;                   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

Tôi đã không nhìn thấy câu hỏi này trong nguồn cấp dữ liệu và chỉ tình cờ tìm thấy nó. Dù sao đây cũng là câu trả lời của tôi:

JavaScript (ES6), 34 byte

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

Thêm 1 byte cho câu trả lời bằng số. Ban đầu dựa trên câu trả lời ES7 vô căn cứ này (37 byte, đã là số):

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

OPoyingly OP muốn 36 gần 66 hơn 6. Giải thích: 11/3 = 3.666 ..., do đó, chia cho tỷ lệ này các phạm vi 7..36, 37..366, v.v. cho các phạm vi 1..9.9, 10 ..99.9, v.v ... Điều này có thể được giải quyết hoàn toàn bằng số bằng cách lấy 2/3 ít hơn một so với công suất cao hơn tiếp theo là 10, mặc dù đó là gôn thủ để cắt, chuyển đổi thành chuỗi, sau đó thay đổi tất cả các ký tự thành chữ số 6. (Mặc dù vẫn không phải là golf như câu trả lời đệ quy thực sự thông minh.)

CJam, 25 byte

Không chậm như trình đệ trình Jelly của Jonathan Alan, nhưng yêu cầu bộ nhớ O (n²) , trong đó n là số đầu vào. Vâng.

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

Điều này tương đương với Python sau:

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: =-

Giải pháp thay thế, 12 byte

ri)3*B/s,'6*

Đây là bản dịch thuật toán của orlp sang CJam.

Giải trình:

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 byte

cắt nhân vật 6

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

Hãy thử trực tuyến!

Thay vì trim($x=$argn+$i,6)>""bạn có thể sử dụng giải pháp Regex !preg_match("#^6+$#",$x=$argn+$i)+11 byte hoặc độ dài chuỗi bằng với phép 6so sánh đếm strlen($x=$argn+$i)-strspn($x,6)+10 byte

LOLCODE 1.4, 471 byte

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

Ồ Đây là Ungolfed và Giải thích:

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

Vẫn wow. Đây là một số pseudojavascrython cho bạn.

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

Vẫn không có được nó? Chương trình này về cơ bản chỉ là (không bao gồm đầu vào 1-3) so sánh đầu vào với 3,6 * 10 ^ n, n là độ dài của đầu vào. Nếu nó nhỏ hơn số đó, nó sẽ in số lượng 6s ít hơn chiều dài. Nếu nó lớn hơn hoặc bằng số đó, số sáu là chiều dài hiện tại.

Rất thích một số trợ giúp chơi golf!

Haxe, 70 byte

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

Đầu vào phải được chuyển thành loại Floatmặc dù là số nguyên, nếu không, Haxe sẽ phàn nàn về việc cố gắng chia số nguyên (có haxe sẽ từ chối biên dịch nếu bạn chia số nguyên cho bất kỳ thứ gì)

Giống như tất cả các câu trả lời khác. Nhân với 3, chia cho 11, in 1 6cho mỗi chữ số.

Brainfuck, 315 byte

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

Chạy nó ở đây . Chọn kích thước ô có thể xử lý các giá trị 3 * (n + 1), vì vậy để tất cả các trường hợp thử nghiệm hoạt động, chọn 16. Bộ nhớ động (vô hạn) phải được bật để điều này hoạt động. Điều này cho phép băng mở rộng sang bên trái. Để nhập một số nguyên, nhập đầu vào như\366 cho n = 366.

Ung dung:

Sử dụng thuật toán tương tự như giải pháp này . Các thuật toán được sử dụng cho từng bước riêng lẻ được lấy từ trang này . Tất cả các thuật toán được sử dụng là không gói, do đó chương trình sẽ không bị hỏng đối với các đầu vào lớn hơn.

,+ # 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 byte

6s×ηs.x

Hãy thử trực tuyến!

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 byte

_ì e¥6}cU

Thử nó

C #, 102 byte

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 thất vọng về độ dài của điều này, có thể làm chính xác như câu trả lời ngắn hơn trong Java nhưng tôi không thực sự hiểu nó vì tôi là một nhà phát triển .NET lười biếng, ngu ngốc :)