악마 숫자는 소수 표현이 6으로 만 구성된 양의 정수입니다. 악마 숫자 목록은 6, 66, 666, 6666으로 시작합니다.

양의 정수가 주어지면 가장 가까운 악마 숫자를 출력하십시오. 두 개가 있으면 더 큰 것을 출력하십시오.

테스트 케이스 :

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

이것은 code-golf 입니다. 바이트 단위의 최단 답변이 이깁니다.

파이썬 2, 28 바이트

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

자바 스크립트 (ES6), 31 29 바이트

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

"그래서 나는 약점을 좋아한다. […] 내가 약할 때, 나는 강하다."

Brachylog , 8 바이트

;I≜+{6}ᵐ

온라인으로 사용해보십시오!

설명

;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

자바 7, 96 93 66 바이트

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

@orlp 포트 놀라운 Python 2 답변 .

여기에서 시도하십시오.

내 66 바이트 수도 악마 라고 생각 합니다. ;)
(최단 Java 답변 btw는 아니지만 대신 @JollyJoker 의 답변을 참조하십시오 .

젤리 , 9 바이트

Ẇa6ḌạÐṂ⁸Ṫ

모나 딕 링크.

온라인으로 사용해보십시오! -이 링크에는 거의 아무 의미가 없습니다 (아래 참조)!

어떻게?

진정한 골퍼 스타일에서는 이것이 비효율적입니다. 365 테스트 케이스의 TIO에서 60 초의 시간을 초과했습니다 ! 국부적으로 이것은 37에서 끝납니다.

Ẇ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 년대가 제한 내에서 패치는 동일한 알고리즘 실행을 만들기 위해 365 및 366 TIO에가의 암시 vectorisation 방지하는 것입니다 Ḍ와 Ẇa6Ḍ€ạÐṂ⁸Ṫ( 그 시도를 ) 그러나 이것은 현재의 입력에 대한 독방 감금 - 잘못 것, 999 ( 삼각형 (999)가 아니라 499,500 이지만 각각 정수 목록 으로, 적어도 파이썬에서는 메모리가 효율적이지 않은 총 Tetrahedral (999) = 166,666,500 정수를 만듭니다 ).

젤리 , 10 바이트

RD6ṁḌạÐṂ¹Ṫ

온라인으로 사용해보십시오!

C, 118 바이트

온라인 시도

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

자바 스크립트 (ES6), 41 바이트

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

테스트 사례

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

매스 매 티카, 36 바이트

순수한 기능 :

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

설명:

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

의 값부터 시작 하여 NestList다음 패턴을 사용하여 입력과 동일한 길이 목록을 반복 작성하십시오 .6+10x(previous_value)6

                        ~Nearest~#

그런 다음이 목록에서 입력에 가장 가까운 값을 찾으십시오.

Max[                              ]

마지막으로 가장 가까운 값 목록에서 최대 값을 가져옵니다.

수학이 임의의 정밀 길이 숫자로 작업 할 수 있기 때문에 목록 길이는 매우 비효율적이지만이 프로그램은 물리적 메모리에 의해서만 제한됩니다.

유해한 것으로 간주되는 템플릿 , 118 바이트

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

온라인으로 사용해보십시오!

언 골프 드 :

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 바이트

-Riley 덕분에 1 바이트

6׌ΣI-Ä}¬

온라인으로 사용해보십시오!

위의 코드에는 성능 문제가있을 수 있습니다. 여기에 10 바이트의 약간 더 효율적인 버전이 있습니다. TIO 대안

설명

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

수학, 76 바이트

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

Neim , 12 10 바이트 (비경쟁)

steenbergh 덕분에 -1 바이트

𝐥𝐈Γ6Θℝ)₁>𝕔

설명:

               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

불행히도 𝕔두 숫자의 차이가 같은 경우 목록에서 더 낮은 값을 반환하므로이를 처리하기 위해 2 바이트를 추가해야했습니다.

비는-경쟁 >, <그리고 ℝ이 질문은 질문 후 추가 된 (및 𝐥숫자 작업에 고정 아니라 목록)

참고 : 길이가 19 이상인 숫자는 Java의 long이 처리하기에는 너무 커지기 때문에 작동하지 않습니다. (그러나 이것은 상당히 큰 값이므로 괜찮을 것입니다)

시도 해봐

자바 8, 37 바이트

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

Kevin Cruijssen의 예제로 가서 String을 반환합니다.

올바른 길이를 얻으려면 * 3 / 11 트릭을 수행 한 다음 모두 6으로 바꾸십시오.

QBIC , 37 27 바이트

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

Maths ™를 사용하는 대신 이제 문자열 조작을 사용하여 Demonic Domains (36, 366, ...)에서 브레이크를 찾습니다. @ eush77의 JS 답변에서 영감을 얻었습니다.

설명

≈         |  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 바이트

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

온라인으로 사용해보십시오!

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 바이트

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

그것은 모든 36666마다 다음의 데모닉 숫자로 넘어 가야한다는 사실을 사용합니다 ... 더 읽기 쉬운 형태로 :

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 바이트

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

orlp의 Python 솔루션 에서 산술 사용하기 :

;                   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

피드에서이 질문을 보지 못했고 우연히 우연히 만났습니다. 어쨌든 내 대답은 다음과 같습니다.

자바 스크립트 (ES6), 34 바이트

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

숫자 형 답변에 1 바이트를 추가합니다. 원래이 ungolfed ES7 답변 (37 바이트, 이미 숫자)을 기반으로합니다.

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

성가신 OP는 36이 6보다 66에 더 가깝기를 원합니다. 설명 : 11 / 3 = 3.666 ...으로 나누면 범위는 7..36, 37..366 등으로 범위는 1..9.9, 10입니다. ..99.9 등. 이것은 10의 다음 거듭 제곱보다 1의 2/3 중 하나를 2/3만큼 빼 냄으로써 순수하게 수치 적으로 풀 수 있습니다. 정말 영리한 재귀 답변만큼 골치 아픈 것은 아닙니다.)

CJam, 25 바이트

Jonathan Alan의 Jelly 제출만큼 느리지 않지만 O (n²) 메모리 가 필요합니다 . 여기서 n 은 입력 번호입니다. 네.

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

이것은 다음 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: =-

대체 솔루션, 12 바이트

ri)3*B/s,'6*

이것은 orlp의 알고리즘을 CJam으로 변환 한 것입니다.

설명:

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 바이트

캐릭터를 다듬다 6

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

온라인으로 사용해보십시오!

대신 trim($x=$argn+$i,6)>""정규식 솔루션 !preg_match("#^6+$#",$x=$argn+$i)+11 바이트 또는 6비교 strlen($x=$argn+$i)-strspn($x,6)+10 바이트 수 와 같은 문자열 길이를 사용할 수 있습니다

LOLCODE 1.4, 471 바이트

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

와. Ungolfed 및 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

아직도 와우. 여기 당신을위한 의사 자바 스크립 톤이 있습니다.

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

아직도 얻지 못합니까? 이 프로그램은 기본적으로 입력 1-3을 제외하고 입력을 3.6 * 10 ^ n과 비교합니다. n은 입력 길이입니다. 이 숫자보다 작은 경우 6보다 긴 숫자보다 1을 적게 인쇄합니다. 해당 숫자보다 크거나 같은 경우 6의 수는 현재 길이입니다.

골프를 도와주세요!

Haxe, 70 바이트

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

입력은 Float정수 임에도 불구하고 유형으로 전달되어야 합니다. 그렇지 않으면 Haxe는 정수를 나누는 것에 대해 불평합니다 (예 : 정수를 다른 것으로 나누면 haxe는 컴파일을 거부 함)

다른 모든 답변과 동일합니다. 3을 곱하고 11로 나누고 6모든 숫자에 대해 1 을 인쇄 합니다.

Brainfuck, 315 바이트

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

여기에서 실행하십시오 . 3 * (n + 1)의 값을 처리 할 수있는 셀 크기를 선택하여 모든 테스트 사례가 작동하려면 16을 선택하십시오.이 기능을 사용하려면 동적 (무한) 메모리를 켜야합니다. 테이프가 왼쪽으로 확장 될 수 있습니다. 정수를 입력하려면\366n = 366과 같은 입력을 입력하십시오.

언 골프 드 :

이 솔루션 과 동일한 알고리즘을 사용합니다 . 각 단계에 사용되는 알고리즘은 이 페이지 에서 가져옵니다 . 사용 된 모든 알고리즘은 랩핑되지 않으므로 더 큰 입력에서 프로그램이 중단되지 않습니다.

,+ # 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 바이트

6s×ηs.x

온라인으로 사용해보십시오!

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 바이트

_ì e¥6}cU

시도 해봐

C #, 102 바이트

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

Kinda는이 길이에 실망했으며 Java의 짧은 대답과 정확히 동일 할 수는 있지만 게으르고 바보 같은 .NET 개발자이기 때문에 실제로 이해하지 못했습니다. :)