ইউরিনাল প্রোটোকল


38

পটভূমি

তথাকথিত "ইউরিনাল প্রোটোকল", যাতে পুরুষের বাথরুমে পৃথক ইউরিনালগুলি বাছাই করা হয় তা বর্ণনা করে একাধিক জায়গায় আলোচনা করা হয়েছে been এই এক্সকেসিডি ব্লগ পোস্টে একটি সংস্করণ দেওয়া হয়েছে । এই প্রশ্নটি একটি সামান্য প্রকরণ উদ্বেগ:

ব্যবস্থা : একটি লাইনে এন ইউরিনাল।
প্রোটোকল : প্রতিটি নতুন ব্যক্তি ইতিমধ্যে ব্যবহার করা থেকে দূরের ইউরিনালগুলির মধ্যে একটি নির্বাচন করে।

মনে রাখবেন যে প্রথম ব্যক্তি কর্তৃক ইউরিনাল বাছাই করা হয় তার উপরে এই কোনও বিধিনিষেধ নেই

আপডেট : এন লোকেরা এন ইউরিনাল নির্বাচন করতে পারে এমন বিভিন্ন উপায়ে ক্রম 1, 2, 4, 8, 20 দিয়ে শুরু হয় ... দ্রষ্টব্য যে এটি OEIS A095236 এর মতো নয় , যা এর থেকে কিছুটা কঠোর বিধিনিষেধ বর্ণনা করে প্রশ্ন।

কার্য

0 এবং 10 এর মধ্যে একটি পূর্ণসংখ্যা n দেওয়া, আউটপুট (যে কোনও ক্রমে) সমস্ত সম্ভাব্য ক্রম যাতে এন লোকেরা ইউরিনাল দখল করতে পারে। ,, মানুষ (প্রথম 9 জনের জন্য 1-9, 0 দশম জন্য) প্রতিনিধিত্বমূলক বামদিকের মূত্রধানী থেকে শুরু হল সংখ্যার একটি ক্রম সঙ্গে: প্রতিটি ক্রম চূড়ান্ত ব্যবস্থা হিসাবে প্রিন্ট করা উচিত ঐচ্ছিক মধ্যে অ আলফানিউমেরিক বিভাজক (কিন্তু আগে বা পরে) সংখ্যাগুলি। উদাহরণস্বরূপ, নিম্নলিখিত ফলাফলগুলি উভয়ই বৈধ:

>> 3
132
213
312
231

>> 4
1|3|4|2
1|4|3|2
3|1|4|2
4|1|3|2
2|3|1|4
2|4|1|3
2|3|4|1
2|4|3|1

আপনি STDIN (অথবা নিকটতম বিকল্প), কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিয়ে একটি প্রোগ্রাম বা ফাংশন লিখতে পারেন। ফলাফলগুলি STDOUT (বা নিকটতম বিকল্প) এ মুদ্রিত করা উচিত।

স্কোরিং

সংক্ষিপ্ততম কোড জিতেছে। মানক শর্তাবলী প্রযোজ্য।


1
হুঁ। 5 urinals আমি পেতে এই । পরিবর্তে এটি 16 টি সারি হওয়া উচিত। কেউ কি দয়া করে এই সমাধানগুলির মধ্যে কোনটি ভুল বলে বর্ণনা করবেন? এটি বর্তমানে বাস্তবায়িত হচ্ছে: ইউরিনালগুলির মধ্যে যে কোনও একটির সাথে সর্বোচ্চ দূরত্ব যুক্ত চয়ন করুন।
নিডসেল্প

1
স্যান্ডবক্সিংয়ের জন্য এতটুকু :-( স্প্যাসটি টাস্কে বর্ণিত হয়েছে, সিক্যুয়েন্স সংজ্ঞা নয় a আমি কম্পিউটারে
পৌঁছানোর সাথে

1
@ কেন্ডসেল্প সারি 3, 4, 17, 18 টি ভুল। এর মধ্যে, আপনি spanদৈর্ঘ্য 1 এর একত্রে ব্যক্তি # 3 রাখুন , যেখানে spanদৈর্ঘ্যের 2 টি উপলব্ধ। আমি হঠাৎ নিজেকে বিভ্রান্ত করতে পেরেছি। এটি প্রদর্শিত হবে যে ওপি ইচ্ছাকৃতভাবে লিঙ্কটি থেকে উদ্ভূত হয়েছে, এবং এইভাবে লিঙ্কটি অনুসরণ করা উচিত?
ব্রেইনস্টিল

টেক্সট A095236 এর মতো নয় বলে উল্লেখ করার জন্য আপডেটটি তৈরি করা হয়েছে spec
উরি গ্রান্টা

এটি কি [1, 3, 2] এ ফর্ম্যাটটিকে আউটপুট দেওয়ার অনুমতি দেয়, যেখানে এই জাতীয় সমাধানটি নিউলাইন দ্বারা পৃথক করা হয়? (সুতরাং কেবল "," এর
পৃথককারী নয়

উত্তর:


11

পাইথ, 53 51

MhSm^-dG2HjbmjdmehxkbQusmm+dkfqgTdeSmgbdQUQGUtQm]dQ

এটি একটি পুনরাবৃত্তি পদ্ধতির। অর্ডার করা লোকেশনগুলির সেটগুলিতে আংশিকভাবে পূর্ণ একটি সম্ভাব্য স্থান দেওয়া, আমরা সমস্ত অনুকূল আরও অবস্থানগুলি পাই, তারপরে সংশ্লিষ্ট অবস্থানের তালিকা তৈরি করি এবং পুনরাবৃত্তি করি।

ফর্মটিতে ফলাফল উত্পন্ন হয় [<first person's location>, <second person's location> ...], তারপরে এটি পছন্দসই বিন্যাসে রূপান্তরিত হয়। MhSm^-dG2Hএকটি সহায়ক ফাংশন সংজ্ঞায়িত করে যা একটি প্রদত্ত স্টল থেকে একটি দখলকৃত স্টলে (স্কোয়ারড) সর্বনিম্ন দূরত্ব খুঁজে পায়। মজাদারভাবে, বিভাজনকারী মুক্ত।

উদাহরণ রান।

ব্যাখ্যা:

প্রথমত, সহায়ক ফাংশন g, যা জি এবং কোনও মানের মধ্যে ন্যূনতম স্কোয়ারের দূরত্ব খুঁজে পায় finds

MhSm^-dG2H
M             def g(G,H): return
 hS           min(                         )
   m     H        map(lambda d:        , H) 
    ^-dG2                      (d-G)**2

এরপরে, আমরা সেই ইউরিনাল এবং যে কোনও অর্পিত মূত্রের মধ্যে ন্যূনতম স্কোয়ার দূরত্বের সর্বাধিক প্রস্রাবের অবস্থানগুলি পাই:

( Qইনপুট হয়।)

eSmgbdQ
eS          max(                                   )
  m   Q         map(lambda b:      , range(len(Q)))
   gbd                       g(b,d)

dএক্ষেত্রে হ'ল দখলযুক্ত মূত্রের তালিকা এবং প্রস্রাবের bঅবস্থানগুলি পুনরাবৃত্তি করে।

এরপরে, আমরা সমস্ত প্রস্রাবের অবস্থানগুলি পাই যাগুলির নিকটতম অধিষ্ঠিত মূত্র থেকে ন্যূনতম স্কোয়ার দূরত্ব উপরে পাওয়া সর্বাধিক মানের সমান।

fqgTdeSmgbdQUQ
f           UQ    filter(lambda T:                             , range(len(Q)))
 qgTd                             g(T,d) ==
     eSmgbdQ                                <value found above>

এরপরে, আমরা উপরে পাওয়া মূত্রের অবস্থানগুলি যুক্ত করে তৈরি ইউরিনাল অবস্থানের তালিকা তৈরি করব d। আমরা এইভাবে দৈর্ঘ্য থেকে তালিকা ব্যাপ্ত মূত্রধানী অবস্থানগুলির প্রতিটি পূর্ববর্তী তালিকা জন্য এমনটি করবে, Nকরতে N+1Gপ্রদত্ত ইউরিনাল স্থানগুলির প্রদত্ত দৈর্ঘ্যের আইনি তালিকার তালিকা।

smm+dkfqgTdeSmgbdQUQG
sm                  G    sum(map(lambda d:                               ,G)
  m+dk                                   map(lambda k:d+[k],            )
      fqgTdeSmgbdQUQ                                        <above list>

এরপরে, আমরা অধিষ্ঠিত ইউরিনাল অবস্থানের তালিকাগুলির সম্পূর্ণ তালিকা তৈরি করতে বারবার উপরোক্ত ভাবটি প্রয়োগ করব। u, কমানো ফাংশন, ঠিক এটি করে, তার দ্বিতীয় তর্কটিতে যতবার উপাদান রয়েছে ততবার।

usmm+dkfqgTdeSmgbdQUQGUtQm]dQ
usmm+dkfqgTdeSmgbdQUQG           reduce(lambda G,H: <the above expression)
                      UtQ        repeat Q-1 times
                         m]dQ    starting with [[0], [1], ... [Q-1]]. 

উপরের উপস্থাপন থেকে রূপান্তর করুন, যা যায় [<1st location>, <2nd location>, ... ], পছন্দসই আউটপুট ফর্ম [<person in slot 1>, <person in slot 2>, ... ],। তারপরে, আউটপুট ফর্ম আউটপুট স্ট্রিংয়ের সাথে যুক্ত হয়ে মুদ্রিত হয়। মুদ্রণ জড়িত।

jbmjdmehxkbQ
jbm             '\n'.join(map(λ k:                                    ,<above>)
   jdm     Q                      ' '.join(map(λ b:                ,Q)
        xkb                                        b.index(k)
      eh                                                     +1 %10

ড্যামনিত, পাইথের আমার পুনরাবৃত্ত সমাধানগুলি বন্ধ করা উচিত। আমি সর্বদা পরাজিত হই: P
orlp

kajsdlkas^23asdjkla1lasdkj~JZasSSA- প্রায় অর্ধেক আকার।
অপ্টিমাইজার 6

@ অপ্টিমাইজার আমি যখন কম ব্যস্ত থাকি তখন আমি একটি ব্যাখ্যা যুক্ত করব।
isaacg

8

পাইথ, 75 71 67

DcGHFk_UQJf!s:GeS,0-TkhS,h+TklGUQIJRsmcX>G0dhHhHJ)R]Gjbmjdmebkcm0Q0

পুনরাবৃত্তিমূলক সংমিশ্রণ সমাধান।

এটি পাইথন সমাধান থেকে মোটামুটি প্রত্যক্ষ অনুবাদ:

N = int(input())

def gen(l, p):
    for d in reversed(range(N)):
        s = []
        for i in range(N):
            if not sum(l[max(0,i-d):min(i+d+1, len(l))]):
                s.append(i)

        if s:
            r = []
            for possib in s:
                j = l[:]
                j[possib] = p+1
                r += gen(j, p+1)

            return r

    return [l]

print("\n".join(" ".join(str(x % 10) for x in sol) for sol in gen([0] * N, 0)))

ওটা কিভাবে কাজ করে? "পুনরাবৃত্ত সংযোজক সমাধান" এর চেয়ে আরও বিশদে।
tbodt

@tbodt পাইথ অনুবাদ করার আগে পাইথন কোডটি যুক্ত করেছিলাম।
orlp

5

সি, 929 878 বাইট

এই এক দৈত্য, ছেলেরা। দুঃখিত।

typedef unsigned long U;typedef unsigned char C;U f(int*u,n){C c[8],a[8];*(U*)(&c)=-1;int i,b=0,l=-9,s=-2,f=0,d;for (i=0; i<n; i++) {if (!u[i]&&s<0)s=i,l=0;if(!u[i])l++;if(u[i]&&s>=0){if(!s)l=2*l-1;d=(l-1)/2;if(b<d)*(U*)(a)=0,*(U*)(c)=-1,*c=s,*a=l,f=1,b=d;else if(b==d)c[f]=s,a[f++]=l;s=-1;}}if(s>=0&&l){l=2*l-1;d=(l-1)/2;if(b<d)*(U*)(c)=-1,*c=s,*a=l,f=1,b=d;else if(b==d)c[f]=s,a[f++]=l;}d=f;for(i=0;i<d;i++){if((c[i]+1)&&c[i]){if(c[i]+a[i]==n)c[i]=n-1;else{if(!(a[i]%2))c[f++]=b+c[i]+1;c[i]+=b;}}}return*(U*)c;}void P(int*u,n,i,c,m){for(i=0;i<n;i++){if(!u[i])c++;if(u[i]>m)m=u[i];}if(!c){for(i=0;i<n;i++)printf("%d",u[i]==10?0:u[i]);printf("\n");}else{int s[8][n];for(i=0;i<8;i++)for(c=0;c<n;c++)s[i][c]=u[c];U t=f(u,n);C*H=&t;for(i=0;i<8;i++)if((C)(H[i]+1))s[i][H[i]]=m+1,P(s[i],n,0,0,0);}}void L(n){int u[n],i,j;for(i=0;i<n;i++){for(j=0;j<n;j++)u[j]=j==i?1:0;P(u,n,0,0,0);}}

সংজ্ঞায়িত 3 ফাংশন, f(int*,int), P(int*,int,int,int,int), এবং L(int)। কল করুন L(n), এবং এটি STDOUT এ আউটপুট দেয়।

এর জন্য আউটপুট n=5:

14352
15342
31452
31542
41352
51342
41532
51432
24153
25143
34152
35142
23415
23514
24513
25413
24315
25314
24351
25341

আপডেট: আমি বিভাজকগুলি সরিয়েছি এবং কোডটি ঠিক করেছি। পুরানো কোডটি কেবলমাত্র n = 7 + এর জন্য ব্যর্থ হয়েছিল, তবে এন = 10 (ওফ!) এর জন্য কিছুই আউটপুট করতে ব্যর্থ হয়েছিল। আমি আরও ভালভাবে এই গুচ্ছ পরীক্ষা করেছি। এটি এখন এন = 13 পর্যন্ত ইনপুট সমর্থন করে (যদিও এটিতে "%d"পরিবর্তন করা উচিত "%x"তাই এটি হেক্সাডেসিমালে মুদ্রিত হয়)। ইনপুট আকার নির্ভর করে sizeof(long)এবং এটি 8অনুশীলন হিসাবে অনুমান করা হয়।

এটি কীভাবে কাজ করে তার কিছু ব্যাখ্যা এবং কেন এই জাতীয় বৈষম্য বাধা রয়েছে:

এগুলি প্রচুর ব্যবহৃত হয়েছিল, তাই আমরা কয়েকটি বাইট সংরক্ষণ করতে তাদের সংজ্ঞা দিয়েছি:

typedef unsigned long U; typedef unsigned char C;

এখানে f:

U f(int*u,n){
    C c[8],a[8];
    *(U*)(&c)=-1;
    int i,b=0,l=-9,s=-2,f=0,d;
    for (i=0; i<n; i++) {
        if (!u[i]&&s<0)
            s=i,l=0;
        if(!u[i])
            l++;
        if(u[i]&&s>=0){
            if(!s)
                l=2*l-1;
            d=(l-1)/2;
            if(b<d)
                *(U*)(a)=0,
                *(U*)(c)=-1,
                *c=s,
                *a=l,
                f=1,
                b=d;
            else if(b==d)
                c[f]=s,a[f++]=l;
            s=-1;
        }
    }
    if(s>=0&&l){
        l=2*l-1;
        d=(l-1)/2;
        if(b<d)
            *(U*)(c)=-1,
            *c=s,
            *a=l,
            f=1,
            b=d;
        else if(b==d)
            c[f]=s,a[f++]=l;
    }
    d=f;
    for(i=0;i<d;i++){
        if((c[i]+1)&&c[i]){
            if(c[i]+a[i]==n)
                c[i]=n-1;
            else{
                if(!(a[i]%2))
                    c[f++]=b+c[i]+1;
                c[i]+=b;
            }
        }
    }
    return*(U*)c;
}

fআকারের একটি অ্যারে nএবং nনিজেই নেয়। এখানে কেবল চতুর বিটটি এটি ফেরত দেয় unsigned longযা char[8]কলিং ফাংশন দ্বারা একটিতে রূপান্তরিত হয় । অ্যারের প্রতিটি অক্ষর এইভাবে হয় 0xFFবা পরবর্তী ব্যক্তির জন্য একটি বৈধ মূত্রের দিকে নির্দেশ করে একটি সূচকতে সেট করা হয় । কারণ n<10, আমাদের পরবর্তী বৈধ মূত্রটি পরবর্তী ব্যক্তি যেভাবে ব্যবহার করতে পারে তা ধরে রাখতে আমাদের কখনই 5 বাইটের বেশি প্রয়োজন হয় না।

এখানে P:

void P(int*u,n,i,c,m){
    for(i=0;i<n;i++){
        if(!u[i])c++;
        if(u[i]>m)m=u[i];
    }
    if(!c){
        for(i=0;i<n;i++)
            printf("%d",u[i]==10?0:u[i]);
        printf("\n");
    }
    else{
        int s[8][n];
        for(i=0;i<8;i++)
            for(c=0;c<n;c++)
                s[i][c]=u[c];
        U t=f(u,n);
        C*H=&t;
        for(i=0;i<8;i++)
            if((C)(H[i]+1))
                s[i][H[i]]=m+1,P(s[i],n,0,0,0);
    }
}

Puআকারের একটি অ্যারে নেয় nযেখানে ঠিক একটি উপাদান সেট করা থাকে 1এবং বাকিগুলি থাকে 0। এরপরে এটি প্রতিটি আদেশের পুনরাবৃত্তির সাথে সন্ধান করে এবং মুদ্রণ করে।

এখানে L:

void L(n){
    int u[n],i,j;
    for(i=0;i<n;i++){
        for(j=0;j<n;j++)
            u[j]=j==i?1:0;
        P(u,n,0,0,0);
    }
}

LP nপ্রতিটি সময় বিভিন্ন প্রারম্ভিক অবস্থানের সাথে কেবল সময় কল করে ।

আগ্রহীদের জন্য, এটি (কম গল্ফ করা) fক্রমটি A095236 এ উত্পন্ন করবে ।

U f(int*u,n) {
    C c[8];
    *(U*)(&c) = -1;
    int i,b=0,l=-10,s=-2,f=0,d;
    for (i=0; i<n; i++) {
        if (!u[i]&&s<0) {
            s=i,l=0;
        }
        if(!u[i]){
            l++;
        }
        if (u[i]&&s>=0) {
            if (!s) {
                l=2*l-1;
            }
            if (b<l) {
                *(U*)(&c)=-1;
                c[0]=s;
                f=1;
                b=l;
            }
            else if (b==l)
                c[f++]=s;
            s=-1;
        }
    }
    if (s>=0&&l) {
        l=2*l-1;
        if (b<l) {
            *(U*)(&c)=-1;
            c[0]=s;
            f=1;
            b=l;
        }
        else if (b==l)
            c[f++]=s;
    }
    d=f;
    for (i=0; i<d; i++) {
        if ((c[i]+1)&&c[i]) {
            if (c[i]+b==n) {
                c[i]=n-1;
            }
            else{
                if (!(b%2)) {
                    c[f++]=(b-1)/2+c[i]+1;
                }
                c[i]+=(b-1)/2;
            }
        }
    }
    return *(U*)c;
}

"1 4 ..." শুরুতে এই
অনুমানের

2
@ এনাটলিগ নং "1 4" কীভাবে ঘটতে পারে তার একটি ধাপে ধাপে ব্যাখ্যা: gist.github.com/orlp/a5706ba664b70209b48a
orlp

মনে রাখবেন, বিভাজকগুলি alচ্ছিক। % D :-) এর পরে স্থানটি সরিয়ে আপনি 1 বাইট (!) সঞ্চয় করতে পারবেন
উরি গ্রান্টা

@ উরিজারফ্যাটি ধন্যবাদ! প্রকৃতপক্ষে, এখানে একটি টন বাট সংরক্ষণ করতে হবে। আমি বর্তমানে একটি ভাল সমাধান এবং একটি ব্যাখ্যা লিখছি।
ব্রেইনস্টিল

@yo 'আমি মনে করি আপনি আউটপুটটি কিছুটা বিভ্রান্ত করছেন। 14352বাম-সর্বাধিক ইউরিনাল বেছে নিয়েছে ব্যক্তি # 1 এর আউটপুট । ব্যক্তি # 2 ডান-সর্বাধিক একটিকে বেছে নিয়েছে, যা পরে # 3 কে মাঝখানে জোর করে। এটি পরবর্তী ইউরিনাল বাছাইয়ের সংখ্যা নয় যা আউটপুট হওয়া উচিত।
ব্রেইনস্টিল

4

পাইথন 2, 208

n=input()
r=range(n)
l=[0]*n
def f(a,d=-1):
 if a>n:print''.join(l);return
 for i in r:
  t=min([n]+[abs(i-j)for j in r if l[j]])
  if t==d:p+=[i]
  if t>d:p=[i];d=t
 for i in p:l[i]=`a%10`;f(a+1);l[i]=0
f(1)

পুনরাবৃত্তি পদ্ধতির।


4

জাভাস্ক্রিপ্ট (ES6) 153 160 169

ম্যাথ.মিন ব্যবহার করে সর্বাধিক দূরত্ব (অবশ্যই) স্রোতযুক্ত কোড এবং 16 বাইট সংরক্ষণ করা ব্যবহার করুন Edit

পুনরাবৃত্ত অনুসন্ধান, এন> 10 দিয়ে কাজ করতে পারে, কেবল% 10 মুছে ফেলুন (এবং কনসোলটি তার সমস্ত আউটপুট আনলোল করার সময় অপেক্ষা করতে প্রস্তুত থাকুন)।

আমি স্লটটি ব্যবহারে (ধনাত্মক সংখ্যা) বা নিকটতম স্লট থেকে বর্তমান দূরত্ব (negative ণাত্মক সংখ্যা <এবং তাই >কোডের মধ্যে অদলবদল) সঞ্চয় করতে একক অ্যারে ব্যবহার করি ।

F=n=>{(R=(m,d,t,x=Math.min(...d=m?
  d.map((v,i)=>(c=i<t?i-t:t-i)?v<c?c:v:m%10)
  :Array(n).fill(-n)))=>
x<0?d.map((v,i)=>v>x||R(-~m,d,i)):console.log(d+[]))()}

Ungolfed

F=n=>{
  var R=(m, // current 'man', undefined at first step
   d, // slot array
   t // current position to fill
  ) =>
  {
    if (m) // if not at first step
    {
      d[t] = m % 10; // mark slot in use, (10 stored as 0 )
      d = d.map((v,i) => { // update distances in d[] 
        var c = i<t ? i-t : t-i; // distance from the current position (negated)
        return v < c ? c : v; // change if less than current distance
      });
    }
    else
    {
      d = Array(n).fill(-n) // fill distance array with max at first step
      // negative means slot free, value is the distance from nearest used slot
      // >= 0 means slot in use by man number 1..n 
    }
    var x = Math.min(...d);
    if ( x < 0 ) // if there is still any free slot
    {
      d.forEach((v,i) => { // check distance for each slot 
        if (v <= x) // if slot is at max distance, call recursive search
          R(-~m, [...d], i) // ~- is like '+1', but works on undefined too
      });
    }
    else
    {
      console.log(d+[]); // no free slot, output current solution
    }
  }

  R() // first step call
}

টেস্ট সালে ফায়ারফক্স / ফায়ারবাগ কনসোলটি

F(5)

1,4,3,5,2
1,5,3,4,2
3,1,4,5,2
3,1,5,4,2
4,1,3,5,2
5,1,3 , 4,2
4,1,5,3,2
5,1,4,3,2
2,4,1,5,3
2,5,1,4,3
3,4,1,5,2
3 , 5,1,4,2
2,3,4,1,5
2,3,5,1,4
2,4,3,1,5
2,5,3,1,4
2,4,5, 1,3
2,5,4,1,3
2,4,3,5,1
2,5,3,4,1



1

ম্যাটল্যাব, 164

function o=t(n),o=mod(r(zeros(1,n)),10);function o=r(s),o=[];d=bwdist(s);m=max(d);J=find(d==m);if~d,o=s;J=[];end,n=max(s)+1;for j=J,o=[o;r(s+n*(1:numel(s)==j))];end

1

পার্ল, 174

খুব ছোট নয়, তবে মজাদার fun আমি use feature 'say';বাইট মোটের দিকে গণনা করছি না ।

$n=pop;@u="_"x$n." "x$n."_"x$n;for$p(1..$n){@u=map{my@r;for$x(reverse 0..$n){
s/(?<=\D{$x}) (?=\D{$x})/push@r,$_;substr $r[-1],pos,1,$p%10/eg and last;
}@r}@u}y/_//d&&say for@u

ডি-golfed:

$n = pop; # Get number of urinals from commandline
@state = ( "_" x $n . " " x $n . "_" x $n );

for my $person (1 .. $n) {
  # Replace each state with its list of possible next states.
  @state = map {
    my @results;
    for my $distance (reverse 0 .. $n) {
      # If there are any spots with at least $distance empty on
      # both sides, then add an entry to @results with the current
      # $person number in that spot, for each spot. Note that this
      # is only used for its side-effect on @results; the modified $_
      # is never used.
      s{
        (?<=\D{$distance})
        [ ]
        (?=\D{$distance})
      }{
        push @results, $_;
        substr $results[-1], pos(), 1, $person % 10;
      }xeg
      # If we found any spots, move on, otherwise try
      # with $distance one lower.
      and last;
    }
    # New state is the array we built up.
    @results;
  } @state;
}

# After adding all the people, remove underscores and print the results
for my $result (@state) {
  $result =~ tr/_//d;
  say $result;
}

1

সি, 248 বাইট

এই কোডটি পছন্দসই ফলাফল উত্পন্ন করতে পুনরাবৃত্ত আলগোরিটম ব্যবহার করে।

void q(char*f,int l,int d,char*o){char*c=f;while(f<c+l){if(!*f){sprintf(o+4*d,"%03i,",f-c);*f=1;q(c,l,d+1,o);*f=0;}f++;}if(d+1==l){o[4*d+3]=0;printf("%s\n",o);}}int main(int i,char**v){int k=atoi(v[1]);char*c=calloc(k,5),*o=c+k;q(c,k,0,o);free(c);}

সম্প্রসারিত:

void printperms(char* memory,int length,int offset,char*output)
{
    char*temp_char=memory;
    while(memory<temp_char+length)
    {
        if(!*memory)
        {
            sprintf(output+4*offset,"%03i,",memory-temp_char);
            *memory=1;
            printperms(temp_char,length,offset+1,output);
            *memory=0;
        }
        memory++;
    }
    if(offset+1==length)
    {
        output[4*offset+3]=0;
        printf("%s\n",output);
    }
}

int main(int i,char**v)
{
    int argument=atoi(v[1]);
    char*t=calloc(argument,5),*output=t+argument;
    printperms(t,argument,0,output);
    free(t);
}

1

বাশ, 744 674 বাইট

এটি এখনও অনেক দীর্ঘ :)। আমি পুনরাবৃত্তির প্রতিটি পর্যায়ে সর্বাধিক দূরবর্তী ইউরিনালগুলি সন্ধানের জন্য মূত্রের সারি এবং একটি বন্যার অ্যালগরিদমকে উপস্থাপন করতে একটি স্ট্রিং ব্যবহার করি। অবরুদ্ধ কোডটি প্রায় স্ব-বর্ণনামূলক। ইউরিনাল সংখ্যা কীবোর্ড থেকে পড়া হয়।

কোড (গল্ফড):

read l;u=----------;u=-${u::$l}-
s(){ u=${u:0:$1}$2${u:$((1+$1))};}
m(){ local u=$1;a=();while :;do [ 0 -ne `expr index - ${u:1:$l}` ]||break;t=$u;y=$u;for i in `seq $l`;do [ ${y:$i:1} = - ]||{ s $(($i-1)) X;s $(($i+1)) X;};done;done;while :;do k=`expr index $t -`;[ 0 != $k ]||break;t=${t:0:$(($k-1))}X${t:$k};if [ 1 -ne $k ]&&[ $(($l+2)) -ne $k ];then a+=($(($k-1)));fi;done;}
e(){ local u f b v;u=$1;f=$2;if [ 1 -eq $l ];then echo 1;return;fi;if [ 1 = $f ];then for i in `seq $l`;do v=$u;s $i 1;e $u 2;u=$v;done;else m $u;b=(${a[@]});if [ 0 -eq ${#b} ];then echo ${u:1:$l};else for i in ${b[@]};do v=$u;s $i $(($f%10));e $u $(($f+1));u=$v;a=(${b[@]});done;fi;fi;}
e $u 1

ব্যবহার করুন:

$ source ./script.sh
input number of urinals from keyboard

এবং অবরুদ্ধ এটি যায়:

read l  # read number of urinals
u=----------
u=-${u:0:$l}- #row is two positions longer (it will be helpful when finding the most distant urinals)

# So, for the end, with 6 men, u might look like this:
# -143652-

# subu no fellow_no => set urinal [number] occupied by [fellow_no]
# this is just convenience for resetting a character inside a string
subu(){ u=${u:0:$1}$2${u:$((1+$1))};}


# this will be iterated in longest to find the remotest places:
# -1---3---2- => spreadstep => X1X-X3X-X2X => spreadstep => X1XXX3XXX2X
# see longest() to get more explanation.
spreadstep()
{
    y=$u
    for i in `seq 1 $l`
    do
    if [ "${y:$i:1}" != "-" ]
    then
        subu $(($i-1)) X
        subu $(($i+1)) X
    fi
    done
}

# Find the urinals with the longest distance. It uses spreadstep() - see above.
# -1---3---2- => spreadstep => X1X-X3X-X2X => spreadstep => X1XXX3XXX2X
# ---> last state with free ones was X1X-X3X-X2X ,
#                                     123456789
# free urinals are no. 3 and no. 7 => save them to arr
longest()
{
    local u=$1
    arr=()
    while true
    do
        if [ 0 -eq `expr index - ${u:1:$l}` ]
        then
            break
        fi
        save=$u
        spreadstep
    done

    while true
    do
        index=`expr index $save -`
        if [ 0 == $index ]
        then
            break
        fi

        save=${save:0:$(($index-1))}X${save:$index}
        if [ 1 -ne $index ] && [ $(($l+2)) -ne $index ]
        then
            arr+=($(($index-1)))
        fi
    done
}

# main function, recursively called
# the first fellow may take any of the urinals.
# the next fellows - only those with the longest distance.
placements_with_start()
{
    local u=$1
    local fellow=$2
    if [ 1 -eq $l ] # special case - there is no 2nd fellow, so below code would work incorrect 
    then
        echo "1"
        return
    fi
    if [ 1 == $fellow ]       # may take any of urinals
    then
        for i in `seq 1 $l`
        do
            local _u=$u
            subu $i 1                     # take the urinal
            placements_with_start $u 2    # let the 2nd fellow choose :)
            u=$_u
        done
    else
        longest $u   # find the ones he can take
        local _arr=(${arr[@]})
        if [ 0 -eq ${#_arr} ]
        then
            echo ${u:1:$l}    # no more free urinals - everyone took one - print the result
        else
            for i in ${_arr[@]}
            do
                local _u=$u
                subu $i $(($fellow % 10))                # take urinal
                placements_with_start $u $(($fellow+1))  # find locations for for next fellow
                u=$_u
                arr=(${_arr[@]})
            done
        fi
    fi
}

placements_with_start $u 1
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.