Un número demoníaco es un número entero positivo cuya representación decimal consta de solo 6. La lista de números demoníacos comienza con 6, 66, 666, 6666.

Dado un entero positivo, genera el número demoníaco más cercano. Si hay dos, produzca el más grande.

Casos de prueba:

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

Este es el código de golf . La respuesta más corta en bytes gana.

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 eso, me deleito en las debilidades [...] Porque cuando soy débil, entonces soy fuerte".

Brachylog , 8 bytes

;I≜+{6}ᵐ

Pruébalo en línea!

Explicación

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

Puerto de @orlp increíble Python 2 respuesta .

Pruébalo aquí

Supongo que mi conteo de 66 bytes también es un demonio. ;)
(No es la respuesta más corta de Java por cierto, vea la respuesta de @JollyJoker para eso en su lugar.

Jalea , 9 bytes

Ẇa6ḌạÐṂ⁸Ṫ

Un enlace monádico.

Pruébalo en línea! - Casi no tiene sentido en este enlace (ver más abajo)!

¿Cómo?

En el verdadero estilo de golfista, esto es realmente ineficiente: ¡llega al tiempo de espera de 60 en TIO para el caso de prueba 365 ! A nivel local, esto termina en 37 s.

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

Un parche para hacer que el mismo algoritmo se ejecute dentro del límite de 60 para 365 y 366 en TIO es evitar la vectorización implícita de Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ( intente eso ), sin embargo, esto ahora seg-falla para una entrada de 999 ( Triangle (999) es solo 499,500 pero cada uno es una lista de enteros, lo que hace un total de Tetrahedral (999) = 166,666,500 enteros, no eficientes en memoria, al menos en Python).

Jalea , 10 bytes

RD6ṁḌạÐṂ¹Ṫ

Pruébalo en línea!

C, 118 bytes

Probar en línea

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 prueba

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

Función pura:

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

Explicación:

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

Iterative crea una lista de longitud igual a la entrada usando NestListsiguiendo el patrón 6+10x(previous_value)comenzando desde el valor de 6.

                        ~Nearest~#

Luego encuentre el valor en esta lista más cercano a la entrada.

Max[                              ]

Por último, tome el valor máximo de la lista de valores más cercanos.

Si bien la longitud de la lista es super ineficiente ya que Mathica puede trabajar con números de longitud de precisión arbitraria, este programa solo está limitado por la memoria física.

Plantillas consideradas dañinas , 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>>>

Pruébalo en línea!

Sin golf:

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 gracias a Riley

6׌ΣI-Ä}¬

Pruébalo en línea!

El código anterior puede tener problemas de rendimiento, aquí hay una versión un poco más eficiente con 10 bytes: alternativa TIO

Explicación

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

-1 byte gracias a steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Explicación:

               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

Desafortunadamente, 𝕔 devolverá el valor más bajo en una lista si dos números tienen la misma diferencia, por lo que tuvimos que agregar 2 bytes para dar cuenta de eso.

No competido como >, <y ℝse agregaron después de que se hizo esta pregunta (y𝐥 se corrigió para trabajar con números, no solo con listas)

Nota: No funcionará para números con una longitud igual a 19 o más, ya que se vuelven demasiado grandes para que los largos de Java puedan manejarlos. (pero este es un valor bastante grande, y debería estar bien)

Intentalo

Java 8, 37 bytes

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

Siguiendo el ejemplo de Kevin Cruijssen y simplemente devolviendo un String.

Haz el truco * 3/11 para obtener la longitud correcta, luego reemplaza todo con seises.

QBIC , 37 27 bytes

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

En lugar de usar Maths ™, esto ahora usa la manipulación de cadenas para encontrar los descansos en los Dominios Demoníacos (36, 366, ...). Inspirado por la respuesta JS de @ eush77.

Explicación

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

cc , 46 bytes

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

Pruébalo en línea!

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

Utiliza el hecho de que necesitamos saltar al siguiente número deamónico en cada 36666 ... En una forma más legible:

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 la aritmética de la solución Python de 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

No vi esta pregunta en el feed, y solo tropecé con ella por accidente. Aquí está mi respuesta de todos modos:

JavaScript (ES6), 34 bytes

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

Agregue 1 byte para una respuesta numérica. Originalmente basado en esta respuesta ES7 sin golf (37 bytes, ya numérica):

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

Molesto, OP quiere que 36 esté más cerca de 66 que de 6. Explicación: 11/3 = 3.666 ..., así que dividiendo entre esto, se escalan los rangos 7..36, 37..366 etc. a los rangos 1..9.9, 10 ..99.9 etc. Esto se puede resolver puramente numéricamente tomando 2/3 de uno menos que la siguiente potencia más alta de 10, aunque es más golfoso truncar, convertir a cadena y luego cambiar todos los caracteres al dígito 6. (Aunque todavía no tan elegante como esa respuesta recursiva realmente inteligente).

CJam, 25 bytes

No es tan lento como la presentación de Jonathan Alan's Jelly, pero requiere memoria O (n²) , donde n es el número de entrada. Sí.

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

Esto es equivalente al siguiente 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: =-

Solución alternativa, 12 bytes.

ri)3*B/s,'6*

Esta es una traducción del algoritmo de orlp a CJam.

Explicación:

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

recortar el personaje 6

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

Pruébalo en línea!

En lugar de trim($x=$argn+$i,6)>""usar una solución Regex !preg_match("#^6+$#",$x=$argn+$i)+11 Bytes o una longitud de cadena igual a la 6comparación de conteo 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

Guau. Aquí está eso Ungolfed y explicado:

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

Aún guau. Aquí hay algunos pseudojavascrython para ti.

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

¿Aún no lo entiendes? Este programa básicamente solo (excluyendo las entradas 1-3) compara la entrada con 3.6 * 10 ^ n, siendo n la longitud de la entrada. Si es menor que ese número, imprime el número de 6s uno menos que la longitud. Si es mayor o igual que ese número, el número de seises es la longitud actual.

Me encantaría un poco de ayuda al golf!

Haxe, 70 bytes

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

La entrada debe pasarse como tipo Float pesar de ser un número entero, de lo contrario, Haxe se quejará de intentar dividir un número entero (sí, haxe se negará a compilar si divide un número entero por algo)

Igual que todas las otras respuestas. Multiplique por 3, divida por 11, imprima 1 6por cada dígito.

Brainfuck, 315 bytes

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

Ejecútalo aquí . Seleccione un tamaño de celda que pueda manejar valores de 3 * (n + 1), por lo que para que todos los casos de prueba funcionen, seleccione 16. Memoria dinámica (infinita) debe estar activada para que esto funcione. Esto permite que la cinta se expanda hacia la izquierda. Para ingresar un número entero, escriba la entrada como\366 para n = 366.

Sin golf:

Utiliza el mismo algoritmo que esta solución . Los algoritmos utilizados para cada paso individual se toman de esta página . Todos los algoritmos utilizados no se ajustan, por lo que el programa no se romperá para entradas más grandes.

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

Pruébalo en línea!

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 bytes

_ì e¥6}cU

Intentalo

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

Un poco decepcionado por la duración de esto, podría hacer exactamente lo mismo que la respuesta más corta en Java, pero realmente no lo entendí porque soy un desarrollador .NET perezoso y estúpido :)