Şeytani bir sayı, ondalık gösterimi yalnızca 6'dan oluşan pozitif bir tamsayıdır. Şeytani sayıların listesi 6, 66, 666, 6666 ile başlar.

Olumlu bir tamsayı verildiğinde, en yakın şeytani sayıyı verin. İki varsa, daha büyük olanı çıkar.

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

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır.

Python 2,28 bayt

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

JavaScript (ES6), 31 29 bayt

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

“Bu yüzden zayıflıklardan memnunum […] Zayıf olduğumda, o zaman güçlüyüm.”

Brachylog , 8 bayt

;I≜+{6}ᵐ

Çevrimiçi deneyin!

açıklama

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

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

Port @orlp şaşırtıcı Python 2 cevap .

Burada dene.

Sanırım 66 bayt sayım da bir şeytan. ;)
(Değil en kısa Java cevap btw bkz @JollyJoker bunun için cevabını yerine.

Jöle , 9 bayt

Ẇa6ḌạÐṂ⁸Ṫ

Monadik bir bağlantı.

Çevrimiçi deneyin! - Bu linkte neredeyse hiçbir nokta yok (aşağıya bakınız)!

Nasıl?

Gerçek golfçü tarzında bu gerçekten verimsiz - 365 test vakası için TIO'da 60'ların zaman aşımına uğradı ! Yerel olarak bu 37'lerde biter.

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

60'lar için sınırlamak içinde bir yama aynı algoritma çalışmasını sağlamak için 365 ve 366 TIO üzerinde örtülü vectorisation kaçınmaktır Ḍile Ẇa6Ḍ€ạÐṂ⁸Ṫ( yani deneyin ) Ancak bu artık bir girdi için seg-arıza olacak, 999 ( Triangle (999) sadece 499.500, ancak her biri bir tam sayı listesidir, toplam Tetrahedral yapar (999) = 166,666,500 tam sayı, hafıza etkin değil, en azından Python'da).

Jöle , 10 bayt

RD6ṁḌạÐṂ¹Ṫ

Çevrimiçi deneyin!

C, 118 bayt

Çevrimiçi dene

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 bayt

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

Test durumları

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 Bayt

Saf fonksiyonu:

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

Açıklama:

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

Yinelemeli , değerden başlayarak NestListdeseni izleyerek girişe eşit uzunlukta bir liste oluşturur .6+10x(previous_value)6

                        ~Nearest~#

Ardından, bu listedeki girişe en yakın olan değeri bulun.

Max[                              ]

Son olarak, en yakın değerler listesinden maksimum değeri alın.

Liste uzunluğu süper verimsiz olmasına rağmen matematiğin isteğe bağlı hassas uzunluk numaraları ile çalışabilmesi nedeniyle bu program sadece fiziksel hafıza ile sınırlıdır.

Zararlı Sayılan Şablonlar , 118 bayt

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

Çevrimiçi deneyin!

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 bayt

- Riley sayesinde 1 bayt

6׌ΣI-Ä}¬

Çevrimiçi deneyin!

Yukarıdaki kodun performans sorunları olabilir, işte 10 bayt ile biraz daha verimli bir sürüm: TIO alternatif

açıklama

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 bayt

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

Neim , 12 10 bayt (rekabet etmeyen)

Steenbergh sayesinde -1 bayt

𝐥𝐈Γ6Θℝ)₁>𝕔

Açıklama:

               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

Ne yazık ki, 𝕔 iki sayı aynı fark varsa, listedeki düşük değeri döndürür, bu nedenle hesaba 2 bayt eklemek zorunda kaldık.

Olarak Dışı rekabet >, <ve ℝbu soru sorulmuştur sonra eklendi (ve𝐥 sayılarla işe sabitlendi, sadece listeler)

Not: Uzunluğu 19 veya daha fazla olan sayılar için çalışmayacak - Java'nın kullanması çok uzun sürdüğü için. (ama bu oldukça büyük bir değer ve iyi olmalı)

Dene

Java 8, 37 bayt

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

Kevin Cruijssen'in örneğine gitmek ve sadece bir String döndürmek.

Doğru uzunluğu almak için * 3/11 numarasını yapın, ardından hepsini sixes ile değiştirin.

QBIC , 37 27 bayt

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

Maths ™ kullanmak yerine, bu şimdi Demonic Domains'deki (36, 366, ...) araları bulmak için string manipulation kullanmaktadır. @ Eush77 'nin JS cevabı esinlenerek.

açıklama

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

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

Çevrimiçi deneyin!

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 bayt

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

Her 36666'da bir sonraki deamonic numarasına atlamamız gerektiği gerçeğini kullanıyor ... Daha okunaklı bir biçimde:

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

beyin fırtınası , 15 bayt

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

Orlp'in Python çözümündeki aritmetik kullanımı :

;                   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

Bu soruyu feed'de görmedim ve yalnızca kazayla tökezledi. İşte yine de cevabım:

JavaScript (ES6), 34 bayt

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

Sayısal bir cevap için 1 bayt ekleyin. Aslen bu unungolfed ES7 cevabını temel almaktadır (37 byte, zaten sayısal):

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

Can sıkıcı OP 36'nın 6'ya 66'ya yakın olmasını istiyor. Açıklama: 11/3 = 3.666 ..., bu nedenle böylesi bölmeler 7..36, 37..366 vb. Aralıkları 1..9.9, 10 aralığına ölçeklendirir. ..99.9 vs. Bu, bir sonraki 10'luk güçten 2 / 3'ünden daha az birinin 2/3'ünü alarak tamamen sayısal olarak çözülebilir, ancak kesmek, dizgiye dönüştürmek ve sonra tüm karakterleri 6 rakamına değiştirmek için. Bu kadar zekice özyinelemeli cevap kadar golf gibi değil.)

CJam, 25 bayt

Jonathan Alan'ın Jelly gönderimi kadar yavaş değil, ancak n'nin giriş numarası olduğu O (n²) bellek gerekiyor . Evet.

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

Bu, aşağıdaki Python'a eşdeğerdir:

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

Alternatif çözüm, 12 bayt

ri)3*B/s,'6*

Bu orlp'in algoritmasının CJam'a çevrilmesidir.

Açıklama:

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 Bayt

karakteri 6 kırp

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

Çevrimiçi deneyin!

Bunun yerine trim($x=$argn+$i,6)>""Regex !preg_match("#^6+$#",$x=$argn+$i)+11 Bayt çözümünü veya +10 Bayt sayı 6karşılaştırmasına eşit dize uzunluğunu kullanabilirsinizstrlen($x=$argn+$i)-strspn($x,6)

LOLCODE 1.4, 471 bayt

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

Vay. İşte Ungolfed ve Açıklaması:

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

Hala vay canına. İşte sizin için bazı sahte javascrython.

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

Hala anlamadın mı? Bu program temel olarak sadece (1-3 girişleri hariç) girişi, girişi uzunluğu olan 3.6 * 10 ^ n ile karşılaştırır. Bu sayıdan daha küçükse, 6s sayısını uzunluktan bir ya da daha az yazdırır. Bu sayıdan büyük veya ona eşitse, altılık sayısı geçerli uzunluktur.

Golfe biraz yardım etmeyi çok isterim!

Haxe, 70 bayt

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

Giriş türü olarak geçilmelidir FloatBir tamsayı olmasına rağmen girişin , aksi takdirde Haxe bir tamsayıyı bölmeye çalışmaktan şikayet eder (evet bir tamsayıyı herhangi birşeye bölerseniz derlemek reddeder)

Diğer tüm cevaplarla aynı. 3 ile çarp, 11 ile böl, 6her basamak için 1 yaz .

Brainfuck, 315 bayt

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

Burada çalıştır . 3 * (n + 1) değerlerini işleyebilecek bir hücre boyutu seçin, bu nedenle tüm test durumlarının çalışması için 16'yı seçin. Dinamik (sonsuz) Bunun çalışması için Belleğin açık olması gerekir. Bu, bandın sola doğru genişlemesini sağlar. Bir tamsayı girmek için, şunu yazın\366 girmek için, n = 366 .

Ungolfed:

Bu çözümle aynı algoritmayı kullanır . Her adım için kullanılan algoritmalar bu sayfadan alınmıştır . Kullanılan tüm algoritmalar sarma değildir, böylece program daha büyük girdiler için bozulmaz.

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

6s×ηs.x

Çevrimiçi deneyin!

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 bayt

_ì e¥6}cU

Dene

C #, 102 bayt

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

Bunun uzunluğunu hayal kırıklığına uğrattım, Java'daki kısa cevapla tam olarak aynı şeyi yapabilirdi, ancak tembel, aptal bir .NET geliştiricisiyim çünkü gerçekten anlamadım :)