Un numero demoniaco è un numero intero positivo la cui rappresentazione decimale è composta da solo 6. L'elenco dei numeri demoniaci inizia con 6, 66, 666, 6666.

Dato un numero intero positivo, genera il numero demoniaco più vicino. Se ce ne sono due, genera quello più grande.

Casi test:

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

Questo è code-golf . Vince la risposta più breve in byte.

Python 2, 28 byte

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

JavaScript (ES6), 31 29 byte

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

"Ecco perché mi diletto nelle debolezze […] Perché quando sono debole, allora sono forte."

Brachylog , 8 byte

;I≜+{6}ᵐ

Provalo online!

Spiegazione

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

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

Port of @orlp stupefacente risposta di Python 2 .

Provalo qui.

Immagino che anche il mio numero di 66 byte sia un demone. ;)
(Non la risposta Java più breve tra l'altro, vedi invece la risposta di @JollyJoker per questo .

Gelatina , 9 byte

Ẇa6ḌạÐṂ⁸Ṫ

Un collegamento monadico.

Provalo online! - Quasi nessun punto in questo link (vedi sotto)!

Come?

Nel vero stile del golfista, questo è veramente inefficiente: colpisce il timeout degli anni '60 in TIO per il test case 365 ! Localmente questo termina in 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)

Una patch per far funzionare lo stesso algoritmo entro il limite degli anni '60 per 365 e 366 su TIO è di evitare la vettorializzazione implicita di Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ( provalo ), tuttavia questo ora seg-fault per un input di 999 ( Triangle (999) è solo 499.500 ma ognuno è un elenco di numeri interi, per un totale di Tetrahedral (999) = 166.666.500 numeri interi, non efficiente in termini di memoria, almeno in Python).

Gelatina , 10 byte

RD6ṁḌạÐṂ¹Ṫ

Provalo online!

C, 118 byte

Prova online

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 byte

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

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

Funzione pura:

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

Spiegazione:

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

Iterativo crea un elenco di lunghezza uguale all'input usando NestListseguendo il modello a 6+10x(previous_value)partire dal valore di 6.

                        ~Nearest~#

Quindi trova il valore in questo elenco più vicino all'input.

Max[                              ]

Infine, prendi il valore massimo dall'elenco dei valori più vicini.

Mentre la lunghezza dell'elenco è super inefficiente in quanto la matematica può funzionare con numeri di lunghezza di precisione arbitrari, questo programma è limitato solo dalla memoria fisica.

Modelli considerati dannosi , 118 byte

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

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

- 1 byte grazie a Riley

6׌ΣI-Ä}¬

Provalo online!

Il codice sopra può avere problemi di prestazioni, ecco una versione leggermente più efficiente con 10 byte: alternativa TIO

Spiegazione

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 byte

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

Neim , 12 10 byte (non concorrenti)

-1 byte grazie a steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Spiegazione:

               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

Sfortunatamente, 𝕔 restituirà il valore più basso in un elenco se due numeri hanno la stessa differenza, quindi abbiamo dovuto aggiungere 2 byte per tenerne conto.

Non competitivi come >, <e ℝsono stati aggiunti dopo che questa domanda è stata posta (ed è 𝐥stata risolta per funzionare con i numeri, non solo con le liste)

Nota: non funzionerà con numeri di lunghezza uguale o superiore a 19, poiché diventano troppo grandi per essere gestiti da Java. (ma questo è un valore abbastanza grande, e dovrebbe andare bene)

Provalo

Java 8, 37 byte

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

Andando per l'esempio di Kevin Cruijssen e solo restituendo una stringa.

Fai il trucco * 3/11 per ottenere la lunghezza giusta, quindi sostituisci tutto con sei.

QBIC , 37 27 byte

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

Invece di usare Maths ™, ora utilizza la manipolazione di stringhe per trovare le interruzioni nei Domini Demoniaci (36, 366, ...). Ispirato dalla risposta JS di @ eush77.

Spiegazione

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

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

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

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

Usa il fatto che dobbiamo saltare al prossimo numero deamonico ogni 36666 ... In una forma più leggibile:

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 byte

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

Utilizzando l'aritmetica dalla soluzione Python di 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

Non ho visto questa domanda nel feed e ci siamo imbattuti per caso. Ecco la mia risposta comunque:

JavaScript (ES6), 34 byte

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

Aggiungi 1 byte per una risposta numerica. Originariamente basato su questa risposta ES7 non golfata (37 byte, già numerica):

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

OP fastidiosamente vuole che 36 sia più vicino a 66 di 6. Spiegazione: 11/3 = 3.666 ..., quindi dividendo per questo scala gli intervalli 7..36, 37..366 ecc. Agli intervalli 1..9.9, 10 ..99.9 ecc. Questo può essere risolto solo numericamente prendendo 2/3 di uno in meno della successiva potenza superiore di 10, anche se è più golfoso troncare, convertire in stringa, quindi cambiare tutti i caratteri nella cifra 6. (Anche se ancora non tanto golfy come quella risposta ricorsiva davvero intelligente.)

CJam, 25 byte

Non è lento come l'invio di Jonathan Alan's Jelly, ma richiede la memoria O (n²) , dove n è il numero di input. Si.

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

Ciò equivale al seguente 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: =-

Soluzione alternativa, 12 byte

ri)3*B/s,'6*

Questa è una traduzione dell'algoritmo di orlp in CJam.

Spiegazione:

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 byte

tagliare il carattere 6

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

Provalo online!

Invece di trim($x=$argn+$i,6)>""te puoi usare una soluzione Regex !preg_match("#^6+$#",$x=$argn+$i)+11 byte o una lunghezza stringa pari al conteggio 6confronto strlen($x=$argn+$i)-strspn($x,6)+10 byte

LOLCODE 1.4, 471 byte

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

Wow. Ecco che Ungolfed e spiegato:

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

Eeeek !!! Ecco alcuni pseudojavascrython per te.

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

Ancora non capisci? Questo programma fondamentalmente solo (esclusi gli ingressi 1-3) confronta l'ingresso con 3,6 * 10 ^ n, n essendo la lunghezza dell'ingresso. Se è inferiore a quel numero, stampa il numero di 6 secondi uno in meno della lunghezza. Se è maggiore o uguale a quel numero, il numero di sei è la lunghezza corrente.

Mi piacerebbe un po 'di aiuto il golf!

Haxe, 70 byte

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

L'input deve essere passato come tipo Floatnonostante sia un numero intero, altrimenti Haxe si lamenterà del tentativo di dividere un numero intero (sì, haxe rifiuterà di compilare se dividi un numero intero per qualcosa)

Come tutte le altre risposte. Moltiplicare per 3, dividere per 11, stampare 1 6per ogni cifra.

Brainfuck, 315 byte

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

Eseguilo qui . Selezionare una dimensione di cella in grado di gestire i valori di 3 * (n + 1), quindi affinché tutti i casi di test funzionino, selezionare 16. La memoria dinamica (infinita) deve essere attivata affinché funzioni. Ciò consente al nastro di espandersi a sinistra. Per inserire un numero intero, digitare l'input like\366 per n = 366.

Ungolfed:

Utilizza lo stesso algoritmo di questa soluzione . Gli algoritmi utilizzati per ogni singolo passaggio sono presi da questa pagina . Tutti gli algoritmi utilizzati sono non-wrapping, quindi il programma non si interromperà per input più grandi.

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

6s×ηs.x

Provalo 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

Japt , 9 byte

_ì e¥6}cU

Provalo

C #, 102 byte

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 po 'deluso dalla lunghezza di questo, potrebbe fare esattamente la stessa della risposta più breve in Java, ma non l'ho capito perché sono uno sviluppatore .NET pigro e stupido :)