Étant donné un nombre net une lliste de limites supérieures, les nombres qui peuvent être créés en multipliant deux ou plusieurs nombres composés uniquement de sept de longueur nou moins qui sont inférieurs à l. A161145 est proche de ce défi, cependant, vous n'incluerez PAS les 7, 77, 777, 7777, 77777, etc.

Exemples

n=anything, l<49 entraînerait:

[]

n=1, l=49 entraînerait:

7*7=49

f(1,49)=[49]

n=1, l=343 entraînerait:

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

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

n=2,l=6000 entraînerait:

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 entraînerait:

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

Etc...

Règles

1. Vous n'avez pas besoin de sortir des étapes intermédiaires, cela a été fait pour plus de clarté.
2. La sortie peut être sous forme de tableau ou séparée par n'importe quel caractère (même les retours à la ligne).
3. La sortie doit être dans l'ordre numérique, du plus bas au plus élevé.
4. Pour que le titre soit pertinent, le plus élevé nqui doit être traité est n=77(si vous ne pouvez pas gérer ce niveau, notez pourquoi - les restrictions linguistiques sont acceptables, la paresse ne l'est pas). Cette limitation est de gêner ceux qui cherchent à construire le surensemble complet en mémoire.
5. Si TIO ne peut pas s'exécuter n=77pour votre code, expliquez quelles spécifications étaient nécessaires pour atteindre n=77.
6. Pour qu'un produit soit valide, il doit comprendre au moins 2 chiffres.
7. Il s'agit du plus petit nombre d'octets de code-golf qui sera considéré comme vainqueur.
8. Vous pouvez choisir que la liste contienne des éléments inférieurs lou inférieurs / égaux à l.
9. BONUS : Si votre code fait exactement 77 octets, bravo à moi; sans valeur, je sais.

05AB1E , 19 octets

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

Essayez-le en ligne!

Explication

Très inefficace. Le lien TIO effectue des ceil(l^(1/7))itérations au lieu des litérations utilisées dans la version golfée pour tester plus facilement les grands testcases.

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ée , 21 20 19 18 octets

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

Notez que la sortie ne correspond pas aux OP. J'ai laissé un commentaire.

Essayez-le en ligne!

Comment ça fonctionne

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 113 109 octets

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)

Notez que TIO n'a pas assez de mémoire pour le dernier cas de test.

Essayez-le en ligne!

JavaScript (ES6), 103 101 octets

Prend une entrée dans la syntaxe 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)

Cas de test

Le dernier cas de test peut prendre quelques secondes.

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 octets

$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 octets supprimant $r=[];et remplacer sort($r);par@sort($r);

Version en ligne

Étendu

Une fonction récursive fait toutes les permutations y compris la 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 octets

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

Étendu

une boucle jusqu'à ce que la limite vérifie chaque valeur divisible par 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);

Version en ligne

quelques octets de plus et un tableau associatif peut être créé en saisissant le nombre et comme valeur un tableau des sept utilisés

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

Version en ligne

Rubis, 89 86 octets

Une solution récursive.

-3 octets en se souvenant que tout ce qui est 0 est 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: []}

Essayez-le en ligne!

Pyth , 22 octets

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

Essayez-le en ligne!

Spécifications

• Contribution: l[newline]n
• Production: array containing the sorted result

PHP, 128 125 130 129 129 127 123 octets

fonctionnera jusqu'à 22 7s mais arrondira des valeurs plus grandes (7 ** 23 est une virgule flottante sur une machine 64 bits).

3 octets enregistrés par Jörg, 3 par moi, 5 4 1 ajouté pour éviter l'avertissement de résultats vides.

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

prend l'entrée des arguments de ligne de commande; courir avec -nrou essayer en ligne .

panne

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 octets

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

Il y a beaucoup de possibilités d'amélioration dans la langue elle-même, ici; pas mal de choses que j'ai écrites semblent être évidemment améliorables avec quelques changements dans la conception du langage. C'est le moyen le plus court que j'ai trouvé avec la version actuelle. Je peux très bien faire quelques suggestions pour Brachylog qui rendraient ce programme plus efficace, plus court et plus lisible.

Très, très lent; TIO expire même sur la réponse non triviale la plus simple possible, il n'y a donc pas grand intérêt à fournir un lien TIO. J'ai vérifié ce programme en l'exécutant localement.

C'est une fonction (pas un programme complet), dont la sortie est un générateur (par opposition à une liste). Ajouter.w⊥ à la fin de la fonction si vous voulez voir toutes les sorties, plutôt que juste la première. (Notez que cela n'a pas vraiment d'importance dans la pratique, car comme le programme est trop lent pour TIO de toute façon, vous devez l'exécuter localement et l'interpréteur Brachylog local s'exécute dans un REPL qui peut décrire très bien un générateur.)

Explication

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.

Utilitaires 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

Essayez-le en ligne . TIO prend environ une minute pour le dernier testcase. Mes résultats correspondent à ceux de Dennis.

Pyth - 57 51 49 42 octets

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

Essayez-le