Dato un numero ne un limite superiore lelencano i numeri che possono essere creati moltiplicando due o più numeri costituiti da soli sette di lunghezza no meno che sono inferiori l. A161145 è vicino a questa sfida, tuttavia, NON includerai 7, 77, 777, 7777, 77777, ecc.

Esempi

n=anything, l<49 comporterebbe:

[]

n=1, l=49 comporterebbe:

7*7=49

f(1,49)=[49]

n=1, l=343 comporterebbe:

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

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

n=2,l=6000 comporterebbe:

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

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

Eccetera...

Regole

1. Non è necessario eseguire passaggi intermedi, questo è stato fatto per chiarezza.
2. L'output può essere un array o separato da qualsiasi carattere (anche newline).
3. L'output deve essere in ordine numerico, dal più basso al più alto.
4. Per rendere rilevante il titolo, il massimo nche deve essere gestito è n=77(se non riesci a gestire così in alto, nota perché - le restrizioni linguistiche sono accettabili, la pigrizia non lo è). Questa limitazione è di ostacolare coloro che cercano di costruire l'intero superset in memoria.
5. Se TIO non può essere eseguito n=77per il tuo codice, spiega quali specifiche sono state richieste per raggiungere n=77.
6. Perché un prodotto sia valido, deve essere composto da almeno 2 numeri.
7. Questo è il conteggio dei byte più basso di code-golf sarà considerato vittorioso.
8. È possibile scegliere l'elenco per contenere elementi inferiori lo inferiori a / uguali a l.
9. BONUS : Se il tuo codice è esattamente 77 byte, complimenti da parte mia; senza valore, lo so.

05AB1E , 19 byte

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

Provalo online!

Spiegazione

Molto inefficiente. TIO link esegue ceil(l^(1/7))iterazioni invece delle literazioni utilizzate nella versione golfata per testare più facilmente test di grandi dimensioni.

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

Gelatina , 21 20 19 18 byte

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

Si noti che l'output non corrisponde ai PO. Ho lasciato un commento

Provalo online!

Come funziona

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

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)

Si noti che TIO non ha memoria sufficiente per l'ultimo caso di test.

Provalo online!

JavaScript (ES6), 103 101 byte

Accetta input nella sintassi del 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)

Casi test

Il completamento dell'ultimo caso di test potrebbe richiedere alcuni secondi.

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 byte

$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 Byte che rimuovono $r=[];e sostituiscono sort($r);con@sort($r);

Versione online

allargato

Una funzione ricorsiva effettua tutte le permutazioni incluso il 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 byte

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

allargato

un ciclo fino a includere il limite controlla ogni valore che è divisibile per 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);

Versione online

qualche byte in più e un array associativo può essere creato come chiave del numero e come valore un array dei sette usati

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

Versione online

Rubino, 89 86 byte

Una soluzione ricorsiva.

-3 byte ricordando che ogni volta 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: []}

Provalo online!

Pyth , 22 byte

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

Provalo online!

Specifiche

• Ingresso: l[newline]n
• Produzione: array containing the sorted result

PHP, 128 125 130 129 127 123 byte

funzionerà fino a 22 7s ma arrotonderà valori più grandi (7 ** 23 è in virgola mobile su una macchina a 64 bit).

3 byte salvati da Jörg, 3 da me, 5 4 1 aggiunti per evitare avvisi per risultati vuoti.

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

accetta input dagli argomenti della riga di comando; corri con -nro provalo online .

abbattersi

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 byte

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

C'è molto margine di miglioramento nella lingua stessa, qui; parecchie cose che ho scritto sembrano ovviamente migliorabili con alcune modifiche al design del linguaggio. Questo è il modo più breve che ho trovato con la versione corrente. Potrei suggerire alcuni suggerimenti per Brachylog che renderebbero questo programma più efficiente, più breve e più leggibile.

Molto, molto lento; TIO scade anche con la risposta non banale possibile più semplice, quindi non ha molto senso fornire un collegamento TIO. Ho verificato questo programma eseguendolo localmente.

Questa è una funzione (non un programma completo), il cui output è un generatore (al contrario di un elenco). Aggiungi .w⊥alla fine della funzione se vuoi vedere tutti gli output, piuttosto che solo il primo. (Si noti che questo non ha molta importanza nella pratica, perché poiché il programma è troppo lento per TIO, è necessario eseguirlo localmente e l'interprete Brachylog locale viene eseguito in un REPL che può descrivere un generatore perfettamente.)

Spiegazione

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

Provalo online . TIO impiega circa un minuto per l'ultimo testcase. I miei risultati corrispondono a @ Dennis's.

Pyth - 57 51 49 42 byte

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

Provalo