Entradas:

Dos dígitos individuales (llamémoslos my n) y dos caracteres (llamémoslos ay b) en el formato de entrada de su elección.

Salida:

Para el tutorial, finja m=2, n=5, a='a', b='b'.

Su salida será una cadena construida a partir de sus cuatro entradas. Llamemos a la cadena result, con valor "". Primero, concatene aen result mtiempos, así que concatene aen result 2tiempos. resultAhora es igual aa. En segundo lugar, concatene ben result mtiempos, así que concatene ben result 2tiempos. resultAhora es igual aabb. Por último, si el resultado ya es más largo que n, truncar resultpara que tenga longitud n. De lo contrario, continúe alternando con mcarreras de longitud de ay bhasta que resulttenga longitud n. El final resultes aabba, que tiene longitud 5.

Casos de prueba:

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 

Como todos saben, uno menor gobernará el mundo, por lo que los programas más pequeños, en bytes, ¡ganan! :)

Python , 32 bytes

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

Pruébalo en línea!

MATL , 5 bytes

Y"i:)

Las entradas son una cadena con los dos caracteres, luego m, luego n.

Pruébalo en línea!

Explicación

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 bytes

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

Pruébalo en línea!

Ruby, 29 caracteres

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

Ejecución de muestra:

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

Pruébalo en línea!

Japt , 10 bytes

VîUçW +UçX

Primero intente usar un lenguaje de golf. Pruébalo en línea!

Explicación

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 bytes

×J×I£

Pruébalo en línea!

Explicación

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

Jalea , 6 4 bytes

xFṁ⁵

Pruébalo en línea!

Gracias a Jonathan Allan por un mejor formato de entrada (-2).

V , 13 bytes

ÀäjÀäêÍî
À|lD

Pruébalo en línea!

ay bse toman en líneas separadas en la entrada, my nse toman como argumento, invertidos (así nes el primer argumento y mes el segundo)

Explicación

Àä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 bytes

Otra solución más de Haskell (espera los caracteres dados como una lista):

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

Pruébalo en línea!

Gracias @Laikoni por -1 byte.

R , 41 39 bytes

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

Una función anónima; imprime el resultado en stdout. Toma los personajes como un vector d=c(a,b). gl¡genera factores (enteros) de (en este caso) 2niveles de longitud de ejecución mcon longitud total n! catlos concatena y los imprime como una cadena.

Pruébalo en línea!

Javascript, 55 bytes

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

Fragmento de código de ejemplo:

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 bytes

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

Casco , 3 bytes

Puerto directo de mi respuesta de Haskell, excepto que el orden de los argumentos es diferente:

↑¢Ṙ

Pruébalo en línea!

Haskell , 48 43 bytes

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

Pruébalo en línea!

QBIC , 37 27 bytes

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

Explicación

          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

Intento previo:

(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 bytes

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

PHP Sandbox en línea

Java (OpenJDK 8) , 75 bytes

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

Pruébalo en línea!

Cubix , 63 58 bytes

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

Pruébalo en línea!

mira al intérprete

Toma datos como ab*m*ndonde el* puede haber cualquier carácter sin dígitos.

Versión de cubo:

        . 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: lea los caracteres y cámbielos (también aestá en la parte superior)
• I:q: leer m, duplicar y presionar hacia abajo (la pila está ahora m,b,a,m)
• ) : decremento
• ?: gire a la derecha si es positivo, vaya derecho si es cero (duplicados a)
• rama positiva (bucle)
  • s:rur(/w: intercambiar, dup, mover m-ia la parte superior de la pila, disminuirm-i
• rama cero
  • B: pila inversa (que ahora tiene mcopias de a:a... b m )
  • n: negar m(para que podamos usar ?para girar a la izquierda)
  • ) : incremento
  • ? : siga recto si es cero, gire a la izquierda si es negativo
• rama negativa (duplicados b)
  • s:r\/rw)\ básicamente lo mismo que la rama positiva pero con incrementos y giros a la izquierda.
• rama cero (imprime la salida)
  • >v;: abre la 0pila (parece a...b...)
  • /B : invertir la pila
  • I : leer n
  • s : intercambiar bucle de impresión:
• oq : imprimir y empujar al fondo de la pila ahora se ve así: ab...a...n
• ( decremento n
• ? : gire a la derecha si es positivo, vaya derecho si es cero
• Si es correcto: /su intercambie la parte superior de la pila y continúe el ciclo
• si es cero, se /refleja hacia abajo y el código evaluado es Iru@; @termina el programa

Carbón de leña , 10 bytes

…⁺×ζＩθ×εＮＮ

Pruébalo en línea! El enlace es a una versión detallada del código e incluye el cuarto ejemplo. (Molesto, el deverbosifer no eliminará el separador si agrego uno antes del último InputNumber()).

Mathematica, 61 bytes

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

entrada

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

Mathematica, 44 bytes

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

Explicación

es el carácter de uso privado de tres bytes U+F3C7, que representa el \[Transpose]operador postfix en Mathematica. No hay un enlace TIO porque Mathics no es compatible , \[Transpose]tiene una prioridad de operador incorrecta, el segundo argumento Tabledebe ser una lista y, lo más importante, StringPadRightno está implementado.

                                         & (* 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 bytes

⎕⍴⎕/⎕

Pruébalo en línea!

Toma los dos caracteres en una cadena como la primera entrada, seguido de my luego n.

Explicación

Sea la entrada de ejemplo '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 bytes

KE<*+*EQ*EQKK

Pruébalo en línea!

Explicación

                 # 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 bytes

{y#,/x#'z}

Pruébalo en línea!

Chip , 588 bytes

*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|
 )\')\')\')\')\')\')\')\'
 `--^--^--^--^--^--^--'

Pruébalo en línea!

Toma la entrada como una cadena de 4 caracteres. Los dos primeros son los personajes a y b , seguido por el valor de byte m , y luego el valor de byte n . Por ejemplo, el TIO incluye entrada ab<tab>2, esto corresponde a 'a', 'b', 9, 50. (Dado que los códigos para <tab>y 2son 9 y 50.

¿Cómo?

Esta respuesta es un poco gigantesca, pero aquí están los aspectos más destacados:

El bloque superior izquierda, con la minúscula a- h, es el mecanismo de almacenamiento para los caracteres a y b , una línea por bit. En su parte inferior, con el v~vymz es el mecanismo de conmutación, para intercambiar entre los dos.

En el medio hay una columna con un montón de ~#M's. Esto se lee en m almacena su negativo. El gran triángulo a la derecha es solo cables para llevar este valor al acumulador superior.

El bloque superior derecho es el acumulador para m . Incrementa cada ciclo (comenzando desde -m ) hasta llegar a cero. Cuando esto sucede, el carácter de salida se intercambia y el recuento se reinicia desde -m .

Mientras tanto, está el bloque inferior, que es el n acumulador. Como n solo se lee una vez, no necesitamos un banco de memoria ( My m) para almacenar este valor. Simplemente lo negamos y comenzamos a contar. Cuando este valor llega a cero, todo el shebang simplemente termina.

Todo lo demás es retrasos ( Zy z), cableado (- , |, ...), y otra miscelánea.