ingressi:

Due cifre singole (chiamiamole me n) e due caratteri (chiamiamole ae b) nel formato di input desiderato.

Produzione:

Per la procedura dettagliata, fingere m=2, n=5, a='a', b='b'.

Il tuo output sarà una stringa creata dai tuoi quattro input. Chiamiamo la stringa result, con valore "". In primo luogo, concatenate asu result morari, in modo da concatenare asulle result 2volte. resultora è uguale aa. In secondo luogo, concatenate bsu result morari, in modo da concatenare bsulle result 2volte. resultora è uguale aabb. Infine, se il risultato è già più lungo di n, troncalo in resultmodo che abbia lunghezza n. Altrimenti, continua ad alternare con mcorse di lunghezza di ae bfino a quando non resultha lunghezza n. Il finale resultè aabba, che ha lunghezza 5.

Casi 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 

Come tutti sanno, uno minore governerà il mondo, quindi i programmi più piccoli, in byte, vincono! :)

Python , 32 byte

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

Provalo online!

MATL , 5 byte

Y"i:)

Gli input sono una stringa con i due caratteri, quindi m, quindi n.

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Rubino, 29 caratteri

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

Esecuzione di esempio:

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

Provalo online!

Japt , 10 byte

VîUçW +UçX

Prima prova a usare un linguaggio da golf. Provalo online!

Spiegazione

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 byte

×J×I£

Provalo online!

Spiegazione

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

Gelatina , 6 4 byte

xFṁ⁵

Provalo online!

Grazie a Jonathan Allan per il miglior formato di input (-2).

V , 13 byte

ÀäjÀäêÍî
À|lD

Provalo online!

ae bsono presi su righe separate nell'input me nsono presi come argomento, invertiti (così nè il primo argomento ed mè il secondo)

Spiegazione

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

Ancora un'altra soluzione di Haskell (si aspetta che i personaggi siano elencati come un elenco):

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

Provalo online!

Grazie @Laikoni per -1 byte.

R , 41 39 byte

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

Una funzione anonima; stampa il risultato su stdout. Prende i personaggi come un vettore d=c(a,b). glgenera fattori (numeri interi) di (in questo caso) 2livelli di lunghezza della corsa mcon lunghezza totale n! catli concatena e li stampa come una stringa.

Provalo online!

Javascript, 55 byte

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

Esempio di frammento di codice:

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 byte

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

Buccia , 3 byte

Porta diretta della mia risposta Haskell, tranne per il fatto che l'ordine degli argomenti è diverso:

↑¢Ṙ

Provalo online!

Haskell , 48 43 byte

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

Provalo online!

QBIC , 37 27 byte

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

Spiegazione

          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

Tentativo precedente:

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

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 byte

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

Provalo online!

Cubix , 63 58 byte

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

Provalo online!

guarda l'interprete

Accetta input come ab*m*ndove* può essere qualsiasi carattere non numerico.

Versione 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: leggi i caratteri e scambiali (così aè in cima)
• I:q: leggi m, duplica e spingi verso il basso (lo stack è ora m,b,a,m)
• ) : decremento
• ? : gira a destra se positivo, vai dritto se zero (duplicati a )
• ramo positivo (loop)
  • s:rur(/w: scambia, duplica, sposta m-iin cima alla pila, diminuiscem-i
• ramo zero
  • B: Stack di inversione (che ora ha mle copie di a: a... b m)
  • n: negate m(quindi possiamo usare ?per girare a sinistra)
  • ) : incremento
  • ? : vai dritto se zero, gira a sinistra se negativo
• ramo negativo (duplicati b)
  • s:r\/rw)\ sostanzialmente uguale al ramo positivo ma con incrementi e virate a sinistra.
• ramo zero (stampa l'output)
  • >v;: espelle dallo 0stack (sembra a...b...)
  • /B : inverti la pila
  • I : leggere n
  • s : swap loop di stampa:
• oq : stampa e spingi in fondo alla pila ora appare come: ab...a...n
• ( diminuzione n
• ? : girare a destra se positivo, andare dritto se zero
• Se giusto,: /su scambia la parte superiore dello stack e continua il ciclo
• se zero, /riflette verso il basso e il codice valutato è Iru@; @termina il programma.

Carbone , 10 byte

…⁺×ζＩθ×εＮＮ

Provalo online! Il collegamento è alla versione dettagliata del codice e include il quarto esempio. (Stranamente il deverbosifer non rimuoverà il separatore se ne aggiungo uno prima dell'ultimo InputNumber().)

Mathematica, 61 byte

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

ingresso

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

Mathematica, 44 byte

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

Spiegazione

è il carattere di uso privato a tre byte U+F3C7, che rappresenta l' \[Transpose]operatore postfix in Mathematica. Nessun collegamento TIO perché Mathics non supporta , \[Transpose]ha la precedenza dell'operatore errata, Tableè necessario che il secondo argomento sia un elenco e, soprattutto, StringPadRightnon sia implementato.

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

⎕⍴⎕/⎕

Provalo online!

Accetta i due caratteri in una stringa come primo input, seguito da me quindi n.

Spiegazione

Sia trattato all'ingresso esempio '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 byte

KE<*+*EQ*EQKK

Provalo online!

Spiegazione

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

{y#,/x#'z}

Provalo online!

Chip , 588 byte

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

Provalo online!

Accetta l'input come una stringa di 4 caratteri. I primi due sono i personaggi a e b , seguiti dal valore di byte m , e quindi il valore di byte n . Ad esempio, il TIO include input ab<tab>2, questo corrisponde a 'a', 'b', 9, 50. (Poiché i codici per <tab>e2 sono 9 e 50.

Come?

Questa risposta è un po 'un colosso, ma ecco i punti salienti:

Il blocco superiore sinistro, con il minuscolo a- h, è il meccanismo di memorizzazione per i caratteri a e b , una linea per bit. In fondo, con v~ve mzè il meccanismo di commutazione, per scambiare tra i due.

Nel mezzo è una colonna con un gruppo di ~#M's. Questo recita in m e memorizza il suo negativo. Il grande triangolo a destra è solo fili per portare questo valore nell'accumulatore superiore.

Il blocco in alto a destra è l'accumulatore per m . Incrementa ogni ciclo (a partire da -m ) fino a raggiungere lo zero. In questo caso, il carattere di output viene scambiato e il conteggio riparte da -m .

Nel frattempo, c'è il blocco inferiore, che è l' accumulatore n . Poiché n viene letto solo una volta, non è necessario un banco di memoria ( Mem ) per memorizzare questo valore. Semplicemente lo neghiamo e iniziamo a contare. Quando questo valore raggiunge lo zero, l'intero shebang viene semplicemente terminato.

Tutti gli altri guff è ritardi ( Ze z), il cablaggio ( -, |, ...), e di altri miscellanea.