Um número demoníaco é um número inteiro positivo cuja representação decimal consiste em apenas 6. A lista de números demoníacos começa com 6, 66, 666, 6666.

Dado um número inteiro positivo, imprima o número demoníaco mais próximo. Se houver dois, produza o maior.

Casos de teste:

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

Isso é código-golfe . A resposta mais curta em bytes vence.

Python 2, 28 bytes

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

JavaScript (ES6), 31 29 bytes

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

"É por isso que me deleito com as fraquezas [...] pois quando sou fraco, sou forte."

Braquilog , 8 bytes

;I≜+{6}ᵐ

Experimente online!

Explicação

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

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

Porto do @orlp incrível resposta em Python 2 .

Experimente aqui.

Acho que minha contagem de 66 bytes também é um demônio. ;)
(Não é a resposta Java mais curta, veja a resposta de @JollyJoker para isso .

Geléia , 9 bytes

Ẇa6ḌạÐṂ⁸Ṫ

Um link monádico.

Experimente online! - Quase nenhum ponto neste link (veja abaixo)!

Quão?

No verdadeiro estilo de golfista, isso é realmente ineficiente - chega aos 60 anos no TIO para o caso de teste 365 ! Localmente, isso termina em 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)

Um patch para executar o mesmo algoritmo dentro do limite dos anos 60 para 365 e 366 no TIO é evitar a vetorização implícita de Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ( tente isso ), no entanto, isso agora causará uma falha seg para uma entrada de 999 ( Triangle (999) é apenas 499.500, mas cada um é uma lista de números inteiros, perfazendo um total de Tetraédrico (999) = 166.666.500 números inteiros, sem economia de memória, pelo menos em Python).

Gelatina , 10 bytes

RD6ṁḌạÐṂ¹Ṫ

Experimente online!

C, 118 bytes

Experimente on-line

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 bytes

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

Casos de teste

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

Função pura:

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

Explicação:

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

Iterativa Crie uma lista de comprimento igual à entrada usando NestListo padrão 6+10x(previous_value)a partir do valor de 6.

                        ~Nearest~#

Em seguida, encontre o valor nesta lista mais próximo da entrada.

Max[                              ]

Por fim, pegue o valor máximo da lista de valores mais próximos.

Embora o tamanho da lista seja super ineficiente, pois o mathematica pode trabalhar com números arbitrários de comprimento de precisão, este programa é limitado apenas pela memória física.

Modelos considerados nocivos , 118 bytes

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

Experimente online!

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 bytes

- 1 byte graças a Riley

6׌ΣI-Ä}¬

Experimente online!

O código acima pode ter problemas de desempenho, eis uma versão um pouco mais eficiente com 10 bytes: alternativa TIO

Explicação

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 bytes

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

Neim , 12 10 bytes (não concorrente)

-1 byte graças a steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Explicação:

               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

Infelizmente, 𝕔 retornará o valor mais baixo em uma lista se dois números tiverem a mesma diferença; portanto, tivemos que adicionar 2 bytes para explicar isso.

Não concorrentes como >, <e ℝforam adicionados após esta pergunta foi feita (e𝐥 foi fixado para trabalhar com números, e não apenas listas)

Nota: Não funcionará para números com um comprimento igual a 19 ou mais - pois eles ficam grandes demais para os comprimentos de Java. (mas esse é um valor bastante grande e deve ficar bom)

Tente

Java 8, 37 bytes

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

Seguindo o exemplo de Kevin Cruijssen e retornando uma String.

Faça o truque * 3/11 para obter o comprimento certo e substitua todos por seis.

QBIC , 37 27 bytes

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

Em vez de usar o Maths ™, agora ele usa manipulação de strings para encontrar as quebras nos domínios demoníacos (36, 366, ...). Inspirado na resposta JS de @ eush77.

Explicação

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

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

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

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

Ele usa o fato de que precisamos pular para o próximo número deamônico a cada 36666 ... De uma forma mais legível:

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 bytes

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

Usando a aritmética da solução Python da 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

Não vi essa pergunta no feed e só a tropecei por acidente. Aqui está a minha resposta de qualquer maneira:

JavaScript (ES6), 34 bytes

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

Adicione 1 byte para uma resposta numérica. Originalmente, com base nesta resposta ES7 não destruída (37 bytes, já numérica):

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

Irritantemente, o OP quer que 36 estejam mais próximos de 66 que 6. Explicação: 11/3 = 3.666 ..., então dividir por isso escala os intervalos 7..36, 37..366 etc. aos intervalos 1..9.9, 10 ..99.9 etc. Isso pode ser resolvido puramente numericamente, usando 2/3 de um a menos que a próxima potência mais alta de 10, embora seja mais complicado truncar, converter em sequência e alterar todos os caracteres para o dígito 6. (Embora ainda não tão golfista quanto a resposta recursiva realmente inteligente.)

CJam, 25 bytes

Não é tão lento quanto o envio de Jonathan Alan's Jelly, mas requer memória O (n²) , onde n é o número de entrada. Sim.

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

Isso é equivalente ao seguinte 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: =-

Solução alternativa, 12 bytes

ri)3*B/s,'6*

Esta é uma tradução do algoritmo do orlp para CJam.

Explicação:

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

aparar o personagem 6

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

Experimente online!

Em vez de trim($x=$argn+$i,6)>""você pode usar uma solução Regex !preg_match("#^6+$#",$x=$argn+$i)+11 Bytes ou um comprimento da corda igualar a contagem 6comparação strlen($x=$argn+$i)-strspn($x,6)+10 Bytes

LOLCODE 1.4, 471 bytes

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

Uau. Aqui está o Ungolfed and Explained:

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

Ainda uau. Aqui está um pseudojavascrython para você.

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

Ainda não entendeu? Este programa basicamente apenas (excluindo as entradas 1 a 3) compara a entrada com 3,6 * 10 ^ n, sendo n o comprimento da entrada. Se for menor que esse número, imprime o número de 6s um a menos que o comprimento. Se for maior ou igual a esse número, o número de seis é o comprimento atual.

Adoraria alguma ajuda no golfe!

Haxe, 70 bytes

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

A entrada deve ser passada como tipo Float apesar de ser um número inteiro; caso contrário, o Haxe se queixará de tentar dividir um número inteiro (sim, o haxe se recusará a compilar se você dividir um número inteiro por qualquer coisa)

O mesmo que todas as outras respostas. Multiplique por 3, divida por 11, imprima 1 6para cada dígito.

Brainfuck, 315 bytes

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

Execute-o aqui . Selecione um tamanho de célula que possa manipular valores de 3 * (n + 1), para que todos os casos de teste funcionem, selecione 16. A memória dinâmica (infinita) deve estar ativada para que isso funcione. Isso permite que a fita se expanda para a esquerda. Para inserir um número inteiro, digite a entrada como\366 para n = 366.

Ungolfed:

Usa o mesmo algoritmo que esta solução . Os algoritmos usados ​​para cada etapa individual são obtidos nesta página . Todos os algoritmos usados ​​são não empacotáveis, para que o programa não seja interrompido por entradas maiores.

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

6s×ηs.x

Experimente 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

Japonês , 9 bytes

_ì e¥6}cU

Tente

C #, 102 bytes

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

Meio decepcionado com a extensão disso, poderia fazer exatamente o mesmo que a resposta mais curta em Java, mas eu realmente não entendi porque sou um desenvolvedor .NET preguiçoso e estúpido :)