Contributions:

Deux chiffres simples (appelons-les met n) et deux caractères (appelons-les aet b) dans le format d'entrée de votre choix.

Production:

Pour la procédure pas à pas, faites semblant m=2, n=5, a='a', b='b'.

Votre sortie sera une chaîne construite à partir de vos quatre entrées. Appelons la chaîne result, avec valeur "". D'abord, concaténer asur les result mtemps, donc concaténer asur les result 2temps. resultest maintenant égal à aa. En second lieu , concatenate bsur les result mtemps, donc concaténer bsur les result 2temps. resultest maintenant égal à aabb. Enfin, si le résultat est déjà plus long que n, tronquez resultpour qu'il ait une longueur n. Sinon, continuez d'alterner avec les mlongueurs de aet bjusqu'à ce que la resultlongueur ait n. La finale resultest aabba, qui a de la longueur 5.

Cas de test:

Input: m = 2, n = 4, a = A, b = B

Output: AABB

Input: m = 3, n = 8, a = A, b = B

Output: AAABBBAA

Input: m = 4, n = 3, a = A, b = B

Output: AAA

Input: m = 2, n = 10, a = A, b = B

Output: AABBAABBAA 

Comme tout le monde le sait, le moindre dirigera le monde, donc les plus petits programmes, en octets, gagneront! :)

Python , 32 octets

lambda m,n,a,b:((a*m+b*m)*n)[:n]

Essayez-le en ligne!

MATL , 5 octets

Y"i:)

Les entrées sont une chaîne avec les deux caractères, puis m, alors n.

Essayez-le en ligne!

Explication

Y"   % Implicit inputs: string and number m. Apply run-length decoding.
     % The second input is reused for each char in the first. Gives a
     % string
i    % Input number n
:    % Push vector [1 2 ... n]
)    % Index the string with the numbers in that vector. Indexing is
     % modular, so the chars are reused if necessary. Implicit display

Haskell, 44 40 octets

f=(.cycle).take
(n#m)a=f n.(f m a++).f m

Essayez-le en ligne!

Ruby, 29 caractères

->m,n,a,b{((a*m+b*m)*n)[0,n]}

Exemple d'exécution:

irb(main):001:0> ->m,n,a,b{((a*m+b*m)*n)[0,n]}[3, 8, 'A', 'B']
=> "AAABBBAA"

Essayez-le en ligne!

Japt , 10 octets

VîUçW +UçX

Essayez d'abord d'utiliser une langue de golf. Essayez-le en ligne!

Explication

Vî          // repeat the following until it reaches length V (second input)
  UçW       // third input repeated U (first input) times
      +UçX  // plus the fourth input, repeated U times

05AB1E , 5 octets

×J×I£

Essayez-le en ligne!

Explication

×      # repeat a and b m times each
 J     # join to string
  ×    # repeat the string n times
   I£  # take the first n characters

Gelée , 6 4 octets

xFṁ⁵

Essayez-le en ligne!

Merci à Jonathan Allan pour un meilleur format d'entrée (-2).

V , 13 octets

ÀäjÀäêÍî
À|lD

Essayez-le en ligne!

aet bsont prises sur des lignes distinctes dans l'entrée, met nsont prises comme argument, inversées (tout ncomme le premier argument et mle deuxième)

Explication

Àäj      ' duplicate the inputs [arg 1] times
a -> a
b    b
     a
     b
     ...
   Àäê   ' duplicate everything straight down [arg 2] times - À cycles arguments
a -> aaa
b    bbb
a    aaa
b    bbb
...  ...
      Íî ' remove all newlines
-> aaabbbaaabbb...
À|lD     ' delete from the [arg 1] + 1 column onwards
-> aaabbbaa

Haskell , 36 35 29 octets

Encore une autre solution Haskell (attend les caractères donnés sous forme de liste):

(m#n)c=take n$cycle$c<*[1..m]

Essayez-le en ligne!

Merci @Laikoni pour -1 octet.

R , 41 39 octets

function(d,m,n)cat(d[gl(2,m,n)],sep='')

Une fonction anonyme; imprime le résultat sur stdout. Prend les personnages comme vecteur d=c(a,b). glgénère des facteurs (entiers) de (dans ce cas) des 2niveaux de longueur de course mavec la longueur totale n! catles concatène et les imprime sous forme de chaîne.

Essayez-le en ligne!

Javascript, 55 octets

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

Exemple d'extrait de code:

f=

(m,n,a,b)=>(a[r='repeat'](m)+b[r](m))[r](n).substr(0,n)

console.log(f(2, 4, 'A', 'B'))
console.log(f(3, 8, 'A', 'B'))
console.log(f(4, 3, 'A', 'B'))
console.log(f(2, 9, 'A', 'B'))

Javascript, 53 octets

(m,n,a,b)=>a.repeat(n).replace(/./g,(i,j)=>j/m&1?b:i)

Décortiquer , 3 octets

Port direct de ma réponse Haskell, sauf que l'ordre des arguments est différent:

↑¢Ṙ

Essayez-le en ligne!

Haskell , 48 43 octets

(m#n)a|r<-(<$[1..m])=take n.cycle.(r a++).r

Essayez-le en ligne!

QBIC , 37 27 octets

[:|G=;+G+;][:|G=G+G]?_sG,d

Explication

          This takes its arguments as frequency m, A, B, length n
          For example: 2, A, B, 8
 :        Read a cmd line arg as number 'b' ('a' is used by the FOR declaration as loop counter)
[ |       Start a FOR loop, from 1 to b
G=  G     Set G to hold itself
  ;+      prepended by a cmd line arg read as strig and assigned to A$
     +;   and followed by a cmd line arg read as strig and assigned to B$
]         At the end of the FOR loop, G has had A added to the front twice, and B t the end x2: G$ = AABB
[:|       FOR c = 1 to n
G=G+G]      Add G to itself          G$ = AABBAABBAABBAABBAABBAABBAABBAABB
?_sG,d    PRINT the first n chars of G$   AABBAABB

Tentative précédente:

(37b)  {Z=Z+;┘_LZ|~a=:|_X]~a%:|\C=A┘A=;┘B=C
Takes its arguments as `A, length n, frequency m, B`.
Basically adds A to Z until length % freq = 0, then swaps A for B. Loops until lengtn = n

PHP> = 7.1, 77 octets

for([,$x,$l,$f,$s]=$argv;$l-=$z;)echo str_repeat(++$i&1?$f:$s,$z=min($l,$x));

PHP Sandbox Online

Java (OpenJDK 8) , 75 octets

void f(int m,int n,char[]s){for(int i=0;i<n;)System.out.print(s[i++/m%2]);}

Essayez-le en ligne!

Cubix , 63 58 octets

.rr.@u:s?.\.sw).i|>v:.\nB;?(q:Is...;rr/s.uw/....sIB/\/?(qo

Essayez-le en ligne!

regarder l'interprète

Prend une entrée comme ab*m*noù le *peut être n'importe quel caractère non numérique.

Version du cube:

        . r r .
        @ u : s
        ? . \ .
        s w ) .
i | > v : . \ n B ; ? ( q : I s
. . . ; r r / s . u w / . . . .
s I B / \ / ? ( q o . . . . . .
. . . . . . . . . . . . . . . .
        . . . .
        . . . .
        . . . .
        . . . .

• i|is: lisez les caractères et échangez-les (donc ac'est en haut)
• I:q: lire m, copier et pousser vers le bas (la pile est maintenant m,b,a,m)
• ) : décrémenter
• ?: tourner à droite si positif, aller tout droit si zéro (doublons a)
• branche positive (boucle)
  • s:rur(/w: swap, dup, déplacer m-ivers le haut de la pile, décrémenterm-i
• branche zéro
  • B: pile inverse (qui a maintenant des mcopies de a:a... b m )
  • n: nier m(afin que nous puissions utiliser ?pour tourner à gauche)
  • ) : incrément
  • ? : aller tout droit si zéro, tourner à gauche si négatif
• branche négative (doublons b)
  • s:r\/rw)\ essentiellement la même que la branche positive mais avec incrément et virages à gauche.
• branche zéro (imprime la sortie)
  • >v;: sortez la 0pile (ressemble a...b...)
  • /B : inverser la pile
  • I : lis n
  • s : permuter la boucle d'impression:
• oq : imprimer et pousser vers le bas de la pile ressemble maintenant à: ab...a...n
• ( décrémenter n
• ? : tourner à droite si positif, aller tout droit si zéro
• Si c'est le cas,:: /suéchange le haut de la pile et continue la boucle
• si zéro, se /reflète vers le bas et le code évalué est Iru@; @termine le programme.

Fusain , 10 octets

…⁺×ζＩθ×εＮＮ

Essayez-le en ligne! Le lien est vers la version détaillée du code et inclut le quatrième exemple. (Malheureusement, le deverbosifer ne supprimera pas le séparateur si j'en ajoute un avant le dernier InputNumber().)

Mathematica, 61 octets

T=Table;StringTake[""<>Flatten@T[{#3~T~#,#4~T~#},⌈#2/#⌉],#2]&

contribution

[2,10, "A", "B"]

Mathematica, 44 octets

StringPadRight[x={##3}~Table~#<>"",#2,x]&

Explication

est le caractère à usage privé de trois octets U+F3C7, représentant l' \[Transpose]opérateur postfix dans Mathematica. Aucun lien TIO car Mathics ne prend pas en charge , \[Transpose]a la mauvaise priorité d'opérateur, le deuxième argument de Tabledoit être une liste et, surtout, StringPadRightn'est pas implémenté.

                                         & (* Function *)
                 {##3}                     (* which takes the third and fourth arguments *)
                      ~Table~#             (* repeats them a number of times equal to the first argument *)
                                          (* takes the tranpose *)
                               <>""        (* then joins the strings with the empty string *)
               x=                          (* sets x equal to that string *)
StringPadRight[                            (* then pads x *)
                                   ,#2     (* to a length equal to the second argument *)
                                      ,x]  (* with x. *)

APL (Dyalog) , 5 octets

⎕⍴⎕/⎕

Essayez-le en ligne!

Prend les deux caractères dans une chaîne comme première entrée, suivi mpuisn .

Explication

Laissez l'entrée par exemple être 'ab', 2, 10.

⎕/⎕                 Replicate the two-char string `m` times
                    2/'ab' => 'aabb'
⎕⍴                  Shape it so that its length is `n`
                    10⍴'aabb' => 'aabbaabbaa'

Pyth , 13 octets

KE<*+*EQ*EQKK

Essayez-le en ligne!

Explication

                 # Implicitly store m to Q
KE               # Store n to K
     *EQ         # Perform a * m
        *EQ      # Perform b * m
    +            # Concatenate the two strings
   *       K     # Multiply by n
  <         K    # Take the first n characters of the string

k, 10 octets

{y#,/x#'z}

Essayez-le en ligne!

Puce , 588 octets

*Z~vZ.*ZZZs  z. z. z. z. z. z. z. z.
  ,'|`-. ZZ--#<,#<,#<,#<,#<,#<,#<,#<
a/mAM/a| `~S `x'`x'`x'`x'`x'`x'`x'`x.
b/mBM/b|  *.)/')/')/')/')/')/')/')/'|
c/mCM/cZv--x^x-^x-^x-^x-^x-^x-^x-^x-'
d/mDM/d||A~#M',-',-',-',-',-',-',-'
e/mEM/e||B~#M-',-',-',-',-',-',-'
f/mFM/f||C~#M--',-',-',-',-',-'
g/mGM/g||D~#M---',-',-',-',-'
h/mHM/h||E~#M----',-',-',-'
 `v~v' ||F~#M-----',-',-'
* `mz  ||G~#M------',-'
Z  `---x'H~#M-------'
Z,--z--^----'
Z|z. z. z. z. z. z. z. z.
Zx#<,#<,#<,#<,#<,#<,#<,#<
 |`x'`x'`x'`x'`x'`x'`x'`xT
 |A| B| C| D| E| F| G| H|
 )\')\')\')\')\')\')\')\'
 `--^--^--^--^--^--^--'

Essayez-le en ligne!

Prend l'entrée comme une chaîne de 4 caractères. Les deux premiers sont les caractères a et b , suivis de la valeur d'octet m , puis de la valeur d'octet n . Par exemple, le TIO comprend une entrée ab<tab>2, cela correspond à «a», «b», 9, 50 (puisque les codes pour <tab>et 2sont 9 et 50.

Comment?

Cette réponse est un peu géante, mais voici les points saillants:

Le bloc supérieur gauche, avec les minuscules a- h, est le mécanisme de stockage des caractères a et b , une ligne par bit. Au fond, avec le v~vet mzest le mécanisme de commutation, pour permuter entre les deux.

Au milieu se trouve une colonne avec un tas de ~#M. Cela se lit en m et stocke son négatif. Le grand triangle à droite n'est que des fils pour amener cette valeur dans l'accumulateur supérieur.

Le bloc supérieur droit est l'accumulateur pour m . Il incrémente chaque cycle (à partir de -m ) jusqu'à ce qu'il atteigne zéro. Lorsque cela se produit, le caractère de sortie est échangé et le comptage redémarre à partir de -m .

Pendant ce temps, il y a le bloc inférieur, qui est l' accumulateur n . Puisque n n'est lu qu'une seule fois, nous n'avons pas besoin d'une banque de mémoire ( Met m) pour stocker cette valeur. Nous le nions simplement et commençons à compter. Lorsque cette valeur atteint zéro, tout le shebang est simplement terminé.

Tous les autres Guff est des retards ( Zet z), le câblage ( -, |, ...), et d' autres miscellany.