Демонічне число - це додатне ціле число, десяткове подання якого складається лише з 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)))

"Ось чому я радію слабким сторонам [...] Бо коли я слабкий, то я сильний".

Брахілог , 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 відповідь «s для цього замість.

Желе , 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)

Патч для того, щоб той самий алгоритм запускався в межах 60-х років для 365 і 366 на TIO, це уникати неявної векторизації Ḍз Ẇa6Ḍ€ạÐṂ⁸Ṫ( спробуйте це ), однак тепер це буде seg-помилка для введення 999 ( Трикутник (999) лише 499 500, але кожне - це список цілих чисел, що складає загалом тетраедра (999) = 166 666 500 цілих чисел, неефективна пам'ять, принаймні, в Python).

Желе , 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

Математика, 36 байт

Чиста функція:

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

Пояснення:

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

Ітеративне створення списку довжини, рівного вводу, використовуючи NestListнаступний зразок, 6+10x(previous_value)починаючи зі значення 6.

                        ~Nearest~#

Потім знайдіть значення в цьому списку, найближче до вхідного.

Max[                              ]

Нарешті, взяти максимальне значення зі списку найближчих значень.

Хоча довжина списку дуже неефективна, оскільки математика може працювати з довільними числами точності довжини, ця програма обмежена лише фізичною пам'яттю.

Шаблони вважаються шкідливими , 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

Математика, 76 байт

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

Нейм , 12 10 байт (неконкуренто)

-1 байт завдяки Стінбергу

𝐥𝐈Γ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");

Перехід за прикладом Кевіна Круїссена і просто повернення рядка.

Виконайте трюк * 3/11, щоб отримати правильну довжину, а потім замініть всі на шість.

QBIC , 37 27 байт

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

Замість використання Maths ™ тепер використовується стрипова маніпуляція для пошуку перерв у доменах Demonic (36, 366, ...). Натхненний JS-відповіддю @ eush77.

Пояснення

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

braingasm , 15 байт

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

Використання арифметики з рішення 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

Я не бачив цього питання у стрічці, і лише наткнувся на нього випадково. Ось моя відповідь все одно:

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

Дратівливо ОП хоче, щоб 36 було ближче до 66, ніж 6. Пояснення: 11/3 = 3.666 ..., тому ділення за цією шкалою діапазонів 7..36, 37..366 і т.д. на діапазони 1..9.9, 10 ..99.9 і т. Д. Це можна вирішити чисто числом, взявши на 2/3 один менший, ніж наступний більший показник на 10, хоча гольфіст урізати, перетворити на рядок, а потім змінити всі символи на цифру 6. (Хоча все-таки не настільки гофрований, як справді хитра рекурсивна відповідь.)

CJam, 25 байт

Не так повільно, як подача Джонатана Алана на желе, але вимагає пам'яті 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)>""ви можете використовувати рішення Regex !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

Ого. Ось, що Ungolfed і пояснив:

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

Ще вау. Ось декілька псевдоеваскритон для вас.

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 на менше довжини. Якщо воно більше або дорівнює цьому числу, число шістдесят - це поточна довжина.

Дуже хотів би допомогти гольфу!

Хакс, 70 байт

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

Введення має бути передано як тип, Floatнезважаючи на ціле число, інакше Haxe поскаржиться на спробу поділити ціле число (так, haxe відмовиться від компіляції, якщо ви поділите ціле число на що-небудь)

Те саме, що і всі інші відповіді. Помножте на 3, розділіть на 11, надрукуйте 1 6на кожну цифру.

Brainfuck, 315 байт

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

Виконати його тут . Виберіть розмір комірки, який може обробляти значення 3 * (n + 1), тому для роботи всіх тестових випадків виберіть 16.Для цього спрацьовує потрібно включити динамічну (нескінченну) пам'ять . Це дозволяє стрічці розширити ліворуч. Щоб ввести ціле число, введіть вхід як\366 n = 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);

Нібито розчарований у тривалості цього, міг зробити точно так само, як і коротша відповідь на Java, але я не дуже цього зрозумів, бо я ледачий, дурний розробник .NET :)