숫자 n와 상한 l목록에 주어진 길이가 7n 보다 작거나 그보다 작은 두 개 이상의 숫자를 곱하여 만들 수있는 숫자입니다 l. A161145 는이 과제에 가깝지만 7, 77, 777, 7777, 77777 등은 포함하지 않습니다.

예

n=anything, l<49 결과 :

[]

n=1, l=49 결과 :

7*7=49

f(1,49)=[49]

n=1, l=343 결과 :

7*7   =49
7*7*7 =343

f(1,343)=[49,343]

n=2,l=6000 결과 :

7*7    =49
7*7*7  =343
7*7*7*7=2401
7*77   =539
7*7*77 =3773
77*77  =5929

f(2,6000)=[49,343,539,2401,3773,5929]

n=3, l=604000 결과 :

[49, 343, 539, 2401, 3773, 5439, 5929, 16807, 26411, 38073, 41503, 59829, 117649, 184877, 266511, 290521, 418803, 456533, 603729]

기타...

규칙

1. 당신은 하지 않습니다 이 명확하게하기 위해 이루어졌다 출력 중간 단계에있다.
2. 출력은 배열이거나 문자 (개행 문자 포함)로 구분 될 수 있습니다.
3. 출력은 가장 낮은 숫자부터 높은 숫자 순서 여야합니다.
4. 제목을 적절 n하게 처리하려면 처리해야하는 최고가 있어야합니다 n=77(높이를 처리 할 수없는 경우 언어 제한이 허용되는 이유, 게으름이 아닌 이유에 유의하십시오). 이 제한은 메모리에 전체 수퍼 세트를 구축하려는 사용자를 방해하기위한 것입니다.
5. n=77코드에 대해 TIO를 실행할 수없는 경우 달성하기 위해 어떤 사양이 필요한지 설명하십시오 n=77.
6. 제품이 유효하려면 2 개 이상의 숫자로 구성되어야합니다.
7. 이것은 코드 골프 최하위 바이트 수는 승리로 간주됩니다.
8. 보다 작 l거나 같은 항목을 포함하도록 목록을 선택할 수 있습니다 l.
9. 보너스 : 코드가 정확히 77 바이트라면 무가치 해

05AB1E , 19 바이트

L7×1¸ì©IF®âPD²‹Ïê®K

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

설명

매우 비효율적입니다. TIO 링크 는 골프 버전에서 사용 된 ceil(l^(1/7))반복 대신 반복을 수행 하여 l큰 테스트 케이스를 쉽게 테스트합니다.

L7×                   # create the list ['7', '77', '777' ...] 
                      # with the final item having n 7's 
   1¸ì©               # prepend a 1 and store a copy in register
       IF             # l times do:
         ®â           # cartesian product between current list and the list in register 
           P          # product of each sublist
            D²‹Ï      # keep only numbers smaller than l
                ê     # remove duplicates and sort
                 ®K   # remove 1, 7, 77, 777 ... from the list

젤리 , 21 20 19 18 바이트

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ

출력이 OP와 일치하지 않습니다. 의견을 남겼습니다.

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

작동 원리

R7ẋḌµ;ŒċP€⁹f€FµÐLḟ  Main link. Left argument: n. Right argument: l

R                   Range; yield [1, ..., n].
 7ẋ                 Times; yield [[7], ..., [7] * n].
   Ḍ                Undecimal; yield s := [7, 77, ...].
    µ         µÐL   Begin a new chain with argument s and call the chain between 
                    until the results no longer chain.
                    Return the last unique result.
      Œċ            Combinations; return all unordered pairs in integers in the
                    return value.
     ;              Concatenate the return value and its pairs.
        P€          Take the product of each individual integer and each pair in
                    the result.
          ⁹f€       Filter each; for each j in [1, ..., l], intersect [j] with the
                    array of products. The result is sorted and contains no 
                    duplicates.
                 ḟ  Filterfalse; remove the elements of s from the result.

파이썬 (2) , 116 (113) 109 바이트

n,l=input()
r=t={1}
exec't|={10**n/9*7};n-=n>1;r=r|{x*y for x in r for y in t if l/x/y};'*l
print sorted(r-t)

TIO에는 마지막 테스트 사례를위한 충분한 메모리가 없습니다.

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

자바 스크립트 (ES6), (103) 101 바이트

카레 구문으로 입력을 (n)(l)받습니다.

n=>l=>(a=[],g=(n,m,p,i)=>(p>l||g(n,m,(a[i>1?p:a]=p)*m,-~i),--n?g(n,m+7,p,i):a.filter(n=>n)))(n,'7',1)

테스트 사례

마지막 테스트 케이스를 완료하는 데 몇 초가 걸릴 수 있습니다.

let f =

n=>l=>(a=[],g=(n,m,p,i)=>(p>l||g(n,m,(a[i>1?p:a]=p)*m,-~i),--n?g(n,m+7,p,i):a.filter(n=>n)))(n,'7',1)

console.log(f(1)(49))
console.log(f(1)(343))
console.log(f(2)(6000))
console.log(f(3)(604000))

PHP, 142 바이트

$r=[];for([,$n,$l]=$argv;$n--;)f($v[]=$z.=7);function f($t){global$v,$l,$r;while($c=$t*$v[+$i++])$l<$c?:f($c)&$r[$c]=$c;}sort($r);print_r($r);

-5 바이트 제거 $r=[];및 교체 sort($r);와@sort($r);

온라인 버전

넓히는

재귀 함수는 한계를 포함한 모든 순열을 만듭니다.

$r=[];
for([,$n,$l]=$argv;$n--;)
  f($v[]=$z.=7);
function f($t){
    global$v,$l,$r;
    while($c=$t*$v[+$i++])
      $l<$c?:f($c)&$r[$c]=$c;
}
sort($r);
print_r($r);

PHP, 145 바이트

for([,$n,$l]=$argv;$n;)$t[]=str_pad(7,$n--,7);for(;$l>=$i+=49;$v>1?:$u[]=$r)for($v=$i,$r=!$c=0;$d=$t[$c];)$v%$d?$c++:($v/=$d)&$r*=$d;print_r($u);

넓히는

49로 나눌 수있는 모든 값에 한계 점검을 포함시킬 때까지의 루프

for([,$n,$l]=$argv;$n;)
  $t[]=str_pad(7,$n--,7);
for(;$l>=$v=$i+=49;$v>1?:$u[]=$r)
  for($r=!$c=0;$d=$t[$c];)
    $v%$d?$c++:($v/=$d)&$r*=$d;
print_r($u);

온라인 버전

몇 바이트 더 있고 연관 배열은 숫자와 키로 사용 된 7의 배열로 만들 수 있습니다.

for([,$n,$l]=$argv;$n;)
  $t[]=str_pad(7,$n--,7);
for(;$l>=$v=$i+=49;$v>1?:$u[array_product($r)]=$r)
  for($r=[],$c=0;$d=$t[$c];)
    $v%$d?$c++:($v/=$d)&$r[]=$d;
print_r($u);

온라인 버전

루비, 89 86 바이트

재귀 솔루션.

0을 곱한 값이 0임을 기억하여 -3 바이트

f=->n,l,b=1{n*l>0?(f[n,l/k=eval(?7*n),b*k]+f[n-1,l,b]+(b>1&&l>=k ?[k*b]:[])).sort: []}

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

Pyth , 22 바이트

JsM._*\7Eu@s*LR+JGJSQJ

JsM._*\7E
        E               second input
     *\7                repeat "7" as many times as the above
   ._                   all prefixes of above
 sM                     convert each to integer
J                       store list as J

         u@s*LR+JGJSQJ
         u              repeat the following until results not unique
                     J  starting from G = J
                        at each iteration, G is the current value
               +JG      append G to J
                  J     J
            *LR         multiply the elements of the above two, vectorizing each
           s            flatten list
          @        SQ   intersect with [1,2,3,...,first input]
                        this takes elements from [1,2,3,...,first input] and
                        check if each element is in the previous list
                        which ensures the result is sorted and unique

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

명세서

• 입력: l[newline]n
• 산출: array containing the sorted result

PHP, 128125130129127 123 바이트

22까지 작동합니다 7 초 하지만 더 큰 값을 반올림합니다 (7 ** 23은 64 비트 시스템에서 부동 소수점 임).

빈 결과에 대한 경고를 피하기 위해 Jörg, 3 by me, 5 4 1을 저장 한 3 바이트

for([,$c,$z]=$argv,$n=$c+1;$c<$z;$p<$z&&$r[$p]=$p)for($b=$c+=$p=1;$b|0;$b/=$n)$p*=str_pad(7,$b%$n,7);@sort($r);print_r($r);

명령 행 인수에서 입력을받습니다. 온라인으로 실행 -nr하거나 사용해보십시오 .

고장

for([,$c,$z]=$argv,$n=$c+1;         # $z=L, $n=N+1
    $c<$z;                          # loop $c from N to L-1:
    $p<$z&&$r[$p]=$p                    # 2. if product is < L, add to array
)                                       #    (key=val to avoid duplicates)
    for($b=$c+=$p=1;$b|0;$b/=$n)        # 1. loop $b through ++$c as base-N+1 number
        $p*=str_pad(7,$b%$n,7);             # take each base-N+1 digit as length
                                            # for a streak of 7s as factor
        // (str_pad is 1 byte shorter than str_repeat and saves 3 by ensuring positive $p)
@sort($r);                          # sort array (muted to avoid warning for empty result)
print_r($r);                        # print array

Brachylog , 28 바이트

h>.ḋ{p~c×ᵐ{=h7&l}ᵐobt≤~t?∧!}

언어 자체의 개선을위한 많은 범위가 있습니다. 제가 쓴 몇 가지 내용은 언어 디자인의 일부 변경으로 명백히 개선 될 수없는 것처럼 보입니다. 이것이 현재 버전에서 찾은 가장 짧은 방법입니다. 이 프로그램을보다 효율적이고 짧고 읽기 쉽게 만드는 Brachylog에 대한 제안을 할 수도 있습니다.

아주 아주 느립니다 TIO는 가장 간단한 가능한 대답조차도 시간 초과되므로 TIO 링크를 제공하는 데 별다른 의미가 없습니다. 이 프로그램을 로컬에서 실행하여 확인했습니다.

이것은 함수 (전체 프로그램이 아님)이며 출력이리스트와 반대 인 생성기입니다. 더하다.w⊥첫 번째 출력이 아닌 모든 출력을 보려면 함수 끝에 하십시오. (어쨌든 TIO에서는 프로그램이 너무 느리기 때문에 로컬에서 실행해야하고 로컬 Brachylog 인터프리터는 생성기를 잘 설명 할 수있는 REPL에서 실행되므로 실제로는 실제로 중요하지 않습니다.)

설명

h>.ḋ{p~c×ᵐ{=h7&l}ᵐobt≤~t?∧!}
  .                           The desired output is
h>                            a number less than the first input
   ḋ p                        such that taking its prime factors in some order,
      ~c                      partitioning them,
        ×ᵐ                    and taking the product of each partition
          {     }ᵐ            produces a number for which each digit
           =h7                is composed only of 7s
              &l              and for which the lengths of those numbers
                  o           are in sorted order
                    t         and the last element
                   b          (which is not also the first element)
                     ≤        is less than or equal to
                      ~t?     the last input.
                         ∧    (Delete an unwanted implicit constraint.)
   ḋ{                     !}  Output each number only once.

배쉬 + GNU 유틸리티, 108

seq -f3o%gp $2|dc|sed -r "/0|1{$1}/d;s/./&7/g;s/1//g;s/2/*/g;/[*]/!d;s/^/a=7/;s/$/;if(a<=$2)a;/"|bc|sort -un

온라인으로 사용해보십시오 . TIO는 마지막 테스트 케이스에 약 1 분이 걸립니다. 내 결과는 @Dennis 와 일치 합니다.

Pyth- 57 51 49 42 바이트

FY}2eQKYJv*\7hQWJIqYJBW!%KJ=/KJ)=/JT)Iq1KY

시도 해봐