Wejścia:

Dwie pojedyncze cyfry (nazwijmy je mi n) i dwa znaki (nazwijmy je ai b) w wybranym przez ciebie formacie wejściowym.

Wynik:

Aby uzyskać przewodnik, udawaj m=2, n=5, a='a', b='b'.

Twój wynik będzie ciągiem zbudowanym z czterech wejść. Nazwijmy ciąg resultz wartością "". Po pierwsze, concatenate ana result mczasie, więc Złącz ana result 2czas. resultteraz jest równy aa. Po drugie, konkatenuj bdo result mczasów, więc konkatenuj bdo result 2czasów. resultteraz jest równy aabb. Na koniec, jeśli wynik jest już dłuższy niż n, obetnij resultgo, aby miał długość n. W przeciwnym razie kontynuuj naprzemiennie z mseriami długości do ai baż resultma długość n. Ostatnim resultjest aabba, który ma długość 5.

Przypadki testowe:

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 

Jak wszyscy wiedzą, mniejszy będzie rządził światem, więc wygrywają najmniejsze programy w bajtach! :)

Python , 32 bajty

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

Wypróbuj online!

MATL , 5 bajtów

Y"i:)

Wejścia są ciągiem z dwóch znaków, a następnie m, po czym n.

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

Ruby, 29 znaków

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

Przykładowy przebieg:

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

Wypróbuj online!

Japt , 10 bajtów

VîUçW +UçX

Najpierw spróbuj użyć języka golfowego. Wypróbuj online!

Wyjaśnienie

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 bajtów

×J×I£

Wypróbuj online!

Wyjaśnienie

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

Galaretka , 6 4 bajtów

xFṁ⁵

Wypróbuj online!

Podziękowania dla Jonathana Allana za lepszy format wejściowy (-2).

V , 13 bajtów

ÀäjÀäêÍî
À|lD

Wypróbuj online!

ai bsą pobierane w osobnych wierszach na wejściu mi nsą traktowane jako argument, odwrócone (podobnie njak pierwszy argument i mdrugi)

Wyjaśnienie

Àä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 bajtów

Jeszcze inne rozwiązanie Haskell (oczekuje znaków podanych jako lista):

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

Wypróbuj online!

Dzięki @Laikoni za -1 bajtów.

R , 41 39 bajtów

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

Anonimowa funkcja; wypisuje wynik na standardowe wyjście. Bierze postacie jako wektor d=c(a,b). glgeneruje współczynniki (liczby całkowite) (w tym przypadku) 2poziomów długości przebiegu mz długością całkowitą n! catkonkatenuje i drukuje je jako ciąg.

Wypróbuj online!

JavaScript, 55 bajtów

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

Przykładowy fragment kodu:

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 bajty

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

Łuska , 3 bajty

Bezpośredni port mojej odpowiedzi Haskell, z tym wyjątkiem, że kolejność argumentów jest inna:

↑¢Ṙ

Wypróbuj online!

Haskell , 48 43 bajtów

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

Wypróbuj online!

QBIC , 37 27 bajtów

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

Wyjaśnienie

          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

Poprzednia próba:

(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 bajtów

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 bajtów

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

Wypróbuj online!

Cubix , 63 58 bajtów

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

Wypróbuj online!

obserwuj tłumacza

Pobiera dane wejściowe, jak ab*m*ngdzie* może być dowolny znak inny niż cyfra.

Wersja kostki:

        . 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 : czytaj znaki i zamieniaj je (tak a jest na górze)
• I:q: czytaj m, dup i wypychaj na dół (stos jest terazm,b,a,m )
• ) : zmniejszenie
• ? : skręć w prawo, jeśli ma wartość dodatnią, idź prosto, jeśli zero (duplikat a )
• gałąź dodatnia (pętla)
  • s:rur(/w: zamień, duplikuj, przejdź m-ina górę stosu, zmniejszajm-i
• gałąź zerowa
  • B: reverse stack (który ma teraz mkopie a:a... b m )
  • n: negate m(abyśmy mogli ?skręcić w lewo)
  • ) : przyrost
  • ? : idź prosto, jeśli zero, skręć w lewo, jeśli jest ujemny
• gałąź ujemna (duplikaty b)
  • s:r\/rw)\ w zasadzie taki sam jak gałąź dodatnia, ale z przyrostem i zwrotami w lewo.
• gałąź zerowa (drukuje dane wyjściowe)
  • >v;: 0zdejmij stos (wygląda jak a...b...)
  • /B : odwróć stos
  • I : przeczytaj n
  • s : zamień drukowaną pętlę:
• oq : print i push na dół stosu wygląda teraz tak: ab...a...n
• ( ubytek n
• ? : skręć w prawo, jeśli ma wartość dodatnią, idź prosto, jeśli zero
• Jeśli dobrze /su:: zamień górę stosu i kontynuuj pętlę
• jeśli zero, /odbija się w dół, a oceniany kod to Iru@; @kończy program.

Węgiel drzewny , 10 bajtów

…⁺×ζＩθ×εＮＮ

Wypróbuj online! Link jest do pełnej wersji kodu i zawiera czwarty przykład. (Irytujące deverbosifer nie usunie separatora, jeśli dodam go przed ostatnim InputNumber().)

Mathematica, 61 bajtów

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

Wejście

[2,10, „A”, „B”]

Mathematica, 44 bajty

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

Wyjaśnienie

to trzy bajtowy prywatny znak U+F3C7reprezentujący \[Transpose]operator Postfiksa w Mathematica. Brak linku TIO, ponieważ Mathics nie obsługuje , \[Transpose]ma niepoprawny priorytet operatora, drugi argument Tablemusi być listą, a co najważniejsze, StringPadRightnie jest zaimplementowany.

                                         & (* 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 bajtów

⎕⍴⎕/⎕

Wypróbuj online!

Pobiera dwa znaki w ciągu jako pierwsze wejście, a mnastępnie i potem n.

Wyjaśnienie

Niech przykładem będzie wejście '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 bajtów

KE<*+*EQ*EQKK

Wypróbuj online!

Wyjaśnienie

                 # 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 bajtów

{y#,/x#'z}

Wypróbuj online!

Chip , 588 bajtów

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

Wypróbuj online!

Pobiera dane wejściowe jako ciąg 4 znaków. Pierwsze dwa to znaki a i b , po których następuje wartość bajtu m , a następnie wartość bajtu n . Na przykład TIO zawiera dane wejściowe ab<tab>2, co odpowiada „a”, „b”, 9, 50. (Ponieważ kody dla <tab>i 2to 9 i 50.

W jaki sposób?

Ta odpowiedź jest trochę gigantyczna, ale oto najważniejsze informacje:

W lewym górnym rogu bloku, z małymi literami a- hjest mechanizm przechowywania postaci a i b , jedna na bit. Na dole, z v~vimz jest mechanizm przełączający, aby przełączać się między nimi.

Pośrodku jest kolumna z pęczkiem ~#M. To brzmi wm przechowuje wartość ujemną. Duży trójkąt po prawej to tylko druty, aby wprowadzić tę wartość do górnego akumulatora.

Górny prawy blok jest akumulatorem dla m . Przyrost zwiększa każdy cykl (od -m ), aż osiągnie zero. Kiedy tak się dzieje, znak wyjściowy jest zamieniany, a liczenie rozpoczyna się od -m .

Tymczasem jest dolny blok, którym jest akumulator n . Ponieważ n jest odczytywany tylko raz, nie potrzebujemy banku pamięci ( Mim ) do przechowywania tej wartości. Po prostu to negujemy i zaczynamy liczyć. Kiedy ta wartość osiągnie zero, cały shebang zostaje po prostu zakończony.

Wszystkie inne guff ma opóźnienia ( Zi z), okablowanie ( -, |...) i innych miscellany.