Đầu vào:

Hai chữ số đơn (hãy gọi chúng mvà n) và hai ký tự (hãy gọi chúng avà b) theo định dạng đầu vào mà bạn chọn.

Đầu ra:

Đối với các hướng dẫn, giả vờ m=2, n=5, a='a', b='b'.

Đầu ra của bạn sẽ là một chuỗi được xây dựng từ bốn đầu vào của bạn. Hãy gọi chuỗi result, với giá trị "". Đầu tiên, nối avào result mthời gian, vì vậy nối avào result 2thời gian. resulthiện nay tương đương aa. Thứ hai, nối bvào result mthời gian, vì vậy nối bvào result 2thời gian. resulthiện nay tương đương aabb. Cuối cùng, nếu kết quả đã dài hơn n, cắt ngắn resultđể nó có độ dài n. Mặt khác, tiếp tục xen kẽ với các bước mchạy dài avà bcho đến khi resultcó độ dài n. Cuối cùng resultlà aabba, có chiều dài 5.

Các trường hợp thử nghiệm:

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 

Như tất cả đều biết, một người ít hơn sẽ thống trị thế giới, vì vậy các chương trình nhỏ nhất, tính bằng byte, sẽ giành chiến thắng! :)

Python , 32 byte

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

Hãy thử trực tuyến!

MATL , 5 byte

Y"i:)

Đầu vào là một chuỗi có hai ký tự, sau đó m, sau đón .

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

Ruby, 29 ký tự

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

Chạy mẫu:

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

Hãy thử trực tuyến!

Japt , 10 byte

VîUçW +UçX

Trước tiên hãy thử sử dụng một ngôn ngữ chơi golf. Hãy thử trực tuyến!

Giải trình

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£

Hãy thử trực tuyến!

Giải trình

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

Thạch , 6 4 byte

xFṁ⁵

Hãy thử trực tuyến!

Cảm ơn Jonathan Allan cho định dạng đầu vào tốt hơn (-2).

V , 13 byte

ÀäjÀäêÍî
À|lD

Hãy thử trực tuyến!

avà bđược lấy trên các dòng riêng biệt trong đầu vào mvà nđược lấy làm đối số, đảo ngược (vì vậy nlà đối số đầu tiên vàm là thứ hai)

Giải trình

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

Một giải pháp Haskell khác (dự kiến ​​các ký tự được đưa ra dưới dạng danh sách):

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

Hãy thử trực tuyến!

Cảm ơn @Laikoni cho -1 byte.

R , 41 39 byte

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

Một chức năng ẩn danh; in kết quả ra thiết bị xuất chuẩn. Đưa các nhân vật như một vector d=c(a,b). gltạo ra các yếu tố (số nguyên) của (trong trường hợp này) 2mức độ dài chạy mvới tổng chiều dài n! catnối và in chúng dưới dạng một chuỗi.

Hãy thử trực tuyến!

Javascript, 55 byte

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

Đoạn mã ví dụ:

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)

Husk , 3 byte

Cổng trực tiếp của câu trả lời Haskell của tôi, ngoại trừ thứ tự đối số là khác nhau:

↑¢Ṙ

Hãy thử trực tuyến!

Haskell , 48 43 byte

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

Hãy thử trực tuyến!

QBIC , 37 27 byte

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

Giải trình

          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

Lần thử trước:

(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 trực tuyến

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

Hãy thử trực tuyến!

Khối , 63 58 byte

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

Hãy thử trực tuyến!

xem phiên dịch

Đưa đầu vào như ab*m*nnơi* có thể là bất kỳ ký tự không có chữ số nào.

Phiên bản khối:

        . 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: đọc trong ký tự và trao đổi chúng (vì vậy alà trên cùng)
• I:q: đọc trong m, dup và đẩy xuống dưới (stack bây giờ m,b,a,m)
• ) : giảm
• ? : rẽ phải nếu dương, đi thẳng nếu không (trùng lặp a )
• nhánh tích cực (vòng lặp)
  • s:rur(/w: hoán đổi, nhân đôi, di chuyển m-ilên đỉnh ngăn xếp, giảm dầnm-i
• không chi nhánh
  • B: ngăn xếp ngược (hiện có mbản sao của a:a... b m )
  • n: phủ định m(vì vậy chúng ta có thể sử dụng ?để rẽ trái)
  • ) : tăng
  • ? : đi thẳng nếu không, rẽ trái nếu âm
• nhánh âm (trùng lặp b)
  • s:r\/rw)\ về cơ bản giống như nhánh dương nhưng với gia số và rẽ trái.
• nhánh không (in đầu ra)
  • >v;: bật 0ngăn xếp ra (hình như a...b...)
  • /B : đảo ngược ngăn xếp
  • I : đọc n
  • s : vòng lặp trao đổi in:
• oq : in và đẩy xuống dưới cùng của ngăn xếp bây giờ trông như: ab...a...n
• ( giảm n
• ? : rẽ phải nếu dương, đi thẳng nếu không
• Nếu đúng ,: /su hoán đổi đỉnh ngăn xếp và tiếp tục vòng lặp
• nếu không, /phản ánh xuống và mã được đánh giá là Iru@; @chấm dứt chương trình.

Than , 10 byte

…⁺×ζＩθ×εＮＮ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã và bao gồm ví dụ thứ tư. (Khó chịu là deverbosifer sẽ không xóa dải phân cách nếu tôi thêm cái trước cái cuối cùng InputNumber().)

Toán học, 61 byte

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

đầu vào

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

Toán học, 44 byte

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

Giải trình

là ký tự sử dụng riêng ba byte U+F3C7, đại diện cho \[Transpose]toán tử postfix trong Mathicala. Không có liên kết TIO vì Mathics không hỗ trợ , \[Transpose]có quyền ưu tiên toán tử sai, đối số thứ hai Tableđược yêu cầu là một danh sách và quan trọng nhất StringPadRightlà không được triển khai.

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

⎕⍴⎕/⎕

Hãy thử trực tuyến!

Lấy hai ký tự trong một chuỗi làm đầu vào đầu tiên, theo sau mvà sau đón .

Giải trình

Hãy ví dụ đầu vào được 'ab', 2, 10.

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

Bình thường , 13 byte

KE<*+*EQ*EQKK

Hãy thử trực tuyến!

Giải trình

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng chuỗi 4 ký tự. Hai đầu tiên là các ký tự a và b , tiếp theo là giá trị byte m và sau đó là giá trị byte n . Ví dụ: TIO bao gồm đầu vào ab<tab>2, điều này tương ứng với 'a', 'b', 9, 50. (Vì các mã cho <tab>và2 là 9 và 50.

Làm sao?

Câu trả lời này là một chút của một người khổng lồ, nhưng đây là những điểm nổi bật:

Khối trên bên trái, với chữ thường a- h, là cơ chế lưu trữ cho các ký tự a và b , mỗi dòng một bit. Ở dưới cùng của nó, với v~vvàmz là cơ chế chuyển đổi, để trao đổi giữa hai.

Ở giữa là một cột với một loạt các ~#M. Cái này đọc bằng m và lưu trữ tiêu cực của nó. Hình tam giác lớn ở bên phải chỉ là dây để đưa giá trị này vào bộ tích lũy phía trên.

Khối trên bên phải là bộ tích lũy cho m . Nó tăng mỗi chu kỳ (bắt đầu từ -m ) cho đến khi nó về không. Khi điều này xảy ra, ký tự đầu ra được hoán đổi và đếm khởi động lại từ -m .

Trong khi đó, có khối thấp hơn, đó là bộ tích lũy n . Vì n chỉ được đọc một lần, chúng tôi không cần ngân hàng bộ nhớ ( Mvà m) để lưu trữ giá trị này. Chúng tôi chỉ đơn giản là phủ nhận nó và bắt đầu đếm. Khi giá trị này bằng 0, toàn bộ shebang chỉ đơn giản là chấm dứt.

Tất cả các câu nói đùa khác là sự chậm trễ ( Zvà z), hệ thống dây điện ( -, |, ...), và sưu tập khác.