Якщо ви берете аркуш паперу з графіком і малюєте похилу лінію, яка йде mодиницями вправо і nодиницями вгору, ви перекреслюєте n-1горизонтальну і m-1вертикальну лінії ліній в певній послідовності. Написати код для виведення цієї послідовності.

Наприклад, m=5і n=3дає:

Можливо, пов'язані: Породження евклідових ритмів , нахили Фібоначчі , FizzBuzz

Введення: два натуральних числа, m,nякі є простими простими

Вихід: Повернення або друк схрещувань у вигляді послідовності двох різних лексем. Наприклад, це може бути рядок Hі V, список Trueта False, або 0's і 1' s, надруковані на окремих рядках. Між маркерами може бути роздільник, якщо він завжди однаковий, а не, скажімо, змінною кількістю пробілів.

Тестові приклади:

Перший тестовий випадок дає порожній вихід або не має виходу.

1 1 
1 2 H
2 1 V
1 3 HH
3 2 VHV
3 5 HVHHVH
5 3 VHVVHV
10 3 VVVHVVVHVVV
4 11 HHVHHHVHHHVHH
19 17 VHVHVHVHVHVHVHVHVVHVHVHVHVHVHVHVHV
39 100 HHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHH

У форматі (m,n,output_as_list_of_0s_and_1s):

(1, 1, [])
(1, 2, [0])
(2, 1, [1])
(1, 3, [0, 0])
(3, 2, [1, 0, 1])
(3, 5, [0, 1, 0, 0, 1, 0])
(5, 3, [1, 0, 1, 1, 0, 1])
(10, 3, [1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1])
(4, 11, [0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0])
(19, 17, [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
(39, 100, [0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0])

Рубі, 92; Страус 0,7,0 , 38

f=->m,n{((1..m-1).map{|x|[x,1]}+(1..n-1).map{|x|[1.0*x*m/n,0]}).sort_by(&:first).map &:last}

:n;:m1-,{)o2W}%n1-,{)m n/*0pW}%+_H$_T%

Вихідні дані для обох використовують 1 та 0 (наприклад 101101).

Ось пояснення страуса:

:n;:m    store n and m as variables, keep m on the stack
1-,      from ex. 5, generate [0 1 2 3]
{...}%   map...
  )        increment, now 5 -> [1 2 3 4]
  o        push 1 (the digit 1 is special-cased as `o')
  2W       wrap the top two stack elements into an array
           we now have [[1 1] [2 1] [3 1] [4 1]]
n1-,     doing the same thing with n
{...}%   map...
  )        increment, now 3 -> [1 2]
  m n/*    multiply by slope to get the x-value for a certain y-value
  0        push 0
  pW       wrap the top two stack elements (2 is special-cased as `p')
+        concatenate the two arrays
_H$      sort-by first element (head)
_T%      map to last element (tail)

І пояснення того, як працює вся справа, використовуючи код Ruby як керівництво:

f = ->m,n {
    # general outline:
    # 1. collect a list of the x-coordinates of all the crossings
    # 2. sort this list by x-coordinate
    # 3. transform each coordinate into a 1 or 0 (V or H)
    # observation: there are (m-1) vertical crossings, and (n-1) horizontal
    #   crossings. the vertical ones lie on integer x-values, and the
    #   horizontal on integer y-values
    # collect array (1)
    (
        # horizontal
        (1..m-1).map{|x| [x, 1] } +
        # vertical
        (1..n-1).map{|x| [1.0 * x * m/n, 0] }  # multiply by slope to turn
                                               # y-value into x-value
    )
    .sort_by(&:first)  # sort by x-coordinate (2)
    .map &:last        # transform into 1's and 0's (3)
}

Пітона, 53

Для цього використовується результат True / False. Тут нічого особливого.

lambda m,n:[x%m<1for x in range(1,m*n)if x%m*(x%n)<1]

Pyth - 32 24 байти

Jmm,chk@Qddt@Qd2eMS+hJeJ

Здійснює введення через stdin у форматі [m,n]. Друкує результат для stdout у вигляді списку 0 і 1, де 0 = V і 1 = H.

Перевірте це в Інтернеті

Пояснення:

J                           # J = 
 m             2            # map(lambda d: ..., range(2))
  m        t@Qd             # map(lambda k: ..., range(input[d] - 1))
   ,chk@Qdd                 # [(k + 1) / input[d], d]
                eMS+hJeJ    # print map(lambda x: x[-1], sorted(J[0] + J[-1])))

Машинний код IA-32, 26 байт

Шестнадцятковий код:

60 8b 7c 24 24 8d 34 11 33 c0 2b d1 74 08 73 03
03 d6 40 aa eb f2 61 c2 04 00

Я почав із наступного коду С:

void doit(int m, int n, uint8_t* out)
{
    int t = m;
    while (true)
    {
        if (t >= n)
        {
            t -= n;
            *out++ = 1;
        }
        else
        {
            t += m;
            *out++ = 0;
        }
        if (t == n)
            break;
    }
}

Він записує вихід у доданий буфер. Він не повертає довжину виводу, але насправді це не потрібно: довжина виводу завжди m + n - 2:

int main()
{
    char out[100];
    int m = 10;
    int n = 3;
    doit(m, n, out);
    for (int i = 0; i < m + n - 2; ++i)
    {
        printf("%d ", out[i]);
    }
}

Щоб перетворити код C в машинний код, спершу я зробив декілька налаштувань, щоб зробити одну з if/elseгілок порожньою та порівняти 0замість n:

void doit(int m, int n, char* out)
{
    int t = n;
    while (true)
    {
        int r = 0;
        t -= m;
        if (t == 0)
            break;
        if (t >= 0)
        {
        }
        else
        {
            t += m + n;
            ++r;
        }
        *out++ = r;
    }
}

З цього моменту написання коду вбудованого встроювання є простим:

__declspec(naked) void __fastcall doit(int x, int y, char* out)
{
    _asm
    {
        pushad;                 // save all registers
        mov edi, [esp + 0x24];  // edi is the output address
        lea esi, [ecx + edx];   // esi is the sum m+n
    myloop:                     // edx is the working value (t)
        xor eax, eax;           // eax is the value to write (r)
        sub edx, ecx;
        jz myout;
        jae mywrite;
        add edx, esi;
        inc eax;
    mywrite:
        stosb;                  // write one value to the output
        jmp myloop;
    myout:
        popad;                  // restore all registers
        ret 4;                  // return (discarding 1 parameter on stack)
    }
}

Пітон - 125 байт

Використовує дуже простий алгоритм, просто збільшує координати і виявляє, коли він перетинає лінії та роздруковує. Шукаю перекласти на Pyth.

a,b=input()
i=1e-4
x=y=l=o=p=0
k=""
while len(k)<a+b-2:x+=i*a;y+=i*b;k+="V"*int(x//1-o//1)+"H"*int(y//1-p//1);o,p=x,y
print k

Це в той час, як цикл перевіряє кількість lінів, а потім перевіряє, чи якесь значення перейшло через межу int шляхом віднімання.

Здійснює введення на зразок 39, 100stdin та виводить, як HHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHstdout, в один рядок.

CJam, 15 байт

Ll~_:*,\ff{%!^}

Спробуйте тут.

Він друкує 01для V та 10для H.

Пояснення

L          e# An empty list.
l~         e# Evaluate the input.
_:*,       e# [0, m*n).
\          e# The input (m and n).
ff{%!      e# Test if each number in [0, m*n) is divisible by m and n.
^}         e# If divisible by m, add an 10, or if divisible by n, add an 01 into
           e# the previous list. If divisible by neither, the two 0s cancel out.
           e# It's just for output. So we don't care about what the previous list
           e# is -- as long as it contains neither 0 or 1.

Діагональна лінія перетинає горизонтальну лінію на кожні 1 / n всієї діагональної лінії та перетинає вертикальну лінію на кожні 1 / м.

TI-BASIC, 32

Prompt M,N
For(X,1,MN-1
gcd(X,MN
If log(Ans
Disp N=Ans
End

Прямо. Використовує послідовність 0та 1, розділених переривами рядків. Перевагами TI-BASIC є двобайтне gcd(та мається на увазі множення, але його недоліками є цикл For, включаючи кінцеве значення та 5 байтів, витрачених на введення.

Пітона, 47

lambda m,n:[m>i*n%(m+n)for i in range(1,m+n-1)]

Як алгоритм анатолігу , але перевіряється безпосередньо за модулями.

Haskell, 78 байт

import Data.List
m#n=map snd$sort$[(x,0)|x<-[1..m-1]]++[(y*m/n,1)|y<-[1..n-1]]

Приклад використання:

*Main> 19 # 17
[0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0]
*Main> 10 # 3
[0,0,0,1,0,0,0,1,0,0,0]

Як це працює: складіть список значень x усіх вертикальних перетинів (x,0)для xв [1,2, ..., m-1] ( 0позначає вертикальні) та додайте список значень x для всіх горизонтальних перетинів (y*m/n,1)для yв [1,2, ..., n-1] ( 1позначає горизонтальність). Сортуйте і візьміть другі елементи пар.

Прокляття дня: знову мені довелося витратити 17 байт на те, importщо sortзнаходиться в Data.Listстандартній бібліотеці, а не в ній.

КДБ (Q), 44 байти

{"HV"0=mod[asc"f"$1_til[x],1_(x*til y)%y;1]}

Пояснення

Знайдіть усі значення осі x пересічних точок і відсортуйте їх. Якщо mod 1 дорівнює нулю, його "V", не-нульовим є "H".

Тест

q){"HV"0=mod[asc"f"$1_til[x],1_(x*til y)%y;1]}[5;3]
"VHVVHV"

CJam, 26 24 байти

l~:N;:M{TN+Mmd:T;0a*1}*>

Спробуйте в Інтернеті

Дуже відверта реалізація алгоритму типу Брезена.

Пояснення:

l~    Get input and convert to 2 integers.
:N;   Store away N in variable, and pop from stack.
:M    Store away M in variable.
{     Loop M times.
  T     T is the pending remainder.
  N+    Add N to pending remainder.
  M     Push M.
  md    Calculate div and mod.
  :T;   Store away mod in T, and pop it from stack
  0a    Wrap 0 in array so that it is replicated by *, not multiplied.
  *     Emit div 0s...
  1     ... and a 1.
}*      End of loop over M.
>       Pop the last 1 and 0.

Останнє 01потрібно вискочити, тому що цикл пройшов увесь шлях до кінцевої точки, яка не є частиною бажаного результату. Зауважте, що ми не можемо просто зменшити кількість циклів на 1. Інакше, бо N > Mвсі 0s з останньої ітерації будуть відсутні, тоді як нам потрібно позбутися лише останньої 0.