Liczba demoniczna jest dodatnią liczbą całkowitą, której reprezentacja dziesiętna składa się tylko z 6. Lista liczb demonicznych zaczyna się od 6, 66, 666, 6666.

Biorąc pod uwagę dodatnią liczbę całkowitą, wypisz najbliższą liczbę demoniczną. Jeśli są dwa, wypisz większy.

Przypadki testowe:

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

To jest golf golfowy . Najkrótsza odpowiedź w bajtach wygrywa.

Python 2, 28 bajtów

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

JavaScript (ES6), 31 29 bajtów

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

„Dlatego lubię słabości […] Bo kiedy jestem słaby, to jestem silny.”

Brachylog , 8 bajtów

;I≜+{6}ᵐ

Wypróbuj online!

Wyjaśnienie

;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 bajtów

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

Port @orlp niesamowita odpowiedź na Python 2 .

Wypróbuj tutaj.

Wydaje mi się, że mój licznik 66 bajtów również jest demonem. ;)
(Nie jest to najkrótsza odpowiedź Java między innymi, zobacz zamiast tego odpowiedź @JollyJoker .

Galaretka , 9 bajtów

Ẇa6ḌạÐṂ⁸Ṫ

Link monadyczny.

Wypróbuj online! - Prawie nie ma sensu w tym linku (patrz poniżej)!

W jaki sposób?

W prawdziwym stylu golfisty jest to naprawdę nieefektywne - osiąga limit czasu 60. w TIO dla przypadku testowego 365 ! Lokalnie kończy się to w 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)

Łatka sprawiająca, że ​​ten sam algorytm działa w granicach 60. dla 365 i 366 na TIO, ma na celu uniknięcie niejawnej wektoryzacji Ḍz Ẇa6Ḍ€ạÐṂ⁸Ṫ( spróbuj ), ale teraz będzie to błąd dla wejścia 999 ( trójkąt (999) jest tylko 499,500, ale każda jest listą liczb całkowitych, co daje w sumie Tetrahedr (999) = 166 666 500 liczb całkowitych, mało wydajnych pamięci, przynajmniej w Pythonie).

Galaretka , 10 bajtów

RD6ṁḌạÐṂ¹Ṫ

Wypróbuj online!

C, 118 bajtów

Wypróbuj 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 bajtów

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

Przypadki testowe

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 bajtów

Czysta funkcja:

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

Wyjaśnienie:

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

Iteracyjnie utwórz listę długości równą wartości wejściowej, używając NestListwzoru 6+10x(previous_value)zaczynającego się od wartości 6.

                        ~Nearest~#

Następnie znajdź wartość na tej liście najbliżej wejścia.

Max[                              ]

Na koniec pobierz maksymalną wartość z listy najbliższych wartości.

Podczas gdy długość listy jest bardzo nieefektywna, ponieważ matematyka może pracować z dowolnymi liczbami długości dokładności, program ten jest ograniczony tylko pamięcią fizyczną.

Szablony uważane za szkodliwe , 118 bajtów

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

Wypróbuj online!

Nie golfowany:

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 bajtów

- 1 bajt dzięki Riley

6׌ΣI-Ä}¬

Wypróbuj online!

Powyższy kod może mieć problemy z wydajnością, tutaj jest nieco bardziej wydajna wersja z 10 bajtami: alternatywa TIO

Wyjaśnienie

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 bajtów

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

Neim , 12 10 bajtów (niekonkurencyjny)

-1 bajt dzięki steenbergh

𝐥𝐈Γ6Θℝ)₁>𝕔

Wyjaśnienie:

               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

Niestety, 𝕔 zwróci niższą wartość z listy, jeśli dwie liczby mają tę samą różnicę, więc musieliśmy dodać 2 bajty, aby to uwzględnić.

Zakaz konkurowania jako >, <i ℝdodano po to pytano (i 𝐥została ustalona do pracy z liczbami, a nie tylko listy)

Uwaga: Nie będzie działać dla liczb o długości równej 19 lub większej - ponieważ stają się one zbyt duże, aby obsługiwały je długo Java. (ale jest to dość duża wartość i powinno być w porządku)

Spróbuj

Java 8, 37 bajtów

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

Idąc za przykładem Kevina Cruijssena i po prostu zwracając .

Wykonaj sztuczkę * 3/11, aby uzyskać odpowiednią długość, a następnie zastąp wszystkie szóstkami.

QBIC , 37 27 bajtów

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

Zamiast używać Maths ™, teraz używa manipulacji ciągiem, aby znaleźć przerwy w Domach Demonicznych (36, 366, ...). Zainspirowany odpowiedzią JS @ eush77.

Wyjaśnienie

≈         |  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 bajtów

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

Wypróbuj 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 bajty

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

Wykorzystuje fakt, że musimy przeskakiwać do następnej liczby demonicznej co 36666 ... W bardziej czytelnej formie:

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 bajtów

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

Używając arytmetyki z rozwiązania Python 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

Nie widziałem tego pytania w kanale i potknąłem się o to przez przypadek. Oto i tak moja odpowiedź:

JavaScript (ES6), 34 bajty

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

Dodaj 1 bajt dla odpowiedzi numerycznej. Pierwotnie oparty na tej nieokreślonej odpowiedzi ES7 (37 bajtów, już numeryczna):

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

Irytujące OP chce, aby 36 było bliżej 66 niż 6. Objaśnienie: 11/3 = 3,666 ..., więc podzielenie przez to skaluje zakresy 7..36, 37..366 itd. Do zakresów 1..9.9, 10 ..99.9 itd. Można to rozwiązać czysto numerycznie, biorąc 2/3 jednej mniejszej niż kolejna wyższa potęga 10, chociaż golfier jest obcinany, konwertowany na ciąg znaków, a następnie zamienia wszystkie znaki na cyfrę 6. (Chociaż nadal nie tak golfowa, jak ta naprawdę sprytna rekurencyjna odpowiedź.)

CJam, 25 bajtów

Nie tak powolny jak poddanie galaretki Jonathana Alana, ale wymaga pamięci O (n²) , gdzie n jest liczbą wejściową. Tak.

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

Jest to równoważne z następującym Pythonem:

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

Alternatywne rozwiązanie, 12 bajtów

ri)3*B/s,'6*

To jest tłumaczenie algorytmu orlp na CJam.

Wyjaśnienie:

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 bajtów

przytnij postać 6

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

Wypróbuj online!

Zamiast tego trim($x=$argn+$i,6)>""możesz użyć rozwiązania Regex !preg_match("#^6+$#",$x=$argn+$i)+ 11 bajtów lub długości łańcucha równej 6porównaniu liczby strlen($x=$argn+$i)-strspn($x,6)+ 10 bajtów

LOLCODE 1.4, 471 bajtów

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

Łał. Oto Ungolfed i wyjaśniono:

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

Wow. Oto kilka pseudojavascrython dla ciebie.

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

Nadal nie rozumiesz? Program ten po prostu (z wyłączeniem wejść 1-3) porównuje dane wejściowe z 3,6 * 10 ^ n, gdzie n jest długością danych wejściowych. Jeśli jest mniejsza niż ta liczba, drukuje liczbę 6s o jeden mniejszą niż długość. Jeśli jest ona większa lub równa tej liczbie, liczba szóstek jest bieżącą długością.

Chciałbym trochę pomóc w grze w golfa!

Haxe, 70 bajtów

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

Dane wejściowe muszą być przekazywane jako typ, Floatmimo że są liczbami całkowitymi, w przeciwnym razie Haxe będzie narzekać na próbę podzielenia liczby całkowitej (tak, haxe odmówi kompilacji, jeśli podzielisz liczbę całkowitą przez cokolwiek)

Taki sam jak wszystkie pozostałe odpowiedzi. Pomnóż przez 3, podziel przez 11, wydrukuj 1 6dla każdej cyfry.

Brainfuck, 315 bajtów

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

Uruchom tutaj . Wybierz rozmiar komórki, która może obsłużyć wartości 3 * (n + 1), więc aby wszystkie przypadki testowe działały, wybierz 16. Dynamiczna (nieskończona) Pamięć musi być włączona, aby działała. Umożliwia to rozwinięcie taśmy w lewo. Aby wprowadzić liczbę całkowitą, wpisz dane wejściowe jak\366 dla n = 366.

Nie golfowany:

Używa tego samego algorytmu jak to rozwiązanie . Algorytmy stosowane dla każdego kroku pochodzą z tej strony . Wszystkie stosowane algorytmy nie zawijają, dzięki czemu program nie będzie się łamał przy większych wejściach.

,+ # 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 bajtów

6s×ηs.x

Wypróbuj 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 bajtów

_ì e¥6}cU

Spróbuj

C #, 102 bajty

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

Trochę rozczarowany długością tego, mógł zrobić dokładnie to samo, co krótsza odpowiedź w Javie, ale tak naprawdę tego nie rozumiałem, ponieważ jestem leniwym, głupim programistą .NET :)