Демоническое число - это положительное целое число, десятичное представление которого состоит только из 6. Список демонических чисел начинается с 6, 66, 666, 6666.

Учитывая положительное целое число, выведите ближайшее демоническое число. Если их два, выведите большее.

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

Это код-гольф . Кратчайший ответ в байтах побеждает.

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 за это .

Желе , 9 байт

Ẇa6ḌạÐṂ⁸Ṫ

Монадическая ссылка.

Попробуйте онлайн! - Почти нет смысла в этой ссылке (см. Ниже)!

Как?

В стиле настоящего игрока в гольф это действительно неэффективно - в TIO время 365 для тестового примера 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 состоит в том, чтобы избежать неявной векторизации Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ( попробуйте это ), однако теперь это вызовет ошибку сегмента для входа 999 ( Triangle (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

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

Попробуйте онлайн!

Ungolfed:

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~#]&

Нейм , 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");

Судя по примеру Кевина Cruijssen в и просто возвращает строку.

Сделайте трюк * 3/11, чтобы получить правильную длину, затем замените все шестерками.

QBIC , 37 27 байт

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

Вместо использования Maths ™ теперь используется манипулирование строками для поиска разрывов в доменах демонов (36, 366, ...). Вдохновлен ответом @ eush77's 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));

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

К сожалению, OP хочет, чтобы 36 было ближе к 66, чем к 6. Объяснение: 11/3 = 3,666 ..., поэтому делим с помощью этого шкалы диапазонов 7,36, 37,3666 и т. Д. До диапазонов 1,9,9,10. ..99.9 и т. Д. Эту проблему можно решить чисто численно, взяв на 2/3 единицу меньше, чем следующая более высокая степень 10, хотя усечь ее лучше, преобразовать в строку, а затем заменить все символы на цифру 6. (Хотя все же не такой гольф, как этот действительно умный рекурсивный ответ.)

CJam, 25 байтов

Не так медленно, как Jonathan Alan's Jelly, но требует 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 + 11 !preg_match("#^6+$#",$x=$argn+$i)байт или длину строки, равную счету 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 - длина входного сигнала. Если оно меньше этого числа, оно печатает число на 6 с на единицу меньше длины. Если оно больше или равно этому числу, число шестерок является текущей длиной.

Хотелось бы помочь в гольф!

Haxe, 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.

Ungolfed:

Использует тот же алгоритм, что и это решение . Алгоритмы, используемые для каждого отдельного шага, взяты из этой страницы . Все используемые алгоритмы не являются переносами, поэтому программа не будет работать при больших входах.

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