Dado um número ne um limite superior, llista os números que podem ser criados multiplicando dois ou mais números que consistem em apenas setes de comprimento nou menos que são menores que l. O A161145 está próximo desse desafio, no entanto, você NÃO incluirá os 7, 77, 777, 7777, 77777, etc.

Exemplos

n=anything, l<49 resultaria em:

[]

n=1, l=49 resultaria em:

7*7=49

f(1,49)=[49]

n=1, l=343 resultaria em:

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

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

n=2,l=6000 resultaria em:

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 resultaria em:

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

Etc ...

Regras

1. Você não precisa emitir etapas intermediárias, isso foi feito para maior clareza.
2. A saída pode ser como uma matriz ou separada por qualquer caractere (mesmo novas linhas).
3. A saída deve estar em ordem numérica, do menor para o maior.
4. Para tornar o título relevante, o mais alto nque deve ser tratado é n=77(se você não conseguir lidar com esse nível, observe o porquê - restrições de idioma são aceitáveis, preguiça não). Essa limitação é para impedir aqueles que desejam criar o superconjunto inteiro na memória.
5. Se o TIO não puder executar o n=77seu código, explique quais especificações foram necessárias para atingir n=77.
6. Para um produto ser válido, ele deve consistir em pelo menos 2 números.
7. Essa contagem de bytes mais baixa do código-golfe será considerada vitoriosa.
8. Você pode escolher a lista para conter itens menores lou iguais a / iguais a l.
9. BÔNUS : Se o seu código tiver exatamente 77 bytes, parabéns meu; inútil, eu sei.

05AB1E , 19 bytes

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

Experimente online!

Explicação

Muito ineficiente. O link TIO executa ceil(l^(1/7))iterações em vez das literações usadas na versão golfed para testar com facilidade casos de teste grandes.

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

Geléia , 21 20 19 18 bytes

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

Observe que a saída não corresponde aos OPs. Eu deixei um comentário.

Experimente online!

Como funciona

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.

Python 2 , 116 113 109 bytes

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)

Observe que o TIO não possui memória suficiente para o último caso de teste.

Experimente online!

JavaScript (ES6), 103 101 bytes

Recebe entrada na sintaxe de currying (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)

Casos de teste

O último caso de teste pode levar alguns segundos para ser concluído.

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 bytes

$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 bytes removendo $r=[];e substituindo sort($r);por@sort($r);

Versão Online

Expandido

Uma função recursiva faz todas as permutações, incluindo o limite

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

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

Expandido

um loop até incluir o limite, verifique todos os valores divisíveis por 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);

Versão Online

alguns bytes a mais e uma matriz associativa pode ser criada, digite o número e, como valor, uma matriz dos setes usados

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

Versão Online

Ruby, 89 86 bytes

Uma solução recursiva.

-3 bytes, lembrando que qualquer coisa que seja 0 é 0.

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: []}

Experimente online!

Pitão , 22 bytes

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

Experimente online!

Especificações

• Entrada: l[newline]n
• Resultado: array containing the sorted result

PHP, 128 125 130 129 127 123 bytes

funcionará até 22 7s, mas arredondará valores maiores (7 ** 23 é ponto flutuante em uma máquina de 64 bits).

3 bytes salvos por Jörg, 3 por mim, 5 4 1 adicionados para evitar aviso de resultados vazios.

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

recebe entrada de argumentos de linha de comando; execute -nrou experimente online .

demolir

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

Braquilog , 28 bytes

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

Há muito espaço para melhorias no próprio idioma, aqui; algumas coisas que escrevi parecem óbvias com algumas mudanças no design da linguagem. Esta é a maneira mais curta que encontrei na versão atual. Posso muito bem fazer algumas sugestões para o Brachylog que tornariam este programa mais eficiente, mais curto e mais legível.

Muito, muito devagar; O TIO atinge o tempo limite, mesmo na resposta não trivial mais simples possível; portanto, não faz muito sentido fornecer um link TIO. Eu verifiquei este programa executando-o localmente.

Esta é uma função (não um programa completo), cuja saída é um gerador (ao contrário de uma lista). Adicione .w⊥ao final da função se você quiser ver todas as saídas, em vez de apenas a primeira. (Observe que isso realmente não importa na prática, porque como o programa é muito lento para o TIO de qualquer maneira, você deve executá-lo localmente e o interpretador Brachylog local é executado em um REPL que pode descrever um gerador muito bem.)

Explicação

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.

Utilitários Bash + 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

Experimente online . O TIO leva cerca de um minuto para o último caso de teste. Meus resultados correspondem @ Dennis.

Pitão - 57 51 49 42 bytes

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

Tente