Eine dämonische Zahl ist eine positive Ganzzahl, deren Dezimaldarstellung nur aus 6 besteht. Die Liste der dämonischen Zahlen beginnt mit 6, 66, 666, 6666.

Geben Sie bei einer positiven Ganzzahl die nächste dämonische Zahl aus. Wenn zwei vorhanden sind, geben Sie den größeren aus.

Testfälle:

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

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt.

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

„Deshalb freue ich mich über Schwächen […] Denn wenn ich schwach bin, bin ich stark.“

Brachylog , 8 Bytes

;I≜+{6}ᵐ

Probieren Sie es online!

Erläuterung

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

Hafen von @orlp erstaunliche Python 2 Antwort .

Probieren Sie es hier aus.

Ich denke, meine 66- Byte-Zahl ist auch ein Dämon. ;)
(Nicht die kürzeste Java-Antwort übrigens, siehe stattdessen die Antwort von @JollyJoker .

Gelee , 9 Bytes

Ẇa6ḌạÐṂ⁸Ṫ

Eine monadische Verbindung.

Probieren Sie es online! - Fast kein Punkt in diesem Link (siehe unten)!

Wie?

Im Stil eines echten Golfspielers ist dies wirklich ineffizient - es ist die 60er-Jahre-Pause bei TIO für den 365- Testfall! Vor Ort endet dies 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)

Ein Patch, mit dem derselbe Algorithmus für 365 und 366 auf TIO innerhalb der 60er-Grenze ausgeführt werden kann , soll die implizite Vektorisierung von Ḍwith Ẇa6Ḍ€ạÐṂ⁸Ṫ( versuchen Sie das ) vermeiden. Dies wird jedoch jetzt bei einer Eingabe von 999 ( Triangle (999) nur fehlschlagen 499.500, aber jedes ist eine Liste von Ganzzahlen, was insgesamt Tetraeder (999) = 166.666.500 Ganzzahlen ergibt (nicht speichereffizient, zumindest in Python).

Gelee , 10 Bytes

RD6ṁḌạÐṂ¹Ṫ

Probieren Sie es online!

C 118 Bytes

Versuchen Sie es 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)

Testfälle

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

Reine Funktion:

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

Erläuterung:

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

Iterativ erstellen Sie eine Liste mit einer Länge, die der Eingabe entspricht. NestListFolgen Sie dabei dem Muster, 6+10x(previous_value)beginnend mit dem Wert von 6.

                        ~Nearest~#

Suchen Sie dann in dieser Liste den Wert, der der Eingabe am nächsten liegt.

Max[                              ]

Zuletzt den Maximalwert aus der Liste der nächstgelegenen Werte entnehmen.

Während die Listenlänge sehr ineffizient ist, da Mathematica mit beliebig genauen Längenangaben arbeiten kann, ist dieses Programm nur durch den physischen Speicher begrenzt.

Als schädlich eingestufte Vorlagen , 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>>>

Probieren Sie es 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 danke an Riley

6׌ΣI-Ä}¬

Probieren Sie es online!

Der obige Code kann Leistungsprobleme verursachen. Hier ist eine etwas effizientere Version mit 10 Bytes: TIO-Alternative

Erläuterung

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

-1 Byte dank steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Erläuterung:

               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

Unglücklicherweise, 𝕔 wird der niedrigere Wert in einer Liste zurückgegeben, wenn zwei Zahlen den gleichen Unterschied aufweisen, sodass wir 2 Bytes hinzufügen mussten, um dies zu berücksichtigen.

Nichtkonkurrierende wie >, <und ℝwurden hinzugefügt , nachdem diese Frage gestellt wurde (und 𝐥wurde an der Arbeit mit Zahlen festgelegt, nicht nur Listen)

Hinweis: Funktioniert nicht für Zahlen mit einer Länge von 19 oder mehr, da sie für Javas Longs zu groß werden. (aber das ist ein ziemlich großer Wert und sollte in Ordnung sein)

Versuch es

Java 8, 37 Bytes

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

Nach dem Beispiel von Kevin Cruijssen und einfach einen String zurückgeben.

Führen Sie den * 3/11-Trick aus, um die richtige Länge zu erhalten, und ersetzen Sie dann alle durch Sechser.

QBIC , 37 27 Bytes

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

Anstatt Maths ™ zu verwenden, wird jetzt die Zeichenfolge bearbeitet, um die Unterbrechungen in den dämonischen Domänen (36, 366, ...) zu finden. Inspiriert von der JS-Antwort von @ eush77.

Erläuterung

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

Gleichstrom , 46 Bytes

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

Probieren Sie es 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

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

Es nutzt die Tatsache, dass wir alle 36666 zur nächsten deamonischen Zahl springen müssen ... In einer besser lesbaren Form:

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

Braingasmus , 15 Bytes

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

Verwenden der Arithmetik aus der Python-Lösung von 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

Ich habe diese Frage im Feed nicht gesehen und bin nur zufällig darüber gestolpert. Hier ist trotzdem meine Antwort:

JavaScript (ES6), 34 Byte

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

Addiere 1 Byte für eine numerische Antwort. Ursprünglich basiert auf dieser ungolfed ES7-Antwort (37 Bytes, bereits numerisch):

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

Ärgerlicherweise möchte OP, dass 36 näher an 66 als 6 liegt. Erläuterung: 11/3 = 3.666 ..., also teilt man die Bereiche 7..36, 37..366 usw. durch diese auf die Bereiche 1..9.9, 10 ..99.9 usw. Dies kann rein numerisch gelöst werden, indem 2/3 einer weniger als die nächsthöhere Potenz von 10 genommen werden. Es ist jedoch Golfspieler, zu kürzen, in eine Zeichenfolge umzuwandeln und dann alle Zeichen in die Ziffer 6 zu ändern nicht so golfen wie diese wirklich kluge rekursive Antwort.)

CJam, 25 Bytes

Nicht so langsam wie Jonathan Alans Jelly-Einreichung, erfordert jedoch O (n²) -Speicher, wobei n die eingegebene Zahl ist. Ja.

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

Dies entspricht dem folgenden 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: =-

Alternative Lösung, 12 Bytes

ri)3*B/s,'6*

Dies ist eine Übersetzung des Algorithmus von orlp in CJam.

Erläuterung:

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

beschneide das Zeichen 6

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

Probieren Sie es online!

Statt trim($x=$argn+$i,6)>""Sie eine Regex - Lösung verwenden können !preg_match("#^6+$#",$x=$argn+$i)gleich +11 Bytes oder eine Stringlänge zählen 6Vergleich 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

Beeindruckend. Hier ist das Ungolfed und erklärt:

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

Immer noch wow. Hier ist etwas Pseudojavascrython für dich.

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

Verstehst du es immer noch nicht? Dieses Programm vergleicht im Grunde genommen nur (mit Ausnahme der Eingänge 1-3) den Eingang mit 3,6 * 10 ^ n, wobei n die Länge des Eingangs ist. Wenn es kleiner als diese Zahl ist, gibt es die Zahl von 6s eins weniger als die Länge aus. Wenn es größer oder gleich dieser Zahl ist, ist die Anzahl der Sechser die aktuelle Länge.

Würde gerne etwas beim Golfen helfen!

Haxe, 70 Bytes

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

Die Eingabe muss als Typ übergeben werden, Floatobwohl es sich um eine Ganzzahl handelt. Andernfalls beschwert sich Haxe über den Versuch, eine Ganzzahl zu teilen (ja, Haxe lehnt die Kompilierung ab, wenn Sie eine Ganzzahl durch etwas teilen).

Gleich wie alle anderen Antworten. Mit 3 multiplizieren, durch 11 teilen, 6für jede Ziffer 1 ausgeben.

Brainfuck, 315 Bytes

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

Führen Sie es hier aus . Wählen Sie eine Zellengröße aus, die Werte von 3 * (n + 1) verarbeiten kann. Wählen Sie daher 16 aus, damit alle Testfälle funktionieren. Dynamischer (unendlicher) Speicher muss aktiviert sein, damit dies funktioniert. Dadurch kann das Band nach links erweitert werden. Um eine Ganzzahl einzugeben, geben Sie die Eingabe wie folgt ein\366 für n = 366 ein.

Ungolfed:

Verwendet den gleichen Algorithmus wie diese Lösung . Die für jeden einzelnen Schritt verwendeten Algorithmen werden von dieser Seite übernommen . Alle verwendeten Algorithmen sind nicht umbrochen, sodass das Programm bei größeren Eingaben nicht unterbrochen wird.

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

Probieren Sie es 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 Bytes

_ì e¥6}cU

Versuch es

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

Ein bisschen enttäuscht von der Länge, könnte genau das Gleiche tun wie die kürzere Antwort in Java, aber ich habe es nicht wirklich verstanden, weil ich ein fauler, dummer .NET-Entwickler bin :)