Dado un número ny una llista de límite superior, los números que se pueden crear multiplicando dos o más números que consisten en solo sietes de longitud no menos que son menores que l. A161145 está cerca de este desafío, sin embargo, NO incluirá los 7, 77, 777, 7777, 77777, etc.

Ejemplos

n=anything, l<49 daría como resultado:

[]

n=1, l=49 daría como resultado:

7*7=49

f(1,49)=[49]

n=1, l=343 daría como resultado:

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

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

n=2,l=6000 daría como resultado:

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 daría como resultado:

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

Etc ...

Reglas

1. Usted no tiene que salida de pasos intermedios, esto se hizo para mayor claridad.
2. La salida puede ser como una matriz o separada por cualquier carácter (incluso nuevas líneas).
3. La salida debe estar en orden numérico, de menor a mayor.
4. Para que el título sea relevante, lo más alto nque debe manejarse es n=77(si no puede manejar ese alto, tenga en cuenta por qué: las restricciones de idioma son aceptables, la pereza no lo es). Esta limitación es para obstaculizar a aquellos que buscan construir todo el superconjunto en la memoria.
5. Si TIO no puede ejecutarse n=77para su código, explique qué especificaciones se requieren para lograrlo n=77.
6. Para que un producto sea válido, debe constar de al menos 2 números.
7. Este es el recuento de bytes más bajo del código de golf se considerará victorioso.
8. Puede elegir que la lista contenga elementos menores lo menores que / iguales a l.
9. BONIFICACIÓN : Si su código es exactamente 77 bytes, felicitaciones de mi parte; sin valor, lo sé.

05AB1E , 19 bytes

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

Pruébalo en línea!

Explicación

Muy ineficiente El enlace TIO realiza ceil(l^(1/7))iteraciones en lugar de las literaciones utilizadas en la versión de golf para probar más fácilmente los grandes casos de prueba.

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

Jalea , 21 20 19 18 bytes

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

Tenga en cuenta que la salida no coincide con los OP. He dejado un comentario

Pruébalo en línea!

Cómo 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)

Tenga en cuenta que TIO no tiene suficiente memoria para el último caso de prueba.

Pruébalo en línea!

JavaScript (ES6), 103101 bytes

Toma entrada en la sintaxis de curry (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 prueba

El último caso de prueba puede tardar unos segundos en completarse.

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 eliminando $r=[];y reemplazando sort($r);con@sort($r);

Versión en línea

Expandido

Una función recursiva realiza todas las permutaciones, incluido el límite

$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

un bucle hasta incluir el límite de verificación de cada valor que es divisible 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);

Versión en línea

unos pocos bytes más y se puede crear una matriz asociativa clave el número y como valor una matriz de los sietes utilizados

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

Versión en línea

Ruby, 89 86 bytes

Una solución recursiva.

-3 bytes al recordar que cualquier cosa multiplicada por 0 es 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: []}

Pruébalo en línea!

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

Pruébalo en línea!

Especificaciones

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

PHP, 128 125 130 129 127 123 bytes

funcionará hasta 22 7s pero redondeará valores más grandes (7 ** 23 es punto flotante en una máquina de 64 bits).

3 bytes guardados por Jörg, 3 por mí, 5 4 1 añadidos para evitar avisos de resultados vacíos.

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

toma datos de los argumentos de la línea de comandos; ejecutar -nro probarlo en línea .

Descompostura

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 bytes

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

Aquí hay muchas posibilidades de mejora en el lenguaje mismo; Parece que hay bastantes cosas que escribí que obviamente podrían mejorarse con algunos cambios en el diseño del lenguaje. Esta es la forma más corta que he encontrado con la versión actual. Bien puedo hacer algunas sugerencias para Brachylog que harían este programa más eficiente, más corto y más legible.

Muy, muy lento; TIO agota el tiempo de espera incluso en la respuesta no trivial más simple posible, por lo que no tiene mucho sentido proporcionar un enlace TIO. He verificado este programa ejecutándolo localmente.

Esta es una función (no un programa completo), cuya salida es un generador (a diferencia de una lista). Agregue .w⊥al final de la función si desea ver todas las salidas, en lugar de solo la primera. (Tenga en cuenta que esto realmente no importa en la práctica, porque como el programa es demasiado lento para TIO de todos modos, debe ejecutarlo localmente, y el intérprete local Brachylog se ejecuta en un REPL que puede describir un generador muy bien).

Explicación

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.

Bash + GNU utilidades, 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

Pruébalo en línea . TIO tarda aproximadamente un minuto en el último caso de prueba. Mis resultados coinciden con los de Dennis.

Pyth - 57 51 49 42 bytes

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

Intentalo