Eingänge:

Zwei einzelne Ziffern (nennen wir sie mund n) und zwei Zeichen (nennen wir sie aund b) in einem Eingabeformat Ihrer Wahl.

Ausgabe:

Stellen Sie sich für die Komplettlösung vor m=2, n=5, a='a', b='b'.

Ihre Ausgabe ist eine Zeichenfolge, die aus Ihren vier Eingaben erstellt wird. Nennen wir den String resultmit Wert "". Erstens, verketten Sie aauf result mZeiten, also verketten Sie aauf result 2Zeiten. resultjetzt gleich aa. Zweitens, verketten Sie bauf result mZeiten, also verketten Sie bauf result 2Zeiten. resultjetzt gleich aabb. Wenn das Ergebnis bereits länger als ist n, schneiden Sie resultes ab, damit es die Länge hat n. Ansonsten abwechselnd mit mLängenläufen von aund bbis resultLänge fortsetzen n. Das Finale resultist aabba, was Länge hat 5.

Testfälle:

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 

Wie alle wissen, wird weniger die Welt regieren, also gewinnen die kleinsten Programme in Bytes! :)

Python , 32 Bytes

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

Probieren Sie es online!

MATL , 5 Bytes

Y"i:)

Eingaben sind eine Zeichenfolge mit den beiden Zeichen then m, then n.

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

Ruby, 29 Zeichen

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

Probelauf:

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

Probieren Sie es online!

Japt , 10 Bytes

VîUçW +UçX

Versuchen Sie zunächst, eine Golfsprache zu verwenden. Probieren Sie es online!

Erläuterung

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£

Probieren Sie es online!

Erläuterung

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

Gelee , 6 4 Bytes

xFṁ⁵

Probieren Sie es online!

Vielen Dank an Jonathan Allan für das bessere Eingabeformat (-2).

V , 13 Bytes

ÀäjÀäêÍî
À|lD

Probieren Sie es online!

aund bwerden in der Eingabe in getrennten Zeilen verwendet mund nals Argument verwendet, umgekehrt (also ndas erste und mdas zweite Argument ).

Erläuterung

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

Noch eine andere Haskell-Lösung (erwartet die angegebenen Zeichen als Liste):

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

Probieren Sie es online!

Danke @Laikoni für -1 Byte.

R , 41 39 Bytes

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

Eine anonyme Funktion; druckt das Ergebnis auf stdout. Nimmt die Zeichen als Vektor d=c(a,b). glErzeugt Faktoren (ganze Zahlen) von (in diesem Fall) 2Lauflängenstufen mmit Gesamtlänge n! catverkettet und druckt sie als Zeichenfolge.

Probieren Sie es online!

Javascript, 55 Bytes

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

Beispielcode-Snippet:

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)

Schale , 3 Bytes

Direkte Portierung meiner Haskell-Antwort, außer dass die Reihenfolge der Argumente unterschiedlich ist:

↑¢Ṙ

Probieren Sie es online!

Haskell , 48 43 Bytes

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

Probieren Sie es online!

QBIC , 37 27 Bytes

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

Erläuterung

          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

Vorheriger Versuch:

(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 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]);}

Probieren Sie es online!

Cubix , 63 58 Bytes

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

Probieren Sie es online!

Beobachten Sie den Dolmetscher

Nimmt Eingaben vor, bei ab*m*ndenen es *sich um beliebige nichtstellige Zeichen handeln kann.

Cube-Version:

        . 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: lese die Zeichen ein und tausche sie aus (so asteht es oben)
• I:q: einlesen m, verdoppeln und nach unten drücken (Stack ist jetzt m,b,a,m)
• ) : Dekrement
• ?: Biegen Sie rechts ab, wenn positiv, fahren Sie geradeaus, wenn Null (Duplikate a)
• positiver Zweig (Schleife)
  • s:rur(/w: tauschen, dupen, m-ian die Spitze des Stapels gehen, dekrementierenm-i
• Null-Zweig
  • B: Reverse Stack (der jetzt mKopien von a: enthält a... b m)
  • n: negieren m(damit wir ?nach links abbiegen können)
  • ) : Zuwachs
  • ? : bei Null geradeaus, bei negativ links abbiegen
• negativer Zweig (Duplikate b)
  • s:r\/rw)\ Im Grunde das gleiche wie der positive Zweig, aber mit Inkrement und Linkskurven.
• Null-Zweig (druckt die Ausgabe)
  • >v;: Pop die 0vom Stapel (sieht aus wie a...b...)
  • /B : kehre den Stapel um
  • I : lesen n
  • s : Druckschleife tauschen:
• oq : print und push to bottom of stack sieht jetzt so aus: ab...a...n
• ( dekrementieren n
• ? : Biegen Sie rechts ab, wenn positiv, fahren Sie geradeaus, wenn Null
• Wenn richtig /su:: Stapeloberteil tauschen und Schleife fortsetzen
• Wenn Null, wird nach /unten reflektiert und der Code wird ausgewertet Iru@. @Beendet das Programm.

Kohle , 10 Bytes

…⁺×ζＩθ×εＮＮ

Probieren Sie es online! Der Link ist eine ausführliche Version des Codes und enthält das vierte Beispiel. (Ärgerlicherweise entfernt der Deverbosifer den Separator nicht, wenn ich vor dem letzten einen hinzufüge InputNumber().)

Mathematica, 61 Bytes

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

Eingang

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

Mathematica, 44 Bytes

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

Erläuterung

ist das Drei-Byte-Zeichen U+F3C7für den privaten Gebrauch , das den Postfix- \[Transpose]Operator in Mathematica darstellt. Keine TIO-Verknüpfung, da Mathics nicht unterstützt , \[Transpose]die falsche Operatorrangfolge hat, das zweite Argument Tableeine Liste sein muss und vor allem StringPadRightnicht implementiert ist.

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

⎕⍴⎕/⎕

Probieren Sie es online!

Nimmt die beiden Zeichen in einer Zeichenfolge als erste Eingabe, gefolgt von mund dann n.

Erläuterung

Lassen Sie das Beispiel eingegeben werden '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

Probieren Sie es online!

Erläuterung

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

Probieren Sie es online!

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

Probieren Sie es online!

Übernimmt die Eingabe als 4-stellige Zeichenfolge. Die ersten beiden sind die Zeichen a und b , gefolgt vom Bytewert m und dem Bytewert n . Zum Beispiel enthält der TIO einen Eingang ab<tab>2, dies entspricht 'a', 'b', 9, 50. (Da die Codes für<tab> und2 9 und 50 sind.

Wie?

Diese Antwort ist ein bisschen wie ein Gigant, aber hier sind die Highlights:

Der obere linke Block mit dem Kleinbuchstaben a- hist der Speichermechanismus für die Zeichen a und b , eine Zeile pro Bit. An der Unterseite mit dem v~vundmz der Schaltmechanismus, um zwischen den beiden zu wechseln.

In der Mitte steht eine Kolumne mit ein paar ~#M. Dies liest in m und speichert sein Negativ. Das große Dreieck rechts besteht nur aus Drähten, um diesen Wert in den oberen Akkumulator zu bringen.

Der obere rechte Block ist der Akkumulator für m . Es erhöht jeden Zyklus (beginnend mit -m ), bis es Null erreicht. In diesem Fall wird das Ausgabezeichen ausgetauscht und die Zählung von -m aus fortgesetzt .

Inzwischen gibt es den unteren Block, der den n- Akkumulator darstellt. Da n nur einmal gelesen wird, benötigen wir keine Speicherbank ( Mund m), um diesen Wert zu speichern. Wir negieren es einfach und fangen an zu zählen. Wenn dieser Wert Null erreicht, wird der gesamte Shebang einfach beendet.

Alle anderen guff ist Verzögerungen ( Zund z), Verdrahtung ( -, |, ...) und andere miscellany.