50

Étant donné deux entiers positifs, A et B, illustrent leur plus petit multiple commun en générant deux lignes de tirets ( -) de longueur LCM (A, B) après avoir remplacé chaque tiret Ath de la première ligne et chaque tiret de la deuxième ligne par des barres verticales ( |)

De cette façon, la fin de chaque ligne sera le seul endroit où deux |sont alignés.

Par exemple, si A = 6 et B = 4, LCM (6, 4) = 12, ainsi:

two lines of 12 dashes:
------------
------------

replace every 6th dash in the first line with a vertical bar:
-----|-----|
------------

replace every 4th dash in the second line with a vertical bar:
-----|-----|
---|---|---|

Ainsi, le résultat final serait

-----|-----|
---|---|---|

L'ordre des nombres entrés doit correspondre à l'ordre des lignes.

Le code le plus court en octets gagne.

Testcases

A B
line for A
line for B

1 1
|
|

1 2
||
-|

2 1
-|
||

2 2
-|
-|

6 4
-----|-----|
---|---|---|

4 6
---|---|---|
-----|-----|

2 3
-|-|-|
--|--|

3 2
--|--|
-|-|-|

3 6
--|--|
-----|

2 5
-|-|-|-|-|
----|----|

4 3
---|---|---|
--|--|--|--|

10 10
---------|
---------|

10 5
---------|
----|----|

10 6
---------|---------|---------|
-----|-----|-----|-----|-----|

24 8
-----------------------|
-------|-------|-------|

7 8
------|------|------|------|------|------|------|------|
-------|-------|-------|-------|-------|-------|-------|

6 8
-----|-----|-----|-----|
-------|-------|-------|

13 11
------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|------------|
----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|----------|

— Les passe-temps de Calvin
source

3

@LeakyNun Il semble plus facile d' étendre une réponse à partir de codegolf.stackexchange.com/q/94999 . Quoi qu’il en soit, les gens s’amuseront à faire celui-ci, qui est une raison décente.

— Les passe-temps de Calvin

1

Puis-je sortir un tableau avec deux chaînes, une pour chaque ligne?

— BlackCap

@BlackCap No. Imprimez les chaînes sur stdout ou un fichier ou renvoyez la chaîne multiligne complète.

— Les passe-temps de Calvin

2

Bonus pour le traitement d'un nombre arbitraire d'entrées?

— Adám

1

@ HelkaHomba Ok merci; enregistré 1 octet supplémentaire. :) (Comme s'il y avait une autre raison de poser de telles questions sur les défis CodeGolf.; P)

— Kevin Cruijssen Le

11

Python 3, 80 octets

Enregistré 1 octet grâce à Halvard Hummel et 1 octet à Jonathan Allan.

import math
def f(*l):
 for k in 0,1:print(l[~k]//math.gcd(*l)*(~-l[k]*"-"+"|"))

Testez-le en ligne!

lambda*l:"\n".join(l[0]*l[1]//math.gcd(*l)//k*(~-k*"-"+"|")for k in l)
import math

Testez-le en ligne! (82 octets - réponse initiale)

C'est le mieux que j'ai pu faire dans Python 2 (81 octets). Il semble que je ne puisse pas commenter cette réponse, je vais simplement poster ceci ici:

from fractions import*
l=a,b=input()
for k in l:print a*b/gcd(*l)/k*(~-k*"-"+"|")

Testez-le en ligne!

Première tentative ici, probablement sous-optimale!

2

Bienvenue chez PPCG!

— Laikoni

3

@Laikoni Merci! Cela semble être une communauté amusante :-)

81 octets

— Halvard Hummel

@HalvardHummel Merci, affichera comme alternative!

En essayant une approche complètement différente, je me suis rendu compte que votre version pourrait être réalisée en 80 .

— Jonathan Allan

10

Haskell , 57 octets

x%y=unlines[["-|"!!(0^mod a b)|a<-[1..lcm x y]]|b<-[x,y]]

Essayez-le en ligne!

— Laikoni
source

Je n'ai jamais vu ce 0^0=1tour auparavant - malin

— BlackCap

@BlackCap Je ne peux pas le dire moi-même parce que je l'ai déjà vu plusieurs fois, bien que je ne me souvienne pas où j'ai vu le tour en premier.

— Laikoni

7

Gelée , 12 octets

Ṭ€ị⁾|-ṁ€æl/Y

Essayez-le en ligne!

— Erik l'Outgolfeur
source

6

MATL , 16 15 octets

'-|'!i&Zm:G\go)

L'entrée est un vecteur de colonne avec les deux nombres. Essayez-le en ligne!

En prime, l'entrée peut contenir plus de deux nombres. . Essayez-le en ligne!

Explication

'-|'   % Push this string
!      % Transpose. This is needed because of input [1; 1]
i      % Input column vector of 2 (or N) numbers
&Zm    % LCM of the 2 (or N) numbers, say L
:      % Range
G      % Push input again
\      % Modulus, element-wise with broadcast. Gives a 2×L (or N×L) matrix
g      % Convert to logical: gives false for zeros, true for nonzeros
o      % Convert to double: gives 0 for false, 1 for true
)      % Index into string (modular, 1-based). Implicitly display

— Luis Mendo
source

Je pense que tu es parti errant He?

— Sanchises

@Sanchises Merci! Oui, c'était dans la version précédente, mais ce n'est pas nécessaire

— Luis Mendo le

En outre, cela semble bien fonctionner sans la transposition? Vous avez trop réfléchi ...;)

— Sanchises Le

@Sanchises Sans la transposition, cela ne fonctionne pas en entrée [1; 1], à cause de la façon dont MATL (AB) gère la forme d'un tableau avec indexation. (Alternativement, la transposition pourrait être remplacée par Hela fin, c'est pourquoi elle était initialement là)

— Luis Mendo

Ah oui, je pensais que c'était là à cause du comportement des lignes, mais je ne pensais pas à ce cas.

— Sanchises

5

R , 109 105 octets

function(a,b){q=1:a*b
l=min(q[!q%%a])
x=rep("-",l*2)
x[c(seq(0,l,a),l+seq(0,l,b))]="|"
write(x,"",l,,"")}

Essayez-le en ligne!

Fonction anonyme. Calcule l=lcm(a,b), génère ensuite un intervalle de 0à lpar a, puis à partir lde 2*lpar b, l' établissement des indices à |et l' impression en tant que matrice avec des lcolonnes.

— Giuseppe
source

5

Python 2 , 66 octets

l=a,b=input()
while a%b:a+=l[0]
for x in l:print a/x*('-'*~-x+'|')

Essayez-le en ligne!

— Xnor
source

4

C, 72 octets

i;f(x,y){for(i=1;i%y|i%x;)putchar(i++%x?45:124);puts("|");y>0&&f(y,-x);}

— orlp
source

4

Husk , 12 octets

†?'-'|TUṪ`%N

Essayez-le en ligne!

Oui, il y a un lcm intégré dans Husk. Non, je n'en ai pas besoin

Bonus: fonctionne avec n'importe quel nombre de valeurs d'entrée

Explication

†?'-'|TUṪ`%N    input:[2,3]
        Ṫ`%N    table of all remainders of positive naturals divided by
                input numbers:
                             [[1,1],[0,2],[1,0],[0,1],[1,2],[0,0],[1,1],[0,2],...
       U        get all elements before the first repeated one:
                             [[1,1],[0,2],[1,0],[0,1],[1,2],[0,0]]
      T         transpose:   
                             [[1,0,1,0,1,0],[1,2,0,1,2,0]]
†?'-'|          replace all truthy elements with '-' and all falsy elements
                with '|': 
                             ["-|-|-|","--|--|"]
                implicit: since this is a full program, join the resulting array
                of strings with newlines, and print to stdout

— Leo
source

4

Mathematica, 63 octets

(s=LCM@##;Print[""<>If[i~Mod~#<1,"|","-"]~Table~{i,s}]&/@{##})&

Essayez-le en ligne!

et une autre version qui user202729 veut vraiment voir vraiment posté

Mathematica, 59 octets

(s=LCM@##;Print[""<>If[#∣i,"|","-"]~Table~{i,s}]&/@{##})&

celui-ci utilise un caractère spécial \[Divides] ∣

— J42161217
source

S'il s'agit de Mathematica, vous pouvez probablement utiliser à la \[Divides]place d' Modopérateur pour représenter la divisibilité, ce qui économise 4 octets. Mathics TIO ne doit pas non plus imprimer le fichier {Null, Null}.

— user202729

@ user202729 J'ai corrigé l'impression en mathématiques.

— J42161217

3

Je pense que votre premier commentaire était assez clair. S'il vous plaît, arrêtez de me presser pour apporter les modifications souhaitées, l'heure exacte que vous souhaitez. Donnez aux utilisateurs quelques heures pour répondre. Certains d'entre nous ont une vie hors de cet endroit

— J42161217

3

05AB1E , 13 octets

ʒ<'-×'|«¹.¿∍,

Utilise le codage 05AB1E . Essayez-le en ligne!

— Adnan
source

Filtrer était une bonne idée, je l'ai fait de façon totalement différente .¿Lε²¹‚%_„-|è}øJ».

— Magic Octopus Urn

3

APL (Dyalog) , 22 octets

Suppose ⎕IO←0. Prend A, B comme bon argument. Prime: gère la liste de saisie de n'importe quelle longueur!

{'|-'[⌽×⍵∘.|⍳∧/⍵]}

Essayez-le en ligne!

{… } Lambda anonyme où⍵ représente le bon argument

'|-'[…] Indexez la chaîne avec:

∧/ LCM à travers l'entrée

⍳ d' abord que beaucoup ɩ ntegers (0 à N-1)

⍵∘.| division reste table avec l'entrée verticalement et horizontalement

× signum

⌽ retourner horizontalement

— Adam
source

Que signifie cette première hypothèse?

— Calvin's Hobbies

@ HelkaHomba Cela signifie que les tableaux commencent à 0, valeur par défaut sur les interpréteurs APL, je crois.

— Conor O'Brien

@ HelkaHomba Comme les systèmes APL sont proposés en versions à la fois 0 et 1, je rédige simplement l'hypothèse. Sinon, il faudrait avoir deux APL. Par exemple, ngn / apl peut exécuter ce même code sans spécifier ⎕IO←0, car il s'agit du code par défaut.

— Adám

3

Octave , 46 38 octets

-8 octets grâce aux suggestions de Luis Mendo

@(a,b)'-|'.'(~mod(1:lcm(a,b),[a;b])+1)

Essayez-le en ligne!

— Giuseppe
source

3

JavaScript (ES6), 69 octets

f=(a,b,S,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,S,A+1):S?'':`
`+f(b,a,1))

Récursivement s'exécute jusqu'à ce qu'il Asoit divisible par les deux aet b- produisant un tiret ou un tuyau en fonction de ala divisibilité de A.

La fonction s’appelle alors elle-même, swapping aet b.

La Svariable empêche la fonction de s’appeler infiniment.

Cas de test:

Afficher l'extrait de code

f=(a,b,S,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,S,A+1):S?'':`
`+f(b,a,1))

console.log(f(1,1));
console.log(f(1,2));
console.log(f(2,1));
console.log(f(2,2));
console.log(f(6,4));
console.log(f(4,6));
console.log(f(2,3));
console.log(f(3,2));
console.log(f(10,10));
console.log(f(3, 6));
console.log(f(2, 5));
console.log(f(4, 3));
console.log(f(10, 10));
console.log(f(10, 5));
console.log(f(10, 6));
console.log(f(24, 8));
console.log(f(7, 8));
console.log(f(6, 8));
console.log(f(13, 11));

Expand snippet

Réponses précédentes:

JavaScript (ES8), 91 octets

f=(a,b,i=2,g=(c,d)=>d?g(d,c%d):c)=>i?'|'.padStart(a,'-').repeat(b/g(a,b))+`
`+f(b,a,i-1):''

Utilise les algorithmes:

lcm(a, b) = ab / gcd(a, b)
gcd(c, d) = d ? gcd(d, c%d) : c

S'appelle de manière récursive une seule fois pour sortir la deuxième ligne.

Cas de test:

Afficher l'extrait de code

f=(a,b,i=2,g=(c,d)=>d?g(d,c%d):c)=>i?'|'.padStart(a,'-').repeat(b/g(a,b))+`
`+f(b,a,i-1):''

console.log(f(1,1));
console.log(f(1,2));
console.log(f(2,1));
console.log(f(2,2));
console.log(f(6,4));
console.log(f(4,6));
console.log(f(2,3));
console.log(f(3,2));
console.log(f(10,10));
console.log(f(3, 6));
console.log(f(2, 5));
console.log(f(4, 3));
console.log(f(10, 10));
console.log(f(10, 5));
console.log(f(10, 6));
console.log(f(24, 8));
console.log(f(7, 8));
console.log(f(6, 8));
console.log(f(13, 11));

Expand snippet

JavaScript (ES6), 93 octets

f=(a,b,i=2,g=(c,d)=>!d=>d?c:g(d,c%d):c)=>i?('-'.repeat(a-1)+'|').repeat(a*bb/g(a,b)/a)+`
`+f(b,a,i-1):''

Même algorithme que précédemment, en utilisant repeatau lieu de padStart.

— Rick Hitchcock
source

1

Je pensais padStartêtre ES8?

— Neil

1

f=(a,b,A=1)=>(A%a?'-':'|')+(A%a|A%b?f(a,b,A+1):a<0?'':`\n`+f(-b,a))

— l4m2

@ l4m2, je peux à peine comprendre le code que j'ai écrit il y a un an, mais il semblerait que le vôtre efface quelques octets, merci!

— Rick Hitchcock

3

Scala, 98 octets

print((a to a*b).find(l=>l%a+l%b==0).map(l=>("-"*(a-1)+"|")*(l/a)+"\n"+("-"*(b-1)+"|")*(l/b)).get)

Essayez-le en ligne

— laitue en cubes
source

Bonjour, bienvenue sur PPCG! Cela ressemble à une excellente première réponse, donc +1 de ma part. Je ne sais pas, puisque je ne l' ai jamais programmé à Scala, mais peut - *(a-1)être à joué au golf *~-aet *(b-1)à *~-b? Aussi, pourriez-vous peut-être ajouter un lien TIO avec le code de test? (Oh, et cet avatar ne me semble pas très cubique.; P)

— Kevin Cruijssen le

2

Merci! Le truc avec *~-aest grande, mais malheureusement Scala nécessite plus de crochets: *(~(-a))pour préciser que les concaténations *~-, *~, ~-ne sont pas des noms de fonction de fantaisie. J'ai ajouté un lien TIO.

— laitue en cubes

Ah oui, ~-peuvent être des noms de fonctions dans Scala. Je me souviens de quelqu'un qui a mentionné cela il y a longtemps. C'est dommage en ce qui concerne le golf. Encore une fois, bienvenue et bonne première réponse.

— Kevin Cruijssen

3

Java (OpenJDK 8) , 103 octets

a->b->{String l="",r="|\n";for(int m=0;(++m%a|m%b)>0;r+=m%b<1?'|':'-')l+=m%a<1?'|':'-';return l+r+'|';}

Essayez-le en ligne!

110 octets, n valeurs d'entrée

a->{String s="";for(int v:a){for(int i=1,z=1;z>(z=0);s+=i++%v<1?'|':'-')for(int k:a)z|=i%k;s+='\n';}return s;}

Essayez-le en ligne!

— Nevay
source

3

Java 8, 125 118 117 octets

a->b->{String A="\n",B=A,t="|";for(int i=1;!A.endsWith(t)|!B.endsWith(t);B+=i++%b<1?t:"-")A+=i%a<1?t:"-";return A+B;}

-7 octets grâce à @Nevay .
-1 octet en commençant par un retour à la ligne (A="",B="\n" remplacée par A="\n",B=A).

Explication:

Essayez ici.

a->b->{             // Method with two integer parameters and String return-type
  String A="\n",    //  String top line (starting with a trailing new-line)
         B=A,       //  String bottom-line (starting with a new-line)
         t="|";     //  Temp String "|" which is used multiple times
  for(int i=1;      //  Index-integer, starting at 1
      !A.endsWith(t)|!B.endsWith(t);
                    //  Loop as long as both Strings aren't ending with "|"
      B+=           //    After every iteration: append `B` with:
         i++%b<1?   //     If `i` is divisible by `b`:
                    //     (and increase `i` by 1 in the process)
          t         //      `t` (holding "|")
         :          //     Else:
          "-")      //      A literal "-"
    A+=             //   Append `A` with:
       i%a<1?       //    If `i` is divisible by `a`
        t           //     `t` (holding "|")
       :            //    Else:
        "-";        //     A literal "-"
                    //  End of loop (implicit / single-line body)
  return A+B;       //  Return both lines, separated by the new-line `B` started with
}                   // End of method

— Kevin Cruijssen
source

1

118 octets:a->b->{String A="",B="\n",k="|";for(int i=0;!A.endsWith(k)|!B.endsWith(k);B+=i%b<1?k:"-")A+=++i%a<1?k:"-";return A+B;}

— Nevay

@ Merci Merci. Je ne peux pas croire que j'ai manqué la chose la plus évidente !A.endsWith(t)|!B.endsWith(t)lorsque je cherchais un moyen court de vérifier si les deux se terminaient par |.. Et commencer par B avec une nouvelle ligne au lieu de la placer entre eux au retour est également intelligent.

— Kevin Cruijssen

2

Python 2 , 96 88 octets

Edit: 4 octets sauvegardés grâce à @Leaky Nun

Edit: 4 octets sauvegardés grâce à @Rod

lambda a,b:b/gcd(a,b)*("-"*~-a+"|")+"\n"+a/gcd(a,b)*("-"*~-b+"|")
from fractions import*

Essayez-le en ligne!

— Halvard Hummel
source

88 octets ou 77 octets pour une sortie plus flexible

— Rod

88 octets

— ovs

1

Apparemment, produire une liste de chaînes n'est pas acceptable. : Je remplace [...]par '\n'.join(...)pour réparer.

— totalement humain

2

Python 2 , 89 octets

Pas l’entrée Python 2 la plus courte, mais une approche différente de celle gcd qui peut encore être jouable au golf.

a,b=input()
h,p='-|'
x=b*(h*~-a+p),a*(h*~-b+p)
for v in x:print v[~zip(*x).index((p,p)):]

Essayez-le en ligne!

— Jonathan Allan
source

2

Haskell , 66 60 octets

a#b=do x<-[a,b];lcm a b`take`cycle(([2..x]>>"-")++"|")++"\n"

Essayez-le en ligne!

Même longueur:

a#b=unlines[take(lcm a b)$cycle$([2..x]>>"-")++"|"|x<-[a,b]]

Ancienne solution:

l!x=[1..div l x]>>([2..x]>>"-")++"|"
a#b|l<-lcm a b=l!a++'\n':l!b

— BlackCap
source

1

Vous pouvez enregistrer un octet avec '\n':.

— Laikoni

@Laikoni Attention, je me rapproche de toi

— BlackCap le

1

C (gcc) , 121 99 93 92 89 octets

Cela devrait être beaucoup plus court, hmmmm ....

#define L(x)for(j=-1,i=a;j<i;i+=i%b||i%a)putchar(++j?j%x?45:124:10);
i,j;f(a,b){L(a)L(b)}

Essayez-le en ligne!

— cleblanc
source

1

J , 20 octets

'-|'{~*.$&>;&(<:=i.)

Essayez-le en ligne!

— milles
source

c'est joli J

— Jonah

1

SOGL V0.12 , 19 16 octets

2{H┌*┐+..*..g/mP

Essayez-le ici!

Explication:

2{                two times do
  H                 decreate ToS - input - by 1
   ┌*               get that many dashes
     ┐+             append a vertical bar
       ..*          push both inputs multiplied           \
          ..g       push gcd(input1, input2)              | LCM - 7 bytes :/
             /      divide the multiblication by the GCD  /
              m     mold the string to that length
               P    print that in a new line

— dzaima
source

Vous avez documenté avant la mise en œuvre? o0

— totallyhuman

1

@icrieverytim SOGL a beaucoup, beaucoup de choses documentées qui ne sont pas implémentées. : p La documentation est essentiellement ma liste TODO (ce que je fais rarement: p)

— dzaima

1

Empilés , 42 38 octets

[:...lcm@z:[:z\/\#-'-'*\rep'|'+out]"!]

Essayez-le en ligne!

Entrez sous la forme d'une paire de nombres. Tous les tests mis en place ressemblent un peu à des bâtiments.

Explication

Cette première prend en compte le nombre lcmde deux entrées z. Ensuite, pour chaque numéro k, nous généronsz / k chaînes -de longueur k - 1, en ajoutant| à la fin de chaque nombre et en sortie.

Tentatives précédentes comptées

42 octets: [:...lcm@z:[:z\/\#-'-'*\rep'|'+''#`out]"!]

Autres tentatives

43 octets: [:...lcm@z:[:z\/\#-'-'*\rep'|'#`'|'+out]"!]

45 octets: ['@lcm'!#~@z,[:z\/\#-'-'*\rep'|'#`'|'+out]"!]

45 octets: [:...lcm@x[x'-'*\#<$betailmap'|'#`'|'+out]"!]

53 octets: [:...lcm'-'*@z#-'.'*'('\+')'+'.'+[z\'$1|'repl out]"!]

54 octets: [:...lcm@x{!x'-'*('('n#-'.'*').')''#`'$1|'repl out}"!]

— Conor O'Brien
source

1

JavaScript (ES6), 89

f=(a,b,t=`
`,l=0,R=n=>'-'.repeat(n-1)+'|')=>l||1/t?f(a,b,l<0?t+R(b,l+=b):R(a,l-=a)+t,l):t

Évaluer le LCM avec des addictions répétées.

Moins joué au golf

F=(a,b, sa='', sb='', la=0, lb=0)=>
{
    var R=n=>'-'.repeat(n-1)+'|'
    if (la != lb || la == 0)
    {
        if (la < lb) {
            sa += R(a)
            la += a
        }
        else
        {
            sb += R(b)
            lb += b
        }
        return F(a, b, sa, sb, la, lb)
    }
    else
        return sa+'\n'+sb
}

Tester

f=(a,b,t=`
`,l=0,R=n=>'-'.repeat(n-1)+'|')=>l||1/t?f(a,b,l<0?t+R(b,l+=b):R(a,l-=a)+t,l):t

function update()
{
  var [a,b]=I.value.match(/\d+/g)
  R.textContent = f(+a,+b)
}  

update()

<input id=I oninput='update()' value='4 6'>
<pre id=R></pre>

Développer l'extrait

— edc65
source

1

VBA (Excel), ~~144~~ 142 octets

Sub q()
a=[a1]
b=[a2]
Do Until c=d And d="|"
e=e+1
c=IIf(e Mod a,"-","|")
d=IIf(e Mod b,"-","|")
f=f& c
g=g& d
Loop
Debug.? f& vbCr& g
End Sub

-2 octets. merci Sir Washington Guedes.

— remuer
source

Oui, merci @WashingtonGuedes. :)

— remuer

1

Ruby , 64 57 octets

->a,b{[a,b].map{|n|(1..a.lcm(b)).map{|x|x%n>0??-:?|}*''}}

-7 octets grâce à G B.

Essayez-le en ligne!

— Casse-croûte
source

Vous n'avez pas besoin d'inclure les 'options', si la fonction renvoie 2 chaînes, c'est bon. Et vous pouvez le raccourcir en utilisant l'opérateur array * (array * '' est équivalent à array.join)

— GB

@GB merci pour votre aide!

— Snack

1

Charbon de bois , 32 30 29 octets

ＮθＮη≔θζＷ﹪ζη≦⁺θζＥ⟦θη⟧…⁺×-⁻ι¹|ζ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Edit: 1 octet enregistré grâce à @ ASCII uniquement.

— Neil
source

29 octets

— ASCII uniquement

@ ASCII-only Quelque chose de nouveau à documenter!

— Neil

Merci de documenter! (désolé, je n'ai pas vraiment envie de documenter des choses même si je devrais vraiment le faire), si cela ne vous dérange pas, il y en a d'autres à documenter. chat.stackexchange.com/transcript/240?m=40270513#40270513 chat.stackexchange. com / transcript / 240? m = 40270838 # 40270838 (vous ne savez pas exactement où les distributions directionnelles doivent aller, ce ne sont ni des commandes ni des opérateurs)

— ASCII uniquement

1

Feuilles de Google, 77 octets

Formule anonyme de feuille de calcul qui prend des entrées A1:B1et des sorties dans la cellule appelante

=REPT(REPT("-",A1-1)&"|",LCM(1:1)/A1)&"
"&REPT(REPT("-",B1-1)&"|",LCM(1:1)/B1

-4 octets grâce à @EngineerToast

— Taylor Scott
source

1

Pouvez-vous présumer que rien d'autre n'est entré dans la rangée 1? Si c'est le cas, vous pouvez mettre en court-circuit LCM(A1,B1)juste LCM(1:1)pour économiser 4 octets. Je pense qu'il est raisonnable de supposer une feuille de départ vierge et de spécifier où se trouvent les entrées et la formule.

— Ingénieur Toast

1

Excel VBA, 79 octets

Fonction de fenêtre immédiate VBE anonyme qui prend une entrée de la plage [A1:B1] et affiche une visualisation de leur LCM dans la fenêtre immédiate VBE.

_{Ceci est un portage de ma réponse Google Sheets .}

?[Rept(Rept("-",A1-1)&"|",LCM(1:1)/A1)]:?[Rept(Rept("-",B1-1)&"|",LCM(1:1)/B1)]

— Taylor Scott
source

1

Japt , 12 octets

£×/Ury)î|ù-X

Japt Interpreter

Entrées sous forme de tableau de nombres. Sort en tant que tableau de chaînes. L'indicateur -R améliore légèrement l'apparence de la sortie, mais n'est pas nécessaire pour la logique.

Explication:

£              For each of the two inputs as X, print...
        |           The string "|"
         ù-X        Left-padded with "-" until it is X characters long
       î            Repeated until its length is
 ×/Ury)             The Least Common Multiple

Un merci supplémentaire à Shaggy pour avoir trouvé quelques octets à sauvegarder.

— Kamil Drakari
source

1

15 octets

— Shaggy,

@ Shaggy Intéressant, je n'ai jamais pensé à utiliser cette partie de Japt de cette manière.

— Kamil Drakari

1

Frappé encore quelques octets

— Shaggy

Illustrer le plus petit commun

Testcases

Python 3, 80 octets

Haskell , 57 octets

Gelée , 12 octets

MATL , 16 15 octets

Explication

R , 109 105 octets

Python 2 , 66 octets

C, 72 octets

Husk , 12 octets

Explication

Mathematica, 63 octets

Mathematica, 59 octets

05AB1E , 13 octets

APL (Dyalog) , 22 octets

Octave , 46 38 octets

JavaScript (ES6), 69 octets

JavaScript (ES8), 91 octets

JavaScript (ES6), 93 octets

Scala, 98 octets

Java (OpenJDK 8) , 103 octets

110 octets, n valeurs d'entrée

Java 8, 125 118 117 octets

Python 2 , 96 88 octets

Python 2 , 89 octets

Haskell , 66 60 octets

C (gcc) , 121 99 93 92 89 octets

J , 20 octets

SOGL V0.12 , 19 16 octets

Empilés , 42 38 octets

Explication

Tentatives précédentes comptées

Autres tentatives

JavaScript (ES6), 89

Ruby , 64 57 octets

Charbon de bois , 32 30 29 octets

Feuilles de Google, 77 octets

Excel VBA, 79 octets

Japt , 12 octets