Muéstrame el demonio más cercano

42

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 . La respuesta más corta en bytes gana.

Monja permeable
fuente
1
¿Cuál es el número máximo que tenemos que soportar?
Sr. Xcoder
1
@ Mr.Xcoder tan grande como puedas soportar.
Leaky Nun
3
@LeakyNun, aunque no soy un cliente habitual de PPCG, diría que la regla no es realmente buena, porque solo puedo decir "Solo puedo admitir números hasta el 34 porque quería tener el código más corto"
Ferrybig
55
@Ferrybig tan grande como puedas soportar, básicamente tan grande como el idioma te limite.
Leaky Nun
3
Aparentemente, el demonio más cercano es Jörg W Mittag .
user2357112 es compatible con Monica

Respuestas:

51

Python 2, 28 bytes

lambda n:'6'*len(`-~n*3/11`)
orlp
fuente
3
Esa es una buena solución.
Leaky Nun
Wow, eso es impresionante. El mío era de 105 bytes usando el método trivial rip. ¡Agradable!
HyperNeutrino
44
Muy genial. ¿Cómo se te ocurrió este algoritmo?
David Z
Eso es genial. El equivalente en JS es un poco más largo:x=>'6'.repeat((''+-~(x*3/11)).length)
Steve Bennett
8
@DavidZ Sugerencia: el promedio de 666 y 6666 es 3666 3.6666... = 11/3..
orlp
14

JavaScript (ES6), 31 29 bytes

f=(x,s='6')=>x<3+s?s:f(x,s+6)

"Por eso, me deleito en las debilidades [...] Porque cuando soy débil, entonces soy fuerte".

eush77
fuente
Wow, por una vez, la conversión de tipos de Javascript es exactamente lo que necesitas :) Eso es increíble.
Steve Bennett
"Por eso, me deleito en las debilidades [...] Porque cuando soy débil, entonces soy fuerte". ~~ 2 Corintios 12:10
John Dvorak
@JohnDvorak "Por lo tanto, me complacen las enfermedades [...] para cuando soy débil, entonces soy fuerte". suena mejor.
MoustacheMoses
8

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
Fatalizar
fuente
5

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.

Kevin Cruijssen
fuente
El uso de la aritmética de enteros debe ser más corto.
Leaky Nun
1
¡Vamos, golf solo un byte más por favor! : p
Olivier Grégoire
1
Ninguno de sus casos de prueba es correcto.
Leaky Nun
1
@ OlivierGrégoire necesita r = "" como corrección de errores de todos modos, así que obtienes tu deseo :)
JollyJoker
@LeakyNun Oops ... Copié el código incorrecto ... "6"debería haber sido "".
Kevin Cruijssen
4

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

Jonathan Allan
fuente
3

Jalea , 10 bytes

RD6ṁḌạÐṂ¹Ṫ

Pruébalo en línea!

Dennis
fuente
¿No sería un puerto más corto?
Leaky Nun
Traté y obtuve 10 también.
Dennis
oh, ¿es el problema que un espacio necesita ser insertado entre 11 y 6?
Leaky Nun
No estoy seguro de cómo poner 11 y 6 uno al lado del otro; Tal vez me estoy perdiendo algo. Tengo ‘×3:11Ṿ”6ṁpara salida de cadena, ‘×3:11D6ṁḌpara entero.
Dennis
3

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;}
Khaled.K
fuente
97 bytes
techo
3

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

Arnauld
fuente
3

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.

Ian Miller
fuente
3

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>>>
eush77
fuente
3

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
kalsowerus
fuente
Sí, pero luego tuvo problemas de rendimiento en el último caso de prueba. El 60 seg máximo en TIO no fueron suficientes para ejecutarlo a través de):
kalsowerus
@Riley gracias, actualicé mi respuesta :)
kalsowerus
2

Mathematica, 76 bytes

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

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

Okx
fuente
Seguramente puedes hacer que esta respuesta compita ...
Leaky Nun
por ejemplo, ¿funcionaría si lo reemplazaras Γ6Θℝ)con ΓΘ𝐈Γ6)𝐣)?
Leaky Nun
@LeakyNun Lo echaré un vistazo.
Okx
@LeakyNun No, no creo que haya una manera de hacerlo competir, ya que hubo un error (ahora corregido) con bucles integrados.
Okx
¿Quién votó en contra y por qué?
Okx
2

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.

Bromista alegre
fuente
@LeakyNun Por supuesto, tuve que agregar lo -~que debería haber visto diez veces en esta página si hubiera prestado atención ...
JollyJoker
2
Cuento 36 bytes. Su código tiene un punto y coma al final innecesario y un espacio inicial.
Esolanging Fruit
1

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
Steenbergh
fuente
1

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
eush77
fuente
1

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));
Horváth Dávid
fuente
2
Creo que usar aritmética de enteros en lugar de String puede ahorrarle muchos bytes.
Leaky Nun
bueno, puede convertir un número en una cadena en C # simplemente agregando una cadena porque tiene un operador + sobrecargado, como se muestra en mi respuesta de 102 bytes. Tampoco creo que necesite volver a analizarlo en un int como la pregunta nos acaba de pedir que "produzca el número demoníaco más cercano"
lee
1

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
daniero
fuente
1

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

Neil
fuente
1

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
Fruta Esolanging
fuente
1

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

Jörg Hülsermann
fuente
1

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!

OldBunny2800
fuente
0

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.

Skidsdev
fuente
0

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
]
mbomb007
fuente
¿Seguramente n=n*3se puede jugar golf a algo así [->+++<]? ¿Y el algoritmo divmod para dividir por 10?
Jo King
134 bytes , que podrían mejorarse aún más
Jo King
@JoKing Debe usar algoritmos que no sean de envoltura para admitir los casos de prueba más grandes, de modo que su solución no funcione realmente. Hay una razón por la que no usé TIO.
mbomb007
Vaya, eliminaré la parte de envoltura, que era solo el número. 140 bytes (TIO porque es más fácil dar el código) (EOF = 0)
Jo King
0

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
Urna de pulpo mágico
fuente
0

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

sotavento
fuente