Angka iblis adalah bilangan bulat positif yang representasi desimalnya hanya terdiri dari 6. Daftar angka iblis dimulai dengan 6, 66, 666, 6666.

Diberikan bilangan bulat positif, hasilkan angka iblis terdekat. Jika ada dua, output yang lebih besar.

Testcases:

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

Ini adalah kode-golf . Jawaban terpendek dalam byte menang.

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

“Itulah sebabnya, saya senang dengan kelemahan [...] Karena ketika saya lemah, maka saya kuat.”

Brachylog , 8 byte

;I≜+{6}ᵐ

Cobalah online!

Penjelasan

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

Port of @orlp jawaban Python 2 yang luar biasa .

Coba di sini.

Saya kira hitungan 66 -bit saya juga iblis. ;)
(Bukan jawaban Java terpendek btw, lihat jawaban @JollyJoker sebagai gantinya.

Jelly , 9 byte

Ẇa6ḌạÐṂ⁸Ṫ

Tautan monadik.

Cobalah online! - Hampir tidak ada gunanya tautan ini (lihat di bawah)!

Bagaimana?

Dalam gaya pegolf sejati, ini benar-benar tidak efisien - ini memukul waktu 60-an di TIO untuk kasus uji 365 ! Secara lokal ini selesai dalam 37-an.

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

Sebuah tambalan untuk membuat algoritma yang sama berjalan dalam batas 60-an untuk 365 dan 366 pada TIO adalah untuk menghindari vektorisasi implisit dari Ḍdengan Ẇa6Ḍ€ạÐṂ⁸Ṫ( coba itu ), namun ini sekarang akan seg-kesalahan untuk input 999 ( Triangle (999) hanya 499.500 tetapi masing-masing adalah daftar bilangan bulat, membuat total Tetrahedral (999) = 166.666.500 bilangan bulat, tidak efisien memori, setidaknya dalam Python).

Jelly , 10 byte

RD6ṁḌạÐṂ¹Ṫ

Cobalah online!

C, 118 byte

Coba Online

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)

Uji kasus

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 Bytes

Fungsi murni:

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

Penjelasan:

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

Iteratif membuat daftar panjang sama dengan input menggunakan NestListmengikuti pola 6+10x(previous_value)mulai dari nilai 6.

                        ~Nearest~#

Kemudian temukan nilai dalam daftar ini yang paling dekat dengan input.

Max[                              ]

Terakhir, ambil nilai maksimum dari daftar nilai terdekat.

Sementara panjang daftar sangat tidak efisien karena matematik dapat bekerja dengan angka panjang presisi yang sewenang-wenang, program ini hanya dibatasi oleh memori fisik.

Template Dianggap Berbahaya , 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>>>

Cobalah online!

Tidak Disatukan:

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 terima kasih kepada Riley

6׌ΣI-Ä}¬

Cobalah online!

Kode di atas dapat memiliki masalah kinerja, ini adalah versi yang sedikit lebih efisien dengan 10 byte: alternatif TIO

Penjelasan

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 byte

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

Neim , 12 10 byte (tidak bersaing)

-1 byte terima kasih kepada steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Penjelasan:

               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

Sayangnya, 𝕔akan mengembalikan nilai yang lebih rendah dalam daftar jika dua angka memiliki perbedaan yang sama, jadi kami harus menambahkan 2 byte ke akun untuk itu.

Non-bersaing sebagai >, <dan ℝditambahkan setelah pertanyaan ini diajukan (dan 𝐥diperbaiki untuk bekerja dengan angka, bukan hanya daftar)

Catatan: Tidak akan berfungsi untuk angka dengan panjang sama dengan 19 atau lebih - karena terlalu besar untuk rindu Java untuk ditangani. (tapi ini nilai yang cukup besar, dan harus baik-baik saja)

Cobalah

Java 8, 37 byte

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

Pergi dengan contoh Kevin Cruijssen dan hanya mengembalikan sebuah String.

Lakukan trik * 3/11 untuk mendapatkan panjang yang tepat, lalu ganti semua dengan enam.

QBIC , 37 27 byte

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

Alih-alih menggunakan Maths ™, ini sekarang menggunakan manipulasi string untuk menemukan jeda di Demonic Domains (36, 366, ...). Terinspirasi oleh jawaban JS @ eush77.

Penjelasan

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

Cobalah online!

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

Ini menggunakan fakta, bahwa kita perlu melompat ke nomor deamonic berikutnya di setiap 36666 ... Dalam bentuk yang lebih mudah dibaca:

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

Menggunakan aritmatika dari solusi Python 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

Saya tidak melihat pertanyaan ini di feed, dan hanya sengaja menemukannya. Inilah jawaban saya:

JavaScript (ES6), 34 byte

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

Tambahkan 1 byte untuk jawaban numerik. Awalnya berdasarkan jawaban ES7 ungolfed ini (37 byte, sudah numerik):

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

Menjengkelkan OP ingin 36 menjadi lebih dekat ke 66 dari 6. Penjelasan: 11/3 = 3.666 ..., jadi membaginya dengan skala ini adalah rentang 7..36, 37..366 dll untuk rentang 1..9.9, 10 ..99.9 dll. Ini dapat dipecahkan secara numerik murni dengan mengambil 2/3 dari yang kurang dari kekuatan 10 berikutnya yang lebih tinggi, meskipun itu golfier untuk memotong, dikonversi ke string, kemudian ubah semua karakter ke angka 6. (Meskipun masih bukan golf seperti jawaban rekursif yang benar-benar pintar.)

CJam, 25 byte

Tidak selambat pengiriman Jelly Jonathan Jonathan, tetapi membutuhkan memori O (n²) , di mana n adalah nomor input. Ya.

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

Ini sama dengan Python berikut:

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

Solusi alternatif, 12 byte

ri)3*B/s,'6*

Ini adalah terjemahan dari algoritma orlp ke dalam CJam.

Penjelasan:

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 Bytes

trim karakter 6

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

Cobalah online!

Alih-alih trim($x=$argn+$i,6)>""Anda dapat menggunakan solusi Regex !preg_match("#^6+$#",$x=$argn+$i)+11 Bytes atau panjang string sama dengan menghitung 6perbandingan strlen($x=$argn+$i)-strspn($x,6)+10 Bytes

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

Wow. Inilah yang Tidak Dijelaskan dan Dijelaskan:

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

Masih wow. Ini beberapa pseudojavascrython untuk Anda.

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

Masih belum mengerti? Program ini pada dasarnya hanya (tidak termasuk input 1-3) membandingkan input ke 3.6 * 10 ^ n, n menjadi panjang input. Jika lebih kecil dari angka itu, ia mencetak jumlah 6s yang kurang dari panjangnya. Jika lebih besar dari atau sama dengan angka itu, jumlah enam adalah panjang saat ini.

Akan senang membantu bermain golf!

Haxe, 70 byte

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

Input harus diteruskan sebagai tipe Floatmeskipun bilangan bulat, jika tidak Haxe akan mengeluh tentang mencoba membagi bilangan bulat (ya haxe akan menolak untuk mengkompilasi jika Anda membagi bilangan bulat dengan apa pun)

Sama seperti semua jawaban lainnya. Kalikan dengan 3, bagi dengan 11, cetak 1 6untuk setiap digit.

Brainfuck, 315 byte

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

Jalankan di sini . Pilih ukuran sel yang dapat menangani nilai 3 * (n + 1), jadi agar semua kasus uji berfungsi, pilih 16. Dinamis (tak terbatas) Memori harus dihidupkan agar ini berfungsi. Ini memungkinkan pita memanjang ke kiri. Untuk memasukkan bilangan bulat, ketikkan input seperti\366untuk n = 366.

Tidak Disatukan:

Menggunakan algoritma yang sama dengan solusi ini . Algoritma yang digunakan untuk setiap langkah individual diambil dari halaman ini . Semua algoritma yang digunakan adalah non-pembungkus, sehingga program tidak akan rusak untuk input yang lebih besar.

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

Cobalah online!

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

Cobalah

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

Agak kecewa dengan panjangnya ini, bisa melakukan hal yang persis sama dengan jawaban yang lebih pendek di Jawa tetapi saya tidak benar-benar memahaminya karena saya adalah pengembang .NET yang malas, bodoh :)