Un nombre démoniaque est un entier positif dont la représentation décimale est constituée de 6. La liste des nombres démoniaques commence par 6, 66, 666, 6666.

Étant donné un entier positif, indiquez le nombre démoniaque le plus proche. S'il y en a deux, affichez le plus gros.

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

C'est du code-golf . La réponse la plus courte en octets l'emporte.

Python 2, 28 octets

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

JavaScript (ES6), 31 29 octets

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

"C'est pourquoi, je me délecte de faiblesses […] Car quand je suis faible, alors je suis fort."

Brachylog , 8 octets

;I≜+{6}ᵐ

Essayez-le en ligne!

Explication

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

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

Port de @orlp incroyable réponse Python 2 .

Essayez ici.

Je suppose que mon compte de 66 octets est également un démon. ;)
(Ce n'est pas la réponse la plus courte en Java, voir la réponse de @JollyJoker pour cela à la place.

Gelée , 9 octets

Ẇa6ḌạÐṂ⁸Ṫ

Un lien monadique.

Essayez-le en ligne! - Presque pas de point dans ce lien (voir ci-dessous)!

Comment?

Dans le style des vrais golfeurs, cela est vraiment inefficace - il arrive à la fin des années 60 chez TIO pour le scénario de test 365 ! Localement cela se termine en 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)

Un patch pour faire le même parcours de l' algorithme dans les années 60 limite pour 365 et 366 sur TIO est d'éviter la vectorisation implicite Ḍavec Ẇa6Ḍ€ạÐṂ⁸Ṫ( essayer ), mais cela va maintenant seg-faute pour une entrée de 999 ( Triangle (999) est seulement 499,500 mais chacun est une liste d’entiers, ce qui donne un total de Tetrahedral (999) = 166 666 500 entiers, ce qui optimise la mémoire, du moins en Python).

Gelée , 10 octets

RD6ṁḌạÐṂ¹Ṫ

Essayez-le en ligne!

C, 118 octets

Essayez en ligne

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 octets

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

Cas de test

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 octets

Fonction pure:

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

Explication:

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

Itératif créer une liste de longueur égale à l'entrée en NestListsuivant le modèle à 6+10x(previous_value)partir de la valeur 6.

                        ~Nearest~#

Trouvez ensuite la valeur dans cette liste la plus proche de l’entrée.

Max[                              ]

Enfin, prenez la valeur maximale dans la liste des valeurs les plus proches.

Tandis que la longueur de la liste est super inefficace car mathematica peut travailler avec des nombres de longueur de précision arbitraire, ce programme n’est limité que par la mémoire physique.

Modèles considérés comme nuisibles , 118 octets

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

Essayez-le en ligne!

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 octets

- 1 octet grâce à Riley

6׌ΣI-Ä}¬

Essayez-le en ligne!

Le code ci-dessus peut avoir des problèmes de performances, voici une version un peu plus efficace avec 10 octets: Alternative TIO

Explication

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 octets

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

Neim , 12 à 10 octets (non en concurrence)

-1 octet grâce à steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Explication:

               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

Malheureusement, 𝕔 nous renverrons la valeur la plus basse dans une liste si deux nombres ont la même différence. Nous avons donc dû ajouter 2 octets pour en tenir compte.

Non en concurrence comme >, <et ℝont été ajoutés après cette question a été posée (et𝐥 été corrigé pour fonctionner avec des nombres, pas seulement des listes)

Remarque: ne fonctionnera pas pour les nombres de longueur égale ou supérieure à 19, car ils deviennent trop volumineux pour les longs traitements de Java. (mais c'est une valeur assez importante, et ça devrait aller)

L'essayer

Java 8, 37 octets

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

En passant par l'exemple de Kevin Cruijssen et juste retourner une chaîne.

Faites l’astuce * 3/11 pour obtenir la bonne longueur, puis remplacez-les tous par des six.

QBIC , 37 27 octets

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

Au lieu d'utiliser Maths ™, il utilise maintenant la manipulation de chaînes pour trouver les ruptures dans les domaines démoniaques (36, 366, ...). Inspiré par la réponse JS de @ eush77.

Explication

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

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

Essayez-le en ligne!

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 octets

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

Il utilise le fait que nous devons passer au prochain numéro deamonique tous les 36666 ... sous une forme plus lisible:

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 octets

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

Utilisation de l'arithmétique de la solution Python d' 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

Je n'ai pas vu cette question dans le fil, et je suis tombé dessus par hasard. Voici ma réponse quand même:

JavaScript (ES6), 34 octets

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

Ajoutez 1 octet pour une réponse numérique. Initialement basé sur cette réponse ESG non golfée (37 octets, déjà numérique):

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

De façon ennuyeuse, OP veut que 36 soit plus proche de 66 que de 6. Explication: 11/3 = 3.666 ..., divisant ainsi par ceci les échelles des gammes 7..36, 37..366, etc. aux gammes 1..9.9, 10 ..99.9 etc. Cela peut être résolu purement numériquement en prenant 2/3 de moins que la puissance immédiatement supérieure de 10, bien qu'il soit plus difficile de tronquer, de convertir en chaîne, puis de changer tous les caractères en chiffre 6. ( pas aussi ludique que cette réponse récursive vraiment intelligente.)

CJam, 25 octets

Pas aussi lent que la soumission de Jonathan Alan Jelly, mais nécessite de la mémoire O (n²) , où n est le nombre entré. Ouais.

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

Ceci est équivalent au Python suivant:

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

Solution alternative, 12 octets

ri)3*B/s,'6*

Ceci est une traduction de l'algorithme de orlp dans CJam.

Explication:

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 octets

couper le personnage 6

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

Essayez-le en ligne!

Au lieu de, trim($x=$argn+$i,6)>""vous pouvez utiliser une solution Regex !preg_match("#^6+$#",$x=$argn+$i)+11 octets ou une longueur de chaîne égale à la 6comparaison de comptage strlen($x=$argn+$i)-strspn($x,6)+10 octets.

LOLCODE 1.4, 471 octets

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

Sensationnel. Voici que 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

Encore wow. Voici quelques pseudojavascrython pour vous.

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

Tu ne comprends toujours pas? Ce programme fondamentalement juste (en excluant les entrées 1-3) compare l’entrée à 3.6 * 10 ^ n, n étant la longueur de l’entrée. S'il est inférieur à ce nombre, le nombre de 6 est inférieur à la longueur. S'il est supérieur ou égal à ce nombre, le nombre de six est la longueur actuelle.

J'adorerais une aide au golf!

Haxe, 70 octets

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

L'entrée doit être passée en tant que type Float alors qu'elle est un entier, sinon Haxe se plaindra d'essayer de diviser un entier (oui, haxe refusera de compiler si vous divisez un entier par quelque chose).

Identique à toutes les autres réponses. Multipliez par 3, divisez par 11, imprimez 1 6pour chaque chiffre.

Brainfuck, 315 octets

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

Exécutez-le ici . Sélectionnez une taille de cellule pouvant gérer des valeurs de 3 * (n + 1). Par conséquent, pour que tous les scénarios de test fonctionnent, sélectionnez 16. La mémoire dynamique (infinie) doit être activée pour que cela fonctionne. Cela permet à la bande de s’étendre vers la gauche. Pour saisir un entier, tapez l'entrée comme suit:\366 pour n = 366.

Ungolfed:

Utilise le même algorithme que cette solution . Les algorithmes utilisés pour chaque étape sont extraits de cette page . Tous les algorithmes utilisés ne sont pas wrappés, afin que le programme ne casse pas pour des entrées plus volumineuses.

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

6s×ηs.x

Essayez-le en ligne!

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 octets

_ì e¥6}cU

L'essayer

C #, 102 octets

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 peu déçu par la longueur de ce document, je pouvais faire exactement la même chose que la réponse plus courte en Java, mais je ne le comprenais pas vraiment car je suis un développeur .NET stupide et stupide :)