ग्रिड पार करने का क्रम

Question

यदि आप ग्राफ़ पेपर की एक शीट लेते हैं और एक ढलान वाली रेखा खींचते हैं जो mइकाइयों को सही और nइकाइयों तक जाती है, तो आप कुछ अनुक्रम में n-1क्षैतिज और m-1ऊर्ध्वाधर ग्रिडलाइन्स को पार करते हैं। उस अनुक्रम को आउटपुट करने के लिए कोड लिखें।

उदाहरण के लिए, m=5और n=3देता है:

संभवतः संबंधित: यूक्लिडियन लय , फाइबोनैचि झुकाव , फ़िज़बज़ उत्पन्न करना

इनपुट: दो धनात्मक पूर्णांक m,nजो अपेक्षाकृत प्रमुख हैं

आउटपुट: दो अलग टोकन के अनुक्रम के रूप में क्रॉसिंग लौटें या प्रिंट करें। उदाहरण के लिए, इसके बारे में एक स्ट्रिंग हो सकता है Hऔर V, की एक सूची Trueऔर False, या 0की और 1'अलग पंक्ति में मुद्रित रहा है। टोकन के बीच एक विभाजक हो सकता है जब तक कि यह हमेशा समान होता है, और नहीं, कहता है, रिक्त स्थान की एक चर संख्या।

परीक्षण के मामलों:

पहला परीक्षण मामला खाली आउटपुट या कोई आउटपुट नहीं देता है।

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

Comments

पीपीसीजी पर आज: गोल्फ ब्रेसेनहम की रेखा आरेखण एल्गोरिथम

— स्पायर

आपके द्वारा जोड़े गए वैकल्पिक प्रारूप के आधार पर, इनपुट को आउटपुट के भाग के रूप में दोहराया जा सकता है / होना चाहिए? अन्यथा, मुझे समझ में नहीं आता कि इनपुट और आउटपुट एक ही सूची का हिस्सा क्यों हैं।

— रेटो कोराडी

@RetoKoradi नहीं, आपको इनपुट शामिल नहीं करना चाहिए। मैंने इसे ट्यूपल्स में रखा ताकि परीक्षण के मामलों को संसाधित करना आसान हो सके।

— xnor

मैं उत्तर की भविष्यवाणी कर सकता हूं, लेकिन यह पूछने के लिए चोट नहीं पहुंचा सकता: क्या यह आउटपुट टोकन के रूप में अंतरिक्ष चरित्र का उपयोग करने के लिए स्वीकार्य होगा? इसका परिणाम यह होगा कि आउटपुट में महत्वपूर्ण अग्रणी / अनुगामी स्थान हो सकते हैं। कोई अन्य स्थान नहीं होगा, इसलिए सभी स्थान महत्वपूर्ण होंगे।

— रीटो कोराडी जूल

@RetoKoradi नहीं, क्योंकि अनुगामी स्थान दृश्यमान नहीं हैं।

— xnor

Answer 1

रूबी, 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)

और रूबी कोड को एक गाइड के रूप में उपयोग करते हुए, पूरी चीज़ कैसे काम करती है, इसकी व्याख्या:

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

Answer 2

पायथन, 53

यह True / False सूची आउटपुट का उपयोग करता है। यहां कुछ खास नहीं।

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

Answer 3

पायथ - 32 24 बाइट्स

Jmm,chk@Qddt@Qd2eMS+hJeJ

प्रारूप के साथ स्टड के माध्यम से इनपुट लेता है [m,n] । परिणाम को 0 और 1 की सूची के रूप में रोकने के लिए प्रिंट करता है, जहां 0 = वी और 1 = एच।

इसे ऑनलाइन टेस्ट करें

---

स्पष्टीकरण:

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

Comments

जब आप मैपिंग समाप्त कर रहे हों, तो आप सिंटैक्टिकल मैप ऑपरेटर का उपयोग करके एक बाइट को बचा सकते हैं। eMके रूप में ही है med।

— माल्टेन

इसके अलावा, आप केवल तभी निकाल @"VH"सकते हैं जब आपको प्रिंट करने की अनुमति दी जाती है 0और 1इसके बजाय Vऔर H।

— माल्टसेन

आप इनलाइन असाइनमेंट का उपयोग करके एक और बाइट बचा सकते हैं J। यहाँ मेरे पास अभी तक 25 बाइट्स हैं: pyth.herokuapp.com/…

— माल्टीसेन

@ माल्टीसेन, धन्यवाद मुझे लगता है कि आप हटा सकते हैं jkक्योंकि आउटपुट एक सूची हो सकती है।

— टायिलो

आप इनलाइन असाइनमेंट के बारे में मेरी टिप्पणी पर 23 नज़र डाल सकते हैं।

— माल्टसेन

Answer 4

IA-32 मशीन कोड, 26 बाइट्स

कोड के Hexdump:

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

मैंने निम्नलिखित C कोड से शुरुआत की:

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

Comments

मैं उत्सुक हूँ - यह एल्गोरिथ्म क्यों काम करता है?

— xnor

@xnor अनौपचारिक रूप से, यह fizzbuzz अनुक्रम को ट्रैक करता है । यहाँ t"दूरी buzz" है। अगर दूरी कम से कम है n, तो जाओ fizz, और जाओ buzz; दूरी को अपडेट करें; दोहराएँ जब तक यह 0. है

— anatolyg

Answer 5

पायथन - 125 बाइट्स

एक बहुत ही सरल एल्गोरिथ्म का उपयोग करता है, बस निर्देशांक बढ़ाता है और पता लगाता है जब यह लाइनों को पार करता है और प्रिंट करता है। पाइथ में अनुवाद करने के लिए देख रहा हूँ।

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पैर की उंगलियों की संख्या की जाँच कर रहा है और फिर जाँच कर रहा है कि क्या मानों में से कोई भी घटाकर एक अंतर सीमा पर चला गया है।

एक लाइन में stdout की 39, 100तरह स्टड और प्रिंट से इनपुट लेता है HHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHH।

Answer 6

सीजेएम, 15 बाइट्स

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

इसे यहाँ आज़माएँ।

यह 01V और के लिए प्रिंट करता है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 / m के लिए एक ऊर्ध्वाधर रेखा को पार करती है।

Comments

क्या आप इसके लिए स्पष्टीकरण जोड़ेंगे? यह बहुत पेचीदा है, लेकिन कम से कम एक प्रारंभिक त्वरित नज़र से मुझे समझ नहीं आता कि यह क्यों काम करता है। इसके साथ खेलने से, मैं देखता हूं कि यह केवल उन मूल्यों के लिए काम करता है जो सापेक्ष अपराध हैं (जो कि समस्या वर्णन में दिए गए हैं), जबकि मेरा सभी मूल्यों के लिए काम करता है। इसलिए अंतर्निहित गणित स्पष्ट रूप से बहुत अलग है।

— रेटो कोराडी जूल

इसे कुछ और डूबने देने के बाद, मेरा मानना ​​है कि मैं कम से कम एल्गोरिथम भाग को समझता हूं। बाद में आउटपुट जनरेशन लॉजिक का अध्ययन करना होगा।

— रेटो कोराडी

@RetoKoradi संपादित

— jimmy23013

Answer 7

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(और निहित गुणन हैं, लेकिन इसके नुकसान हैं एंड लूप सहित अंत मूल्य और इनपुट के लिए खर्च किए गए 5 बाइट्स।

Answer 8

अजगर, ४ 47

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

अनातोलीग के एल्गोरिथ्म की तरह , लेकिन सीधे तौर पर मोडुली से जांचा जाता है।

Answer 9

हास्केल, 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,0)के लिए xमें [1,2, ..., एम-1] ( 0ऊर्ध्वाधर इंगित करता है) और सभी क्षैतिज क्रॉसिंग की एक्स-मानों की सूची संलग्न (y*m/n,1)के लिएy में [१,२, ..., एन -१] ( 1क्षैतिज इंगित करता है)। जोड़े के दूसरे तत्वों को क्रमबद्ध करें और लें।

दिन का अभिशाप: फिर से मुझे 17 बाइट खर्च करने होंगे importक्योंकि sortयह Data.Listमानक पुस्तकालय में नहीं है।

Answer 10

केडीबी (क्यू), 44 बाइट्स

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

व्याख्या

सभी एक्स खोजेंप्रतिच्छेदन बिंदुओं के अक्ष मान कीजिए और उन्हें क्रमबद्ध कीजिए। यदि मोड 1 शून्य "V" है, तो गैर-शून्य "H" है।

परीक्षा

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

Answer 11

सीजेएम, 26 24 बाइट्स

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

इसे ऑनलाइन आज़माएं

बहुत सीधा, बहुत ज्यादा एक Bresenham प्रकार एल्गोरिथ्म का प्रत्यक्ष कार्यान्वयन।

स्पष्टीकरण:

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।

Comments

आप के >लिए उपयोग कर सकते हैं ;W<।

— jimmy23013

@ jimmy23013 अच्छा विचार है। चूंकि मुझे पता है कि मेरे पास 1स्टैक के ऊपर है, इसलिए मैं इसे उत्पादक रूप से उपयोग कर सकता हूं।

— रेटो कोराडी जूल