গ্রিড ক্রসিং ক্রম

17

আপনি যদি গ্রাফ পেপারের একটি শীট নেন mএবং একটি opালু লাইন আঁকেন যা ইউনিট ডানদিকে যায় এবং nইউনিটগুলি উপরে যায়, আপনি কিছু অনুক্রমে n-1অনুভূমিক এবং m-1উল্লম্ব গ্রিডলাইনগুলি অতিক্রম করেন । যে অনুক্রমের আউটপুট কোড লিখুন।

উদাহরণস্বরূপ, m=5এবং n=3দেয়:

গ্রিডলাইনগুলি মি = 5, এন = 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])
code-golf  sequence  grid 
— xnor
সূত্র
2
আজ পিপিসিজিতে: গল্ফ ব্রেসেনহ্যামের লাইন অঙ্কন অ্যালগরিদম
— স্পার
আপনি যুক্ত বিকল্প বিন্যাসের উপর ভিত্তি করে, আউটপুট অংশ হিসাবে ইনপুট পুনরাবৃত্তি করা যাবে? অন্যথায়, কেন ইনপুট এবং আউটপুট একই তালিকার অংশ তা আমি বুঝতে পারি না।
— রেটো কোরাাদি
@ রিটোকোরাডি না, আপনাকে ইনপুটটি অন্তর্ভুক্ত করা উচিত নয়। পরীক্ষার কেসগুলি প্রক্রিয়া করা সহজ করার জন্য আমি এটি টিপলে রেখেছি।
— xnor
আমি উত্তরটি পূর্বাভাস দিতে পারি, তবে এটি জিজ্ঞাসা করাতে ক্ষতি করতে পারে না: আউটপুট টোকেনগুলির মধ্যে একটি হিসাবে স্থানের অক্ষরটি ব্যবহার করা কি গ্রহণযোগ্য হবে? এর ফলাফলটি হ'ল আউটপুটটিতে উল্লেখযোগ্য শীর্ষস্থানীয় / পিছনের স্থান থাকতে পারে। অন্য কোনও স্থান থাকবে না, সুতরাং সমস্ত স্থান উল্লেখযোগ্য হবে।
— রেটো কোরাাদি
পুনঃটুইট করুন না, কারণ পিছনের স্থানগুলি দৃশ্যমান নয়।
— xnor

উত্তর:

7

রুবি, 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)
}
— ডোরকনব
সূত্র
5

পাইথন, 53

এটি সত্য / মিথ্যা তালিকার আউটপুট ব্যবহার করে। এখানে বিশেষ কিছু নেই।

lambda m,n:[x%m<1for x in range(1,m*n)if x%m*(x%n)<1]
— feersum
সূত্র
4

পাইথ - 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])))
— Tyilo
সূত্র
আপনি যখন ম্যাপিং শেষ করবেন তখন সিনট্যাক্টিকাল ম্যাপ অপারেটরটি ব্যবহার করে আপনি একটি বাইট সংরক্ষণ করতে পারেন। eMহিসাবে একই med।
— মালটিসেন
এছাড়াও, আপনি শুধু নিতে পারে @"VH"যেহেতু আপনি প্রিন্ট করতে অনুমতি দেওয়া হয় 0এবং 1পরিবর্তে Vএবং H।
— মালটিসেন
এর সাথে ইনলাইন অ্যাসাইনমেন্ট ব্যবহার করে আপনি আরও একটি বাইট সংরক্ষণ করতে পারেন J। আমার এখন পর্যন্ত 25 বাইটে যা আছে তা এখানে: pyth.herokuapp.com/…
— মালটিসেন
@ মাল্টেসেন, ধন্যবাদ আমি মনে করি আপনি jkআউটপুট একটি তালিকা হতে পারে হিসাবে আপনি অপসারণ করতে পারেন ।
— টাইলো
আপনি ইনলাইন অ্যাসাইনমেন্ট সম্পর্কে আমার মন্তব্য 23 টি পেতে পারেন।
— মালটিসেন
4

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

সি কোডটি মেশিন কোডে রূপান্তর করতে, আমি প্রথমে কিছু টুইট করেছিলাম, একটি 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)
    }
}
— anatolyg
সূত্র
আমি কৌতূহলী - কেন এই অ্যালগরিদম কাজ করে?
— xnor
@ xnor অনানুষ্ঠানিকভাবে, এটি fizzbuzz ক্রম ট্র্যাক করে । এখানে t"দূরত্ব buzz"। যদি দূরত্ব কমপক্ষে থাকে তবে nযান fizz, অন্যথায় যান buzz; দূরত্ব আপডেট করুন; পুনরাবৃত্তি না হওয়া পর্যন্ত 0.
— anatolyg
3

পাইথন - 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ইনসের সংখ্যাটি পরীক্ষা করছে এবং তারপরে মানগুলি কোনও বিয়োগ করে একটি পূর্ব সীমা অতিক্রম করেছে কিনা তা পরীক্ষা করে।

স্টিডিনের মতো ইনপুট নেয় এবং এক লাইনে স্টাডআউট 39, 100প্রিন্ট করে HHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHHHVHHVHHHVHHVHHHVHHVHHHVHH।

— Maltysen
সূত্র
3

সিজেম, 15 বাইট

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

এখানে চেষ্টা করুন।

এটি 01ভি এবং 10এইচ এর জন্য প্রিন্ট করে

ব্যাখ্যা

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 / মিটার জন্য একটি উল্লম্ব রেখা অতিক্রম করে।

— jimmy23013
সূত্র
আপনি কি এর জন্য একটি ব্যাখ্যা যুক্ত করবেন? এটি খুব কৌতূহলোদ্দীপক, তবে কমপক্ষে প্রাথমিক তাত্ক্ষণিক দৃষ্টি থেকে আমি বুঝতে পারি না কেন এটি কাজ করে। এটি খেলতে থেকে, আমি লক্ষ্য করেছি যে এটি কেবলমাত্র সেই মানগুলির জন্য কাজ করে যা আপেক্ষিক প্রাইমস (যা সমস্যার বিবরণে দেওয়া হয়), যখন খনি সমস্ত মানের জন্য কাজ করে। সুতরাং অন্তর্নিহিত গণিত স্পষ্টতই খুব আলাদা।
— রেটো কোড়াদি
এটি আরও কিছুতে ডুবে যাওয়ার পরে, আমি বিশ্বাস করি আমি কমপক্ষে অ্যালগরিদম অংশটি বুঝতে পারি। পরে আউটপুট জেনারেশন যুক্তি অধ্যয়ন করতে হবে।
— রেটো কোরাদি
@ রিটোকোরাদি সম্পাদিত।
— জিমি 23013
2

টিআই-বেসিক, 32

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

সহজবোধ্য। লাইনব্রেক দ্বারা পৃথক 0এবং এর একটি ক্রম ব্যবহার 1করে। টিআই-বেসিকের সুবিধাগুলি হ'ল দ্বি-বাইট gcd(এবং সূচিত গুণক, তবে এর অসুবিধাগুলি হ'ল ফর্ম লুপ এবং শেষ মান সহ 5 টি বাইট ইনপুট জন্য ব্যয় করা।

— lirtosiast
সূত্র
1

হাস্কেল, 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, ..., M-1] ( 0উল্লম্ব ইঙ্গিত) এবং সমস্ত অনুভূমিক ক্রসিং-এর এক্স-মূল্যবোধের তালিকা যোগ (y*m/n,1)জন্য yএ [1,2, ..., n-1] ( 1অনুভূমিক নির্দেশ করে)। জোড়গুলির দ্বিতীয় উপাদানগুলি বাছাই করুন এবং নিন।

দিনের অভিশাপ: আবার আমাকে 17 বাইট ব্যয় করতে হয়েছে importকারণ স্ট্যান্ডার্ড লাইব্রেরিতে sortরয়েছে Data.Listএবং না।

— nimi
সূত্র
1

কেডিবি (কিউ), 44 বাইট

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

ব্যাখ্যা

সমস্ত এক্সছেদ করা পয়েন্টগুলির অক্ষের মানগুলি সন্ধান করুন এবং সেগুলি সাজান। যদি Mod 1 এর শূন্য হয় তবে এর "ভি" হয় না, শূন্য নয় "এইচ"।

পরীক্ষা

q){"HV"0=mod[asc"f"$1_til[x],1_(x*til y)%y;1]}[5;3]
"VHVVHV"
— WooiKent লি
সূত্র
1

সিজেম, 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সমস্ত 0এসটি অনুপস্থিত হবে, যখন আমাদের কেবল খুব শেষটি থেকে মুক্তি পাওয়া দরকার 0।

— রেটো কোরাদি
সূত্র
1
আপনি >জন্য ব্যবহার করতে পারেন ;W<।
— জিমি 23013
@ jimmy23013 ভাল ধারণা। যেহেতু আমি জানি যে আমার কাছে 1স্ট্যাকের শীর্ষ রয়েছে, আমি সম্ভবত এটি উত্পাদনশীলভাবে ব্যবহার করতে পারি।
— রেটো কোরাাদি
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.