Seventy Seven Sevens

19

É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 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.
Urne de poulpe magique
la source
J'ai du mal à analyser "lister les nombres qui peuvent être créés en multipliant deux ou plusieurs nombres composés de seulement sept de longueur nou moins qui sont inférieurs à l"
xnor
Est-il acceptable d'avoir plusieurs chiffres sortis plus d'une fois?
drogué de mathématiques
La règle 5 est assez inutile, est-ce que du code sera exécuté n=77et l=7**7**7, par exemple?
Jonathan Allan
1
Peut-on supposer que le résultat ne sera pas vide?
Titus
@JonathanAllan true.
Urne de poulpe magique du

Réponses:

1

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
Emigna
la source
$L7ׂ˜- a essayé d'obtenir 5 octets, n'a pas pu.
Urne de poulpe magique du
@carusocomputing: Oui, j'ai l'impression que 6 octets, c'est trop, mais je ne vois vraiment pas de chemin plus court. J'espérais que tu
m'écoles
Je pensais .pou .strop, mais même ceux-ci semblent plus longs. J'ai accidentellement frappé «rafraîchir» sur la page TIO avec mon exemple d'implémentation au lieu de l'exécuter, je l'ai supprimé d'existence. Je pense que c'était 26 cependant.
Urne de poulpe magique
1
@carusocomputing: C'est pourquoi vous devez toujours appuyer régulièrement sur le bouton de lien. Ne perdez rien en rafraîchissant ou en redémarrant l'ordinateur. Un peu ennuyeux de perdre l'histoire cependant :)
Emigna
7

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.
Dennis
la source
6

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!

Dennis
la source
4

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.

Arnauld
la source
4

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

Jörg Hülsermann
la source
while($c=$t*$v[+$i++])$l<$c?f($c)&$r[$c]=$c;enregistre 3 octets; mais ça devrait l'être $l<=$c. $r?sort($r)&print_r($r):0;au lieu d'en $r=[];enregistre un.
Titus
1
$z.=7;est 5 octets plus court que $z=$z*10+7;.
Titus
et @est un autre 4 octets plus court que $r?...:0;. (Merci @Christoph)
Titus
@Titus Pourquoi devrait-il en être ainsi $l<=$c? Il semble qu'hier n'était pas mon jour pour le $z.=7et les 2 octets supplémentaires que j'ai trouvés. Je pense d'abord à vos deux autres suggestions. Vous manquez la :boucle in the while
Jörg Hülsermann
J'ai demandé au PO de clarifier. Dans la description, il parle de résultats that are less than l, dans ses exemples, ils are less than or equal. Selon la clarification, $c>$l||.../ $c>$l?:...ou $c<$l&&...sont les plus courts.
Titus
4

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!

Encre de valeur
la source
3

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
Leaky Nun
la source
3

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
Titus
la source
1
for([,$c,$z]=$argv,$n=1+$c;$c<$z;au lieu defor($n=1+$c=$argv[1];$c<$z=$argv[2];
Jörg Hülsermann
1
Utiliser @au lieu de $r&&pour supprimer l'avertissement? $p<$z&&$r[$p]=$p
Christoph
Je viens de remarquer que cela devrait être un $p>$z?:$r[$p]=$pexemple, n=1, l=343il est clair que cela ldevrait être inclus. Par conséquent, aucune économie lors de l'utilisation de $p>$z||$r[$p]=$pou $p>$z?:$r[$p]=$p.
Christoph
1
@Christoph J'ai demandé au PO de clarifier. Merci de me l'avoir rappelé @; sera édité lorsque l'OP répond.
Titus
1
@Christoph semble aller bien; et peu importe que ce soit $p>$z||ou $p<$z&&. Je m'en tiendrai à la description.
Titus
3

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.

la source
2

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.

Traumatisme numérique
la source
1

Pyth - 57 51 49 42 octets

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

Essayez-le

Maria
la source
2
Bienvenue chez PPCG! Il existe de nombreux raccourcis disponibles, qui peuvent réduire votre code de beaucoup d'octets. Vous pouvez venir dans notre salon de discussion et me cingler si vous voulez en savoir plus.
Leaky Nun
1
Malheureusement, votre programme actuel ne génère pas les résultats corrects, à savoir qu'il inclut 7et 77pour votre entrée actuelle.
Leaky Nun
1
Les moyens de réduire les octets comprennent: l'utilisation à la mplace de Fou Vetc. (programmation fonctionnelle vs contrôle d'exécution); en utilisant hQau lieu de @Q0; en utilisant eQau lieu de @Q1; en utilisant i*hQ]7Tau lieu de la longue boucle for pour générer 777...7.
Leaky Nun
@LeakyNun Merci beaucoup pour les suggestions et le lien chatroom. Aussi, je l'ai corrigé.
Maria