Wenn Sie eine Zahl nund eine Obergrenze angeben, llisten Sie die Zahlen auf, die durch Multiplikation von zwei oder mehr Zahlen erstellt werden können, die nur aus siebenn oder weniger Längen bestehen , die kleiner als sind l. A161145 steht kurz vor dieser Herausforderung. Sie werden jedoch NICHT die Werte 7, 77, 777, 7777, 77777 usw. berücksichtigen.

Beispiele

n=anything, l<49 würde ergeben:

[]

n=1, l=49 würde ergeben:

7*7=49

f(1,49)=[49]

n=1, l=343 würde ergeben:

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

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

n=2,l=6000 würde ergeben:

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 würde ergeben:

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

Etc...

Regeln

1. Sie müssen keine Zwischenschritte ausgeben, dies dient der Übersichtlichkeit.
2. Die Ausgabe kann als Array oder durch ein beliebiges Zeichen (auch Zeilenvorschub) getrennt erfolgen.
3. Die Ausgabe muss in numerischer Reihenfolge erfolgen, von der niedrigsten zur höchsten.
4. Damit der Titel relevant wird n, muss der höchste behandelt werden n=77(wenn Sie nicht mit dem höchsten umgehen können, beachten Sie, warum - Spracheinschränkungen akzeptabel sind, Faulheit nicht). Diese Einschränkung soll die Benutzer daran hindern, die gesamte Obermenge im Speicher zu erstellen.
5. Wenn TIO n=77für Ihren Code nicht ausgeführt werden kann, erläutern Sie, welche Spezifikationen erforderlich waren, um dies zu erreichen n=77.
6. Damit ein Produkt gültig ist, muss es aus mindestens 2 Zahlen bestehen.
7. Dies ist Code-Golf. Die niedrigste Byteanzahl wird als siegreich eingestuft.
8. Sie können die Liste so auswählen, dass sie Elemente enthält, die kleiner loder gleich sind l.
9. BONUS : Wenn Ihr Code genau 77 Bytes hat, ein dickes Lob von mir; wertlos, ich weiß.

05AB1E , 19 Bytes

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

Probieren Sie es online!

Erläuterung

Sehr ineffizient. TIO Link führt ceil(l^(1/7))Iterationen anstelle der lin der Golfversion verwendeten Iterationen durch, um das Testen großer Testfälle zu vereinfachen.

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

Jelly , 21 20 19 18 Bytes

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

Beachten Sie, dass der Ausgang nicht mit den OPs übereinstimmt. Ich habe einen Kommentar hinterlassen.

Probieren Sie es online!

Wie es funktioniert

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)

Beachten Sie, dass TIO nicht genügend Speicher für den letzten Testfall hat.

Probieren Sie es online!

JavaScript (ES6), 103 bis 101 Byte

Übernimmt Eingaben in der Currying-Syntax (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)

Testfälle

Der letzte Testfall kann einige Sekunden dauern.

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 Entfernen $r=[];und Ersetzen sort($r);mit@sort($r);

Online Version

Erweitert

Eine rekursive Funktion macht alle Permutationen einschließlich des Limits

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

Erweitert

ein loop till inklusive limit prüft jeden durch 49 teilbaren wert

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

Online Version

Ein paar Bytes mehr und ein assoziatives Array können erstellt werden. Geben Sie die Nummer und als Wert ein Array der verwendeten Siebenen ein

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

Online Version

Ruby, 89 86 Bytes

Eine rekursive Lösung.

-3 Bytes, indem Sie daran denken, dass alles, was mal 0 ist, 0 ist.

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

Probieren Sie es online!

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

Probieren Sie es online!

Technische Daten

• Eingang: l[newline]n
• Ausgabe: array containing the sorted result

PHP, 128 125 130 129 127 123 Bytes

funktioniert bis zu 22 7s, rundet jedoch größere Werte (7 ** 23 ist Gleitkomma auf einer 64-Bit-Maschine).

3 Bytes gespeichert von Jörg, 3 von mir, 5 4 1 hinzugefügt, um eine Warnung vor leeren Ergebnissen zu vermeiden.

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

Nimmt Eingaben von Befehlszeilenargumenten entgegen. Laufen Sie mit -nroder versuchen Sie es online .

Nervenzusammenbruch

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?∧!}

In der Sprache selbst gibt es hier viel Raum für Verbesserungen. Einige Dinge, die ich geschrieben habe, scheinen offensichtlich verbesserungsfähig zu sein, wenn man das Design der Sprache ändert. Dies ist der kürzeste Weg, den ich mit der aktuellen Version gefunden habe. Ich kann durchaus einige Vorschläge für Brachylog machen, die dieses Programm effizienter, kürzer und lesbarer machen würden.

Sehr sehr langsam; TIO überschreitet das Zeitlimit sogar bei der einfachstmöglichen, nicht trivialen Antwort, sodass es nicht sinnvoll ist, eine TIO-Verbindung bereitzustellen. Ich habe dieses Programm überprüft, indem ich es lokal ausführe.

Dies ist eine Funktion (kein vollständiges Programm), deren Ausgabe ein Generator ist (im Gegensatz zu einer Liste). Fügen Sie .w⊥am Ende der Funktion hinzu, wenn Sie nicht nur die erste, sondern alle Ausgaben anzeigen möchten. (Beachten Sie, dass dies in der Praxis keine Rolle spielt, da das Programm für TIO ohnehin zu langsam ist, müssen Sie es lokal ausführen, und der lokale Brachylog-Interpreter wird in einer REPL ausgeführt, die einen Generator genau beschreiben kann.)

Erläuterung

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

Probieren Sie es online aus . TIO benötigt ungefähr eine Minute für den letzten Testfall. Meine Ergebnisse stimmen mit denen von @ Dennis überein .

Pyth - 57 51 49 42 Bytes

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

Versuch es