NxN গ্রিডের সারি, কলাম এবং কর্ণগুলি N এর মাধ্যমে 1 দিয়ে পূরণ করুন

Question

কার্য

ইনপুট এন দেওয়া হয়েছে, একটি এনএক্সএন গ্রিড উত্পন্ন এবং আউটপুট দেয় যেখানে প্রতিটি সারি, কলাম এবং দুটি তির্যকগুলিতে 1 থেকে 1 N(বা Nযদি সহজ হয় তবে 0 থেকে −1) থাকে।

ইনপুট

ইনপুটটি ইতিবাচক পূর্ণসংখ্যা N। এটি গ্রিডে কলাম এবং সারিগুলির সংখ্যা উপস্থাপন করে। এই সমস্যার জন্য, আপনি ধরে নিতে পারেন Nএকটি যুক্তিসঙ্গত আকার হবে, 4 ≤ N ≤ 8বা ( 1 ≤ N ≤ 8আপনি যদি নীচে বোনাসের জন্য যান)।

আউটপুট

আউটপুট হবে N× Nগ্রিড। গ্রিড, প্রত্যেক সারি মাত্র 1 টি সংখ্যার ধারণ করে N, প্রতিটি কলাম শুধুমাত্র সংখ্যা 1 থেকে রয়েছে N, এবং দৈর্ঘ্য দুটি কর্ণ N(থেকে এক (0,0)থেকে (N-1,N-1)থেকে এক (0,N-1)থেকে (N-1, 0)) শুধুমাত্র সংখ্যার 1 ধারণ N। আপনি 0 থেকে নম্বর ব্যবহার করতে পারেন N−1। প্রত্যেকটির জন্য N, অনেকগুলি সম্ভাব্য সমাধান রয়েছে, আপনার কেবলমাত্র প্রথমটি খুঁজে পাওয়া দরকার। সংখ্যার মধ্যে ফাঁকা স্থান মুদ্রণের দরকার নেই।

সীমাবদ্ধতাসমূহ

আপনার কোডটি পুনরাবৃত্তির জন্য ফলাফল তৈরি করতে সক্ষম হওয়া উচিত N >= 7। এটি হ'ল, যদি আপনি প্রতিটিবার N = 7আপনার কোড থেকে প্রকৃতপক্ষে চালাতে এবং সমাধান পেতে সক্ষম হন তবে আপনি ভাল। নিরঙ্কুশ সীমাবদ্ধতার ক্ষেত্রে, আপনার কোডটি N = 7প্রতিবার চালানোর সময় 10 মিনিটের মধ্যে সমাধান করতে সক্ষম হওয়া উচিত (উদাহরণস্বরূপ, আপনি যদি এলোমেলো সংখ্যার উপর নির্ভর করেন, সবচেয়ে খারাপ ক্ষেত্রে আপনার কোডটি এখনও 10 মিনিটের নিচে শেষ করা উচিত N = 7) ।

উদাহরণ

• ইনপুট: 4

  একটি সম্ভাব্য আউটপুট:

  1 2 3 4
  3 4 1 2
  4 3 2 1
  2 1 4 3
  

• ইনপুট: 5

  একটি সম্ভাব্য আউটপুট:

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

• ইনপুট: 8

  একটি সম্ভাব্য আউটপুট:

  1 2 3 4 5 6 7 8
  2 3 1 5 4 8 6 7
  4 1 2 3 7 5 8 6
  6 4 7 8 1 2 3 5
  7 5 8 2 6 3 4 1
  5 8 4 6 2 7 1 3
  8 7 6 1 3 4 5 2
  3 6 5 7 8 1 2 4
  

স্কোরিং

এটি কোড-গল্ফ , তাই বাইটের মধ্যে সংক্ষিপ্ততম কোডটি এক ব্যতিক্রম সহ জয়ী হয়। ইনপুটগুলির N = 2, 3জন্য কোনও বৈধ সমাধান নেই। যদি আপনার কোড এটিকে পরিচালনা করে (এই ক্ষেত্রে কোনও কিছুই আউটপুট না করে বা খালি স্ট্রিং আউটপুট না দিয়ে সম্পূর্ণরূপে চালানো), এবং এখনও পরিচালনা করে N = 1( 1এটির জন্য আউটপুট ), আপনার বাইট গণনা থেকে 20% নিন।

Comments

সম্পর্কিত , তবে ত্রিভুজগুলির প্রয়োজনীয়তার কারণে এই জাতীয় গ্রিডটি এখানে কাজ করবে না।

— xnor

আমি এই চ্যালেঞ্জটি পছন্দ করি তবে এর মানগুলির জন্য আমিও একটি অ্যালগরিদম বের করতে পারি না N। এই জাভাস্ক্রিপ্ট কোডটি N = 1, 5 or 7কারও পক্ষে যদি সহায়তা করে তবে এটির জন্য কাজ করে:for(o="",y=N;y--;o+="\n")for(x=N;x--;)o+=(((N-y)*2+x)%N)+1

— user81655

খুব সম্পর্কিত, ডুপ্লিকেট: কোডগলফ.স্ট্যাকেক্সেঞ্জারভিউ

— স্তর নদী সেন্ট

@ স্টেভেরিলিল যদিও এটি কোড গল্ফ ছিল না।

— এলোমেলো

সম্ভবত আপনার কেসটি সম্পর্কে আরও স্পষ্ট হওয়া উচিত N = 1: বোনাসের লক্ষ্য হিসাবে উত্তরগুলি 1খালি স্ট্রিং নয়, ফিরে আসা উচিত return

— লিন

Answer 1

পাইথন 3, 275 260 বাইট * 0.8 = 220 208 বাইট

পুনরাবৃত্ত / ব্যাকট্র্যাকিং পদ্ধতি Rrecursive ফাংশন lহয়, coLumn wহয়, RoW Kহয়, পরবর্তী প্রবেশিকা।

আমি সূচিগুলি আরও সহজ করতে এটিকে একটি 1 ডি অ্যারে এবং প্রি-প্রিন্ট করা বেছে নিয়েছি।

r=range
n=(int)(input())
def R(A,I):
 l=I%n;w=I//n
 if I==n*n:[print(A[i*n:i*n+n])for i in r(n)];exit()
 for K in r(n):
  if all([all([A[i*n+l]!=K,w!=l or A[i+n*i]!=K,w!=n-1-l or A[n*i+n-i-1]!=K])for i in r(w)]+[A[w*n+i]!=K for i in r(l)]):R(A+[K],I+1)
R([],0)

অবরুদ্ধ সংস্করণ:

def Recurse(A,I,n):
 column=I%n
 row=I//n
 if I==n*n:
     [print(*A[i*n:i*n+n])for i in range(n)] # output
     exit() #end recursion
 for K in range(n):
    # try every possibility. Test if they satisfy the constraints:
    # if so, move the index on. If none of them do, we'll return None.
    # if a child returns None, we'll move onto the next potential child:
    # if all of them fail it will backtrack to the next level.
    if all([
        all([
            A[i*n+column]!=K, # column constraint
            row!=column or A[i+n*i]!=K, # diagonal constraint
            row!=n-1-column or A[n*i+n-i-1]!=K # antidiagonal constraint
            ]) for i in range(row)
        ]+[
            A[row*n+i]!=K for i in range(column) # row constraint
            ]):
        Recurse(A+[K],I+1,n)

Recurse([],0,(int)(input()))

Answer 2

ফানসিটন , অ-প্রতিযোগিতামূলক

হালনাগাদ! ব্যাপক পারফরম্যান্সের উন্নতি! n = 7 এখন 10 মিনিটের নিচে পূর্ণ! নীচে ব্যাখ্যা দেখুন!

এটি লিখতে ভাল মজা ছিল। এটি ফানসিটনে লিখিত এই সমস্যার জন্য একটি নিষ্ঠুর-শক্তি সমাধানকারী। কিছু ফ্যাক্টয়েড:

• এটি STDIN- তে একটি পূর্ণসংখ্যা গ্রহণ করে। কোনও বহিরাগত শ্বেত স্পেস এটি ভেঙে দেয়, পূর্ণসংখ্যার পরে একটি নতুন লাইন সহ।
• এটি 0 থেকে n - 1 (1 থেকে n নয় ) সংখ্যা ব্যবহার করে ।
• এটি গ্রিডটি "পিছনের দিকে" পূরণ করে, সুতরাং নীচের সারিটি 3 2 1 0শীর্ষ সারিটি যেখানে পড়া হবে তার চেয়ে আপনি নীচের সারিটি যেখানে পড়েন সেখানে একটি সমাধান পান 0 1 2 3।
• এটি এন = 1 এর সঠিকভাবে আউটপুট করে 0(একমাত্র সমাধান) ।
• N = 2 এবং n = 3 এর জন্য খালি আউটপুট ।
• কোনও এক্সে-তে সংকলিত হয়ে গেলে, এন = 7 এর জন্য প্রায় 8¼ মিনিট সময় লাগে (পারফরম্যান্স উন্নতির প্রায় এক ঘন্টা আগে)। সংকলন ছাড়াই (দোভাষী ব্যবহার করে) এটি প্রায় 1.5 গুণ সময় নেয়, তাই সংকলকটি ব্যবহার করা এটির পক্ষে উপযুক্ত।
• ব্যক্তিগত মাইলফলক হিসাবে, আমি প্রথমবার সিউডোকোড ভাষায় প্রোগ্রামটি না লিখে পুরো ফানসিটন প্রোগ্রামটি লিখেছিলাম। আমি যদিও এটি প্রথমে আসল সি # তে লিখেছি।
• (তবে, আমি প্রথমবারের মতো ফানসিটনের কোনও কিছুর পারফরম্যান্সের ব্যাপক উন্নতি করতে পরিবর্তন এনেছি না। প্রথমবারের মতো আমি ঘটনাটির কাজটি করেছি the গুণটির অপারেশনগুলির ক্রমটি অদলবদলের কারণে একটি বিশাল পার্থক্য হয়েছিল গুণটি অ্যালগরিদম কীভাবে কাজ করে Just যদি আপনি কৌতূহলী হন case)

আরও ঝামেলা ছাড়া:

            ┌────────────────────────────────────┐           ┌─────────────────┐
            │                                  ┌─┴─╖ ╓───╖ ┌─┴─╖   ┌──────┐    │
            │                    ┌─────────────┤ · ╟─╢ Ӂ ╟─┤ · ╟───┤      │    │
            │                    │             ╘═╤═╝ ╙─┬─╜ ╘═╤═╝ ┌─┴─╖    │    │
            │                    │               └─────┴─────┘   │ ♯ ║    │    │
            │                  ┌─┴─╖                             ╘═╤═╝    │    │
            │     ┌────────────┤ · ╟───────────────────────────────┴───┐  │    │
          ┌─┴─╖ ┌─┴─╖   ┌────╖ ╘═╤═╝ ┌──────────┐         ┌────────┐ ┌─┴─╖│    │
          │ ♭ ║ │ × ╟───┤ >> ╟───┴───┘        ┌─┴─╖       │ ┌────╖ └─┤ · ╟┴┐   │
          ╘═╤═╝ ╘═╤═╝   ╘══╤═╝          ┌─────┤ · ╟───────┴─┤ << ╟─┐ ╘═╤═╝ │   │
    ┌───────┴─────┘ ┌────╖ │            │     ╘═╤═╝         ╘══╤═╝ │   │   │   │
    │     ┌─────────┤ >> ╟─┘            │       └───────┐      │   │   │   │   │
    │     │         ╘══╤═╝            ┌─┴─╖   ╔═══╗   ┌─┴─╖ ┌┐ │   │ ┌─┴─╖ │   │
    │     │           ┌┴┐     ┌───────┤ ♫ ║ ┌─╢ 0 ║ ┌─┤ · ╟─┤├─┤   ├─┤ Ӝ ║ │   │
    │     │   ╔═══╗   └┬┘     │       ╘═╤═╝ │ ╚═╤═╝ │ ╘═╤═╝ └┘ │   │ ╘═╤═╝ │   │
    │     │   ║ 1 ╟───┬┘    ┌─┴─╖       └───┘ ┌─┴─╖ │   │      │   │   │ ┌─┴─╖ │
    │     │   ╚═══╝ ┌─┴─╖   │ ɓ ╟─────────────┤ ? ╟─┘   │    ┌─┴─╖ │   ├─┤ · ╟─┴─┐
    │     ├─────────┤ · ╟─┐ ╘═╤═╝             ╘═╤═╝   ┌─┴────┤ + ╟─┘   │ ╘═╤═╝   │
  ┌─┴─╖ ┌─┴─╖       ╘═╤═╝ │ ╔═╧═╕ ╔═══╗ ┌───╖ ┌─┴─╖ ┌─┴─╖    ╘═══╝     │   │     │
┌─┤ · ╟─┤ · ╟───┐     └┐  └─╢   ├─╢ 0 ╟─┤ ⌑ ╟─┤ ? ╟─┤ · ╟──────────────┘   │     │
│ ╘═╤═╝ ╘═╤═╝   └───┐ ┌┴┐   ╚═╤═╛ ╚═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝                  │     │
│   │   ┌─┴─╖ ┌───╖ │ └┬┘   ┌─┴─╖ ┌─┘           │     │                    │     │
│ ┌─┴───┤ · ╟─┤ Җ ╟─┘  └────┤ ? ╟─┴─┐   ┌─────────────┘                    │     │
│ │     ╘═╤═╝ ╘═╤═╝         ╘═╤═╝   │   │╔════╗╔════╗                      │     │
│ │       │  ┌──┴─╖ ┌┐   ┌┐ ┌─┴─╖ ┌─┴─╖ │║ 10 ║║ 32 ║    ┌─────────────────┘     │
│ │       │  │ << ╟─┤├─┬─┤├─┤ · ╟─┤ · ╟─┘╚══╤═╝╚╤═══╝ ┌──┴──┐                    │
│ │       │  ╘══╤═╝ └┘ │ └┘ ╘═╤═╝ ╘═╤═╝     │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖                  │
│ │     ┌─┴─╖ ┌─┴─╖  ┌─┴─╖  ┌─┴─╖ ╔═╧═╕     └─┤ ? ╟─┤ · ╟─┤ % ║                  │
│ └─────┤ · ╟─┤ · ╟──┤ Ӂ ╟──┤ ɱ ╟─╢   ├───┐   ╘═╤═╝ ╘═╤═╝ ╘═╤═╝                  │
│       ╘═╤═╝ ╘═╤═╝  ╘═╤═╝  ╘═══╝ ╚═╤═╛ ┌─┴─╖ ┌─┴─╖   │     └────────────────────┘
│         └─────┤      │            └───┤ ‼ ╟─┤ ‼ ║   │        ┌──────┐
│               │      │                ╘═══╝ ╘═╤═╝   │        │ ┌────┴────╖
│               │      │                      ┌─┴─╖   │        │ │ str→int ║
│               │      └──────────────────────┤ · ╟───┴─┐      │ ╘════╤════╝
│               │          ┌─────────╖        ╘═╤═╝     │    ╔═╧═╗ ┌──┴──┐
│               └──────────┤ int→str ╟──────────┘       │    ║   ║ │ ┌───┴───┐
│                          ╘═════════╝                  │    ╚═══╝ │ │ ┌───╖ │
└───────────────────────────────────────────────────────┘          │ └─┤ × ╟─┘
           ┌──────────────┐                                  ╔═══╗ │   ╘═╤═╝
╔════╗     │ ╓───╖ ┌───╖  │                              ┌───╢ 0 ║ │   ┌─┴─╖ ╔═══╗
║ −1 ║     └─╢ Ӝ ╟─┤ × ╟──┴──────┐                       │   ╚═╤═╝ └───┤ Ӂ ╟─╢ 0 ║
╚═╤══╝       ╙───╜ ╘═╤═╝         │                       │   ┌─┴─╖     ╘═╤═╝ ╚═══╝
┌─┴──╖ ┌┐ ┌───╖ ┌┐ ┌─┴──╖ ╔════╗ │                       │ ┌─┤   ╟───────┴───────┐
│ << ╟─┤├─┤ ÷ ╟─┤├─┤ << ║ ║ −1 ║ │                       │ │ └─┬─╜ ┌─┐ ┌─────┐   │
╘═╤══╝ └┘ ╘═╤═╝ └┘ ╘═╤══╝ ╚═╤══╝ │                       │ │   └───┴─┘ │   ┌─┴─╖ │
  │         └─┘      └──────┘    │                       │ └───────────┘ ┌─┤ ? ╟─┘
  └──────────────────────────────┘         ╓───╖         └───────────────┘ ╘═╤═╝
                               ┌───────────╢ Җ ╟────────────┐                │
      ┌────────────────────────┴───┐       ╙───╜            │
      │                          ┌─┴────────────────────┐ ┌─┴─╖
    ┌─┴─╖                      ┌─┴─╖                  ┌─┴─┤ · ╟──────────────────┐
    │ ♯ ║ ┌────────────────────┤ · ╟───────┐          │   ╘═╤═╝                  │
    ╘═╤═╝ │                    ╘═╤═╝       │          │     │              ┌───╖ │
┌─────┴───┘    ┌─────────────────┴─┐   ┌───┴───┐    ┌─┴─╖ ┌─┴─╖          ┌─┤ × ╟─┴─┐
│              │                 ┌─┴─╖ │   ┌───┴────┤ · ╟─┤ · ╟──────────┤ ╘═╤═╝   │
│              │ ┌───╖ ┌───╖  ┌──┤ · ╟─┘ ┌─┴─┐      ╘═╤═╝ ╘═╤═╝        ┌─┴─╖ │     │
│         ┌────┴─┤ ♭ ╟─┤ × ╟──┘  ╘═╤═╝   │ ┌─┴─╖ ┌───╖└┐ ┌──┴─╖      ┌─┤ · ╟─┘     │
│         │      ╘═══╝ ╘═╤═╝ ┌───╖ │     │ │ × ╟─┤ Ӝ ╟─┴─┤ ÷% ╟─┐    │ ╘═╤═╝ ┌───╖ │
│   ┌─────┴───┐     ┌────┴───┤ Ӝ ╟─┴─┐   │ ╘═╤═╝ ╘═╤═╝   ╘══╤═╝ │    │   └───┤ Ӝ ╟─┘
│ ┌─┴─╖ ┌───╖ │     │ ┌────╖ ╘═╤═╝   │   └───┘   ┌─┴─╖      │   │    └────┐  ╘═╤═╝
│ │ × ╟─┤ Ӝ ╟─┘     └─┤ << ╟───┘   ┌─┴─╖ ┌───────┤ · ╟───┐  │ ┌─┴─╖ ┌───╖ │    │
│ ╘═╤═╝ ╘═╤═╝         ╘══╤═╝   ┌───┤ + ║ │       ╘═╤═╝   ├──┴─┤ · ╟─┤ × ╟─┘    │
└───┤     └────┐ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ╔═══╗ ┌─┴─╖ ┌─┴─╖  ╘═╤═╝ ╘═╤═╝      │
  ┌─┴─╖ ┌────╖ │ ║ 0 ╟─┤ ? ╟─┤ = ║  ┌┴┐  │ ║ 0 ╟─┤ ? ╟─┤ = ║    │     │ ┌────╖ │
  │ × ╟─┤ << ╟─┘ ╚═══╝ ╘═╤═╝ ╘═╤═╝  └┬┘  │ ╚═══╝ ╘═╤═╝ ╘═╤═╝    │     └─┤ << ╟─┘
  ╘═╤═╝ ╘═╤══╝ ┌┐     ┌┐ │     │     └───┘       ┌─┴─╖   ├──────┘       ╘═╤══╝
    │     └────┤├──┬──┤├─┘     ├─────────────────┤ · ╟───┘                │
    │          └┘┌─┴─╖└┘       │     ┌┐   ┌┐     ╘═╤═╝ ┌┐   ┌┐            │
    └────────────┤ · ╟─────────┘   ┌─┤├─┬─┤├─┐     └───┤├─┬─┤├────────────┘
                 ╘═╤═╝             │ └┘ │ └┘ │         └┘ │ └┘
                   └───────────────┘    │    └────────────┘

প্রথম সংস্করণ ব্যাখ্যা

প্রথম সংস্করণটি এন = 7 সমাধান করতে প্রায় এক ঘন্টা সময় নিয়েছিল নীচে বেশিরভাগ ব্যাখ্যা করে যে এই ধীর সংস্করণটি কীভাবে কাজ করেছে। এটি নীচে 10 মিনিটের নিচে নিয়ে যাওয়ার জন্য আমি কী পরিবর্তন করেছি তা আমি নীচে ব্যাখ্যা করব।

বিট মধ্যে একটি ভ্রমণ

এই প্রোগ্রামের বিট প্রয়োজন। এর জন্য প্রচুর পরিমাণে বিট প্রয়োজন এবং এটি সমস্ত সঠিক জায়গায় প্রয়োজন। অভিজ্ঞ ফানসিটন প্রোগ্রামাররা ইতিমধ্যে জানেন যে আপনার যদি এন বিটের প্রয়োজন হয় তবে আপনি সূত্রটি ব্যবহার করতে পারেন

যা ফানসিটনে প্রকাশিত হতে পারে

আমার পারফরম্যান্স অপটিমাইজেশন করার সময়, আমার কাছে ঘটেছিল যে আমি এই সূত্রটি ব্যবহার করে একই মানটি খুব দ্রুত গণনা করতে পারি:

আমি আশা করি আপনি আমাকে ক্ষমা করবেন যে আমি এই পোস্টে সেই অনুযায়ী সমস্ত সমীকরণ গ্রাফিক্স আপডেট করি নি।

এখন, ধরা যাক আপনি বিটের একটি সংকীর্ণ ব্লক চান না; আসলে, যদি আপনি চান এন নিয়মিত সময় অন্তর প্রত্যেক এ বিট ট -th বিট মত তাই হয়:

                                 LSB
                                  ↓
00000010000001000000100000010000001
                            └──┬──┘
                               k

আপনি এটি জানার পরে এর সূত্রটি মোটামুটি সোজা-এগিয়ে রয়েছে:

কোডে, ফাংশনটি n এবং k এরӜ মান নেয় এবং এই সূত্রটি গণনা করে।

ব্যবহৃত সংখ্যা ট্র্যাক করা

আছে এন চূড়ান্ত গ্রিড ² এর সংখ্যা, এবং প্রতিটি সংখ্যা কোনো হতে পারে এন সম্ভাব্য মান। প্রতিটি ঘরে কোন সংখ্যার অনুমতি রয়েছে তা ট্র্যাক করার জন্য, আমরা n ³ বিট সমন্বিত একটি সংখ্যা বজায় রাখি, যাতে একটি নির্দিষ্ট মান নেওয়া হয়েছে তা নির্দেশ করার জন্য কিছুটা সেট করা থাকে। প্রাথমিকভাবে এই সংখ্যাটি 0, স্পষ্টতই।

অ্যালগরিদম নীচে ডান কোণে শুরু হয়। "অনুমান" করার পরে প্রথম সংখ্যাটি 0 হয়, আমাদের এই সত্যটি ট্র্যাক করে রাখতে হবে যে 0 একই কোষে একই সারি, কলাম এবং তির্যক বরাবর অনুমোদিত নয়:

LSB                               (example n=5)
 ↓
 10000 00000 00000 00000 10000
 00000 10000 00000 00000 10000
 00000 00000 10000 00000 10000
 00000 00000 00000 10000 10000
 10000 10000 10000 10000 10000
                             ↑
                            MSB

এই লক্ষ্যে, আমরা নিম্নলিখিত চারটি মান গণনা করি:

• বর্তমান সারি: আমাদের প্রতি n- তম বিট (প্রতি সেল প্রতি এক) n বিট প্রয়োজন , এবং তারপরে এটিকে বর্তমান সারি আর-এ স্থানান্তর করুন , প্রতিটি সারি মনে রাখে n ² বিট রয়েছে :

  

• বর্তমান কলাম: আমাদের প্রতিটি এন th-th বিট (প্রতি সারি প্রতি একটি) n বিট দরকার , এবং তারপরে এটি বর্তমান কলামে সি-এ স্থানান্তর করুন , প্রতিটি কলামে এন বিট রয়েছে মনে করে :

  

• ফরোয়ার্ড ডায়াগোনাল: আমাদের প্রতিটি এন বিট দরকার ... (আপনি কি মনোযোগ দিয়েছিলেন? তাড়াতাড়ি, এটি বের করে ফেলুন!) ... এন ( এন +1) -বিট (ভাল হয়েছে!) তবে কেবল যদি আমরা আসলেই থাকি এগিয়ে তির্যক:

  

• পিছনের তির্যক: এখানে দুটি জিনিস। প্রথমত, আমরা কীভাবে জানব যে আমরা পিছনের তির্যকটিতে আছি? গাণিতিকভাবে, অবস্থাটি সি = ( এন - 1) - আর , যা সি = এন + (- আর - 1) এর সমান । আরে, এটা কি আপনাকে কিছু মনে করিয়ে দেয়? এটি ঠিক, এটি দুটির পরিপূরক, সুতরাং হ্রাসের পরিবর্তে আমরা বিটওয়াইজ নেগেশন (ফানসিটনে খুব দক্ষ) ব্যবহার করতে পারি। দ্বিতীয়ত, উপরের সূত্রটি ধরে নিয়েছে যে আমরা কমপক্ষে তাত্পর্যপূর্ণ বিট সেট করতে চাই, তবে পশ্চাদপথ ত্রিভুজের মধ্যে আমরা তা করি না, তাই আমাদের এটিকে স্থানান্তরিত করতে হবে ... জানেন কি? ... ঠিক আছে, এন ( এন - 1)।

  

  এটিই কেবলমাত্র একটি যেখানে আমরা সম্ভাব্যভাবে 0 দ্বারা n = 1 বিভক্ত করি তবে ফানসিটনের কোনও যত্ন নেই। 0 ÷ 0 কেবল 0, আপনি জানেন না?

কোডে, ফাংশনটি Җ(নীচের অংশে) n এবং একটি সূচক নেয় (যা থেকে এটি বিভাজন এবং বাকী দ্বারা r এবং c গণনা করে), এই চারটি মান গণনা করে এবং orসেগুলি একসাথে s করে।

ব্রুট ফোর্স অ্যালগরিদম

ব্রুট-ফোর্স অ্যালগরিদম Ӂ(শীর্ষে ফাংশন) দ্বারা প্রয়োগ করা হয় । এটি এন (গ্রিডের আকার), সূচক (যেখানে গ্রিডে আমরা বর্তমানে একটি সংখ্যা রাখছি ) লাগে , এবং নেওয়া হয় ( n ³ বিট সহ সংখ্যাটি আমাদের জানায় যে আমরা প্রতিটি ঘরে এখনও কোন সংখ্যা রাখতে পারি)।

এই ফাংশনটি স্ট্রিংয়ের ক্রম দেয় returns প্রতিটি স্ট্রিং গ্রিডের একটি সম্পূর্ণ সমাধান। এটি সম্পূর্ণ সমাধানকারী; আপনি যদি এটি ছেড়ে দেন তবে এটি সমস্ত সমাধান ফিরিয়ে দেবে, তবে এটি তাদের অলস-মূল্যায়িত ক্রম হিসাবে ফিরিয়ে দেয়।

• যদি সূচক 0-এ পৌঁছে যায়, আমরা সফলভাবে পুরো গ্রিডটি পূরণ করেছি, তাই আমরা খালি স্ট্রিং (কোনও একক সমাধান যা কোনও কক্ষকে আচ্ছাদন করে না) যুক্ত একটি ক্রম ফিরিয়ে দিয়েছি। খালি স্ট্রিংটি হ'ল 0এবং আমরা লাইব্রেরির ফাংশনটি এটিকে ⌑একটি একক-উপাদান ক্রমিকায় পরিণত করতে ব্যবহার করি ।

• নীচে কর্মক্ষমতা উন্নতির অধীনে বর্ণিত চেকটি এখানে ঘটে।

• যদি সূচকটি এখনও 0-এ পৌঁছায় না, আমরা এখন সূচকটি পেতে 1 হ্রাস করেছিলাম যেখানে আমাদের এখন একটি নম্বর রাখতে হবে (কল করুন যে ix )।

  আমরা ♫0 থেকে n - 1 পর্যন্ত মানগুলি সহ অলস ক্রম উত্পন্ন করতে ব্যবহার করি ।

  তারপরে আমরা ɓএকটি ল্যাম্বডা (মোনাডিক বাইন্ড) ব্যবহার করি যা নিম্নলিখিতগুলি যথাযথভাবে করে:

  • প্রাসঙ্গিক বিট প্রথমেই দেখ নেয়া সিদ্ধান্ত নিতে সংখ্যা এখানে বা বৈধ নয় কিনা। আমরা একটি সংখ্যা স্থাপন করতে পারেন আমি যদি এবং কেবল যদি নিয়ে যাওয়া & (1 << ( এন × IX ) << আমি ) ইতিমধ্যে সেট করা নেই। যদি এটি সেট করা থাকে, ফিরে 0(ফাঁকা ক্রম)
  • Җবর্তমান সারি, কলাম এবং তির্যক (গুলি) এর সাথে সম্পর্কিত বিট গণনা করতে ব্যবহার করুন । এটি আমি দ্বারা শিফট করুন এবং তারপরে orএটি নেওয়া হবে ।
  • Ӂঅবশিষ্ট কোষগুলির জন্য সমস্ত সমাধান পুনরুদ্ধার করতে পুনরায় কল করুন , এটি নতুন নেওয়া এবং হ্রাস ix পেরিয়ে । এটি অসম্পূর্ণ স্ট্রিংগুলির একটি ক্রম দেয়; প্রতিটি স্ট্রিংয়ের ix অক্ষর রয়েছে (গ্রিডটি সূচী ix পর্যন্ত পূর্ণ )।
  • ɱএইভাবে পাওয়া সমাধানগুলিতে যেতে ম্যাপ (মানচিত্র) ব্যবহার করুন এবং প্রতিটিটির শেষে আমি সম্মতি ‼জানাতে ব্যবহার করুন । সূচকটি এন এর একাধিক হলে একটি নতুন লাইন যুক্ত করুন , অন্যথায় একটি স্থান।

ফলাফল তৈরি হচ্ছে

প্রধান প্রোগ্রাম কল করে Ӂ(ব্রুট ফরসার) এন , ইনডেক্স = এন with (মনে রাখবেন আমরা গ্রিডটি পিছনের দিকে পূরণ করেছি) এবং নেওয়া = 0 (প্রাথমিকভাবে কিছুই নেওয়া হয় না)। যদি এর ফলাফলটি খালি অনুক্রম হয় (কোনও সমাধান পাওয়া যায় নি), খালি স্ট্রিংটিকে আউটপুট করুন। অন্যথায়, অনুক্রমের প্রথম স্ট্রিং আউটপুট। দ্রষ্টব্য যে এর অর্থ এটি ক্রমের কেবলমাত্র প্রথম উপাদানটি মূল্যায়ন করবে, যার কারণেই সমাধানটি সমস্ত সমাধান না পাওয়া পর্যন্ত সমাধান চালিয়ে যায় না।

কর্মক্ষমতা বৃদ্ধি

(যারা ইতিমধ্যে ব্যাখ্যাটির পুরাতন সংস্করণটি পড়েছেন তাদের জন্য: প্রোগ্রামটি আর ক্রমের ক্রম তৈরি করে না যা আলাদাভাবে আউটপুটের জন্য একটি স্ট্রিংয়ে রূপান্তরিত করা দরকার; এটি কেবল স্ট্রিংগুলির একটি ক্রম সরাসরি তৈরি করে I've আমি সেই অনুসারে ব্যাখ্যাটি সম্পাদনা করেছি I've । তবে এটি মূল উন্নতি ছিল না Here এটি এখানে আসে))

আমার মেশিনে, প্রথম সংস্করণের সংকলিত এক্সটি এন = 7 সমাধান করতে ঠিক 1 ঘন্টা সময় নিয়েছিল এটি 10 ​​মিনিটের প্রদত্ত সময়সীমার মধ্যে ছিল না, তাই আমি বিশ্রাম নিই নি। (ভাল, আসলে, আমি বিশ্রাম না করার কারণটি ছিল যে কীভাবে এটির গতি বাড়ানো যায় সে সম্পর্কে আমার এই ধারণা ছিল।)

উপরে বর্ণিত অ্যালগরিদমটি তার অনুসন্ধানটি থামিয়ে দেয় এবং প্রতিবার ব্যাকট্র্যাক হয় যে এটি এমন একটি ঘরের সাথে মুখোমুখি হয় যেখানে নেওয়া সংখ্যার সমস্ত বিট সেট করা থাকে যা ইঙ্গিত করে যে এই কক্ষে কিছুই রাখা যাবে না।

যাইহোক, অ্যালগরিদম অব্যাহত থাকবে futilely গ্রিড পূরণ করতে পর্যন্ত সেল যা ঐ সমস্ত বিট সেট করা হয়। এটি আরও দ্রুত হবে যদি এটি ইতিমধ্যে যে কোনও এখনও পূরণযোগ্য-পূর্ণ ঘরটিতে ইতিমধ্যে সমস্ত বিটস সেট থাকে, যা ইতিমধ্যে ইঙ্গিত দেয় যে আমরা যত নম্বরই রাখি না কেন বাকি গ্রিডটি আমরা কখনই সমাধান করতে পারি না much এটা। তবে আপনি কীভাবে কোনও দক্ষতার সাথে পরীক্ষা করতে পারেন যে কোনও কোষের সমস্ত এনটাইটেল ব্যতীত তার এন বিট সেট আছে কিনা ?

কৌশলটি নেওয়া সংখ্যায় ঘরে প্রতি একক বিট যোগ করে শুরু হয় । উপরে যা দেখানো হয়েছিল তার পরিবর্তে এখন এটি দেখতে দেখতে এটি:

LSB                               (example n=5)
 ↓
 10000 0 00000 0 00000 0 00000 0 10000 0
 00000 0 10000 0 00000 0 00000 0 10000 0
 00000 0 00000 0 10000 0 00000 0 10000 0
 00000 0 00000 0 00000 0 10000 0 10000 0
 10000 0 10000 0 10000 0 10000 0 10000 0
                                       ↑
                                      MSB

N Instead এর পরিবর্তে, এখন এই সংখ্যায় n ² ( n + 1) বিট রয়েছে। বর্তমান সারি / কলাম / তির্যককে জনপ্রিয় করে ফাংশনটি সেই অনুযায়ী পরিবর্তন করা হয়েছে (আসলে, সৎ হওয়ার জন্য সম্পূর্ণ পুনরায় লেখা)। এই ফাংশনটি এখনও প্রতি সেল কেবলমাত্র n বিটগুলি তৈরি করবে , সুতরাং আমরা কেবল অতিরিক্ত অতিরিক্ত বিট যোগ করব 0।

এখন, ধরা যাক আমরা গণনার অর্ধেক পথ পেরিয়ে এসেছি, আমরা সবেমাত্র একটি 1মাঝারি কক্ষে রেখেছি, এবং নেওয়া নম্বরটি দেখতে এরকম কিছু দেখাচ্ছে:

                 current
LSB              column           (example n=5)
 ↓                 ↓
 11111 0 10010 0 01101 0 11100 0 11101 0
 00011 0 11110 0 01101 0 11101 0 11100 0
 11111 0 11110 0[11101 0]11100 0 11100 0    ← current row
 11111 0 11111 0 11111 0 11111 0 11111 0
 11111 0 11111 0 11111 0 11111 0 11111 0
                                       ↑
                                      MSB

আপনি দেখতে পাচ্ছেন, উপরের-বাম ঘর (সূচক 0) এবং মাঝের-বাম ঘর (সূচি 10) এখন অসম্ভব। আমরা কীভাবে সর্বাধিক দক্ষতার সাথে এটি নির্ধারণ করব?

এমন একটি সংখ্যা বিবেচনা করুন যাতে প্রতিটি ঘরের 0 তম বিট সেট করা থাকে তবে কেবল বর্তমান সূচী পর্যন্ত। পরিচিত সূত্রটি ব্যবহার করে এই জাতীয় সংখ্যা গণনা করা সহজ:

আমরা যদি এই দুটি সংখ্যা একসাথে যুক্ত করি তবে আমরা কী পেতে পারি?

LSB                                               LSB
 ↓                                                 ↓
 11111 0 10010 0 01101 0 11100 0 11101 0           10000 0 10000 0 10000 0 10000 0 10000 0        ╓───╖
 00011 0 11110 0 01101 0 11101 0 11100 0     ║     10000 0 10000 0 10000 0 10000 0 10000 0            ║
 11111 0 11110 0 11101 0 11100 0 11100 0  ═══╬═══  10000 0 10000 0 00000 0 00000 0 00000 0  ═════   ╓─╜
 11111 0 11111 0 11111 0 11111 0 11111 0     ║     00000 0 00000 0 00000 0 00000 0 00000 0  ═════   ╨
 11111 0 11111 0 11111 0 11111 0 11111 0           00000 0 00000 0 00000 0 00000 0 00000 0          o
                                       ↑                                                 ↑
                                      MSB                                               MSB

ফলাফল হলো:

             OMG
              ↓
        00000[1]01010 0 11101 0 00010 0 00011 0
        10011 0 00001 0 11101 0 00011 0 00010 0
═════   00000[1]00001 0 00011 0 11100 0 11100 0
═════   11111 0 11111 0 11111 0 11111 0 11111 0
        11111 0 11111 0 11111 0 11111 0 11111 0

আপনি দেখতে পাচ্ছেন যে অতিরিক্ত যোগ হয়েছে আমাদের অতিরিক্ত সংযোজন যা অতিরিক্ত যুক্ত হয়েছে, তবে কেবলমাত্র সেই ঘরের জন্য সমস্ত বিট সেট করা থাকলে! অতএব, যা করার বাকি তা হ'ল those বিটগুলি (উপরের মতো একই সূত্র, তবে << এন ) মাস্ক করা এবং ফলাফলটি 0:

00000[1]01010 0 11101 0 00010 0 00011 0    ╓╖    00000 1 00000 1 00000 1 00000 1 00000 1         ╓─╖ ╓───╖
10011 0 00001 0 11101 0 00011 0 00010 0   ╓╜╙╖   00000 1 00000 1 00000 1 00000 1 00000 1        ╓╜ ╙╖    ║
00000[1]00001 0 00011 0 11100 0 11100 0   ╙╥╥╜   00000 1 00000 1 00000 0 00000 0 00000 0  ═════ ║   ║  ╓─╜
11111 0 11111 0 11111 0 11111 0 11111 0   ╓╜╙╥╜  00000 0 00000 0 00000 0 00000 0 00000 0  ═════ ╙╖ ╓╜  ╨
11111 0 11111 0 11111 0 11111 0 11111 0   ╙──╨─  00000 0 00000 0 00000 0 00000 0 00000 0         ╙─╜   o

যদি এটি শূন্য না হয় তবে গ্রিডটি অসম্ভব এবং আমরা থামতে পারি।

• এন = 4 থেকে 7 এরসমাধান এবং চলমান সময় দেখায় স্ক্রিনশট ।

Comments

পবিত্র FUCK। বাবু, এটা চিত্তাকর্ষক।

— দেউসোভি

আমি দেউসোভির মন্তব্যে দ্বিতীয়বার, এই বিষয়ে এত প্রচেষ্টা করার জন্য আপনাকে ধন্যবাদ

— হরগাসিনস্কি

Answer 3

হাস্কেল, 790 * 0.80 = 632 বাইট

import Data.List
import Control.Monad
import Data.Array
s r=let{h as bs=[(a,b)|a<-as,b<-bs];(&)m k=(\(Just x)->x)$lookup k m;j=Just;n=Nothing;c=[1..r];q=delete;u=h[1..r]c;o=[(s,[u |u<-[h[1..r][c]|c<-c]++[h[r]c|r<-[1..r]]++[zip[1..r][1..r],zip[1..r][r,r-1..1]],s`elem`u])|s<-u];k=foldr(>=>)j;a p d g0=k[t p d2|d2<-q d(g0!p)]g0;t p d g0|not(d`elem`(g0!p))=j g0|[]<-v=n|[d2]<-v=k[t s2 d2|s2<-[(s,delete s$nub(concat(o&s)))|s<-u]&p]g1|True=k[l[s|s<-u,not(d`elem`v)]|u<-o&p]g1 where{v=q d(g0!p);g1=g0//[(p,v)];l[]_=n;l[d3]g=a d3 d g;l _ r=j r};w g0|and[case g0!s of{[_]->True;_->False}|s<-u]=j g0|True=msum[a s' d g0>>=w|d<-g0!s']where(_,s')=minimumBy(\(a,_)(b,_)->compare a b)[(l,s)|s<-u,let v=g0!s;l=length v,l>1]}in fmap(fmap(\[x]->x))$w$array((1,1),(r,r))[((i,j),[1..r])|i<-[1..r],j<-[1..r]]

আমি লক্ষ করেছি এই সমস্যাটি সুডোকুর সাথে খুব মিল। আমি পাইথনের এই অন্যটির উপর ভিত্তি করে হাস্কেল-এ লিখেছিলাম এমন একটি পুরানো সুডোকু সলভার মনে আছে । এটি আমার প্রথম কোড গল্ফ পোস্ট বা প্রচেষ্টা।

কারণ এটি ফেরৎ এই বোনাস পরিপূর্ণ Nothingজন্য n=2,3এবং Just <result>জন্য n>=4, যেখানে <result>অবিচ্ছেদ্য মূল্যবোধের 2D অ্যারে।

অনলাইন দোভাষী জন্য এখানে দেখুন । সেই কোডটি পোস্টের একটির তুলনায় প্রকৃতপক্ষে দীর্ঘতর কারণ একটি সম্পূর্ণ প্রোগ্রাম কী রূপায়িত হয় সে সম্পর্কে অনলাইন দোভাষীর আরও কঠোর প্রয়োজনীয়তা রয়েছে (নিয়ম অনুসারে একটি জমা দেওয়া কোনও ফাংশন হতে পারে)। এই জমাটি একটি ফাংশন আর্গুমেন্ট হিসাবে ইনপুট নেয়।

Comments

কয়েকটি দ্রুত টিপস: ক) আপনি সংজ্ঞায়িত করেন c=[1..r], যাতে আপনি এটি oএবং এর মধ্যে ব্যবহার করতে পারেন w। খ) minimumBy(\(a,_)(b,_)->compare a b)[...]হয় head$sortOn fst[...]। গ) vমধ্যে v=g0!sশুধুমাত্র একবার ব্যবহার করা হয়, তাই সব এটা সংজ্ঞায়িত না: l=length$g0!s। d) আপনার এখনও দুটি অক্ষরের প্যারামিটারের নাম রয়েছে। e) Trueসাথে 1<2এবং Falseসাথে প্রতিস্থাপন 2<1। চ) and[case g0!s of{[_]->True;_->False}|s<-u]হয় all((==1).length.(g0!))u।

— নিমি

কুইক টিপস, পার্ট II: ছ) (&)m k=সংজ্ঞায়িত করা যায় পোতা: m&k=। জ) not(dএলেম (g0!p))হয় notElem d$g0!p। i) concat(...)হয় id=<<(...)। জ) hযেমন একটি ইনফিক্স অপারেটর ব্যবহার করুন as%bs=।

— নিমি

দ্রুত মেটা টিপস: আপনি ডাবল ব্যাকটিক্স ব্যবহার করে সঠিকভাবে ব্যাকটিক্সযুক্ত কোডটি সীমিত করতে পারেন ​``like`this``​!

— লিন

Answer 4

পাইথ, 41 বাইট

#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K

#                                      ;   # while(True)
 Km.SQQ                                    # K = random QxQ 2d list
       I                               ;   # if ...
        .A                                 # all of...
          m                          Q     # map(range(Q))...
                +                          # concat
                 .TK                       # transpose K
                    .Tm,@@Kdd@@Kt-Qdd      # diagonals of K
                      m             d      # map(range(d))
                       ,                   # 2-elem list of...
                        @@Kdd              # K[n][n]
                             @@Kt-Qd       # and K[len(K)-n-1][n]
                    .T                     # transpose
           qQl{d                           # subarrays have no dups...
                                      B;   # ... then, break
                                        K  # output final result

বর্বর বাহিনী এফটিডব্লিউ!

যেহেতু এটি মূলত এটি কাজ না করা অবধি র্যান্ডম শ্যাফেলগুলি চেষ্টা করে চলেছে (ভাল, এটি চেষ্টা চালিয়ে যায় n * [shuffle(range(n))]), এটি সত্যই, সত্যই দীর্ঘ সময় নেয়। এটি কতটা সময় নেয় তার ধারণা দেওয়ার জন্য এখানে কয়েকটি পরীক্ষার রান রয়েছে:

llama@llama:~$ time echo 4 | pyth <(echo '#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K')               
[[2, 1, 0, 3], [0, 3, 2, 1], [3, 0, 1, 2], [1, 2, 3, 0]]
echo 4  0.00s user 0.00s system 0% cpu 0.001 total
pyth <(echo '#Km.SQQI.AmqQl{d+.TK.Tm,@@Kdd@@Kt-QddQB;K')  0.38s user 0.00s system 96% cpu 0.397 total

এটি কেবল 4x4, এবং এটি অর্ধেক সেকেন্ডের নীচে চলে। আমি আসলে প্রতারণা করছি কারণ কয়েকটি পরীক্ষার মধ্যে এটিই সেরা them তাদের বেশিরভাগই এক বা দু'বার সময় নেয়।

আমার এখনও 5x5 তে টাইমিং পাওয়া যায় নি (এটি একবারে শেষ হয়ে যায়, তবে এটি একটি আরপিএল ছিল এবং আমি এটির সময় নিচ্ছিলাম না)।

নোট করুন যে সময়সীমাটির বিধি এই উত্তর পোস্ট হওয়ার পরে কেবল প্রশ্নের মধ্যেই সম্পাদিত হয়েছিল।

Comments

আমি মনে করি এটি দশ মিনিটের মধ্যে 7x7 করতে পারে না? ^^

— লিন

@ মরিস ভাল, কখনও কখনও এটি করতে পারে ...;) এটি কি আমার প্রয়োজনের হাতছাড়া হয়ে গেছে ? আমি প্রশ্নের সময়সীমা উল্লেখ করার মতো কিছুই দেখতে পাচ্ছি না।

— ডোরকনব্ব

আমি এটি মন্তব্যগুলিতে দেখছি ( 12 ঘন্টা আগে নতুন মন্তব্য নয় )

— edc65

এর জন্য দুঃখিত, কেউ এটি উল্লেখ না করা পর্যন্ত আমি এটি ভাবিনি, আমি এখনই চ্যালেঞ্জটি সম্পাদনা করব

— hargasinski

আপনার মন্তব্য করা সংস্করণটিতে বিমূর্ত ASCII শিল্পের জন্য +1। :)

— ইলমারি করোনেন

Answer 5

এসডাব্লুআই-প্রোলোগ, 326 * 0.80 = 260.8 বাইট

:-use_module(library(clpfd)).
a(N):-l(N,R),m(l(N),R),append(R,V),V ins 1..N,transpose(R,C),d(0,R,D),maplist(reverse,R,S),d(0,S,E),m(m(all_distinct),[R,C,[D,E]]),m(label,R),m(p,R).
l(L,M):-length(M,L).
d(X,[H|R],[A|Z]):-nth0(X,H,A),Y is X+1,(R=[],Z=R;d(Y,R,Z)).
p([H|T]):-write(H),T=[],nl;write(' '),p(T).
m(A,B):-maplist(A,B).

সম্পাদনা: @ ম্যাটকে ধন্যবাদ 16 টি বাইট

ব্যবহার

a(5).আপনার দোভাষী জন্য কল করুন N=5। এটির falseজন্য N=2বা ফিরে আসে N=3।

যেহেতু এটি সিএলপিএফডি লাইব্রেরি ব্যবহার করে এটি খাঁটি ব্রুটফোর্স নয়। এই প্রোগ্রামটি N=20আমার কম্পিউটারে প্রায় 15 সেকেন্ডের মধ্যে একটি সমাধান খুঁজে পেতে পারে ।

অবহেলিত + ব্যাখ্যা:

এটি মূলত সুডোকু সলভারের মতো কাজ করে, ব্লক সীমাবদ্ধতাগুলি ত্রিভুজ সীমাবদ্ধতার সাথে প্রতিস্থাপন করা হয়।

:-use_module(library(clpfd)).      % Import Constraints library

a(N):-
    l(N,R),                        % R is a list of length N
    maplist(l(N),R),               % R contains sublists, each of length N
    append(R,V),                   
    V ins 1..N,                    % Each value in the matrix is between 1 and N
    maplist(all_distinct,R),       % Values must be different on each row
    transpose(R,C),
    maplist(all_distinct,C),       % Values must be different on each column
    d(0,R,D),
    maplist(reverse,R,S),          
    d(0,S,E),
    all_distinct(D),               % Values must be different on the diagonal
    all_distinct(E),               % Values must be different on the "anti"-diagonal
    maplist(label,R),              % Affects actual values to each element
    maplist(p,R).                  % Prints each row

l(L,M):-length(M,L).               % True if L is the length of M

d(X,[H|R],[A|Z]):-nth0(X,H,A),Y is X+1,(R=[],Z=R;d(Y,R,Z)). % True if the third argument is the diagonal of the second argument

p([H|T]):-write(H),T=[],nl;write(' '),p(T).  % Prints a row separated by spaces and followed by a new line

Comments

খুব সুন্দর! আপনি এতে বাইট সংরক্ষণ করতে পারেন:maplist(maplist(all_distinct), [R,C,D,E])

— মাদুর

@ ম্যাট পরামর্শের জন্য ধন্যবাদ, 16 বাইট সংরক্ষণ করে। আমি [R,C,[D,E]]যদিও ব্যবহার করা প্রয়োজন , কারণ Eএবং Dসহজ তালিকা।

— ফ্যাটালাইজ করুন

ঠিক আছে, খুব সুন্দর কাজ!

— মাদুর

@ ফ্যাটালাইজ কেবল আপনাকে জানাতে, আপনার সমাধানটি সবচেয়ে চিত্তাকর্ষক ছিল কারণ এটি কেবল সমাধান করা যায়N=20

— হরগ্যাসিনস্কি

@ জেকু ধন্যবাদ! তবে এটি বেশিরভাগই প্রোলোগের আশ্চর্যজনক সিএলপিএফডি লাইব্রেরির কারণে, যা এই জাতীয় সমস্যাগুলিতে ভারী

— উত্থাপন করে

Answer 6

সিজেম, 87 বাইট - 20% বোনাস = 69.6 বাইট

qi__"@I/l
ŤˏūȻ
܀ᅀ൹৽჈͚
㑢鴑慚菥洠㬝᚜
"N/=:i0+\,m!f=`1LL](4e<=

উত্তরগুলি হার্ডকোডগুলি। কিছু অপ্রিন্টেবল রয়েছে। N = 1মাধ্যমে কাজ করে N = 8।

মূলত, সেই রহস্যময় স্ট্রিংয়ের প্রতিটি লাইনে range(N)ইউনিকোড অক্ষর হিসাবে এনকোডযুক্ত ক্রমের অনুমতিগুলির তালিকাতে সূচক থাকে ।

=:i0+\,m!f=প্রথমে নীচের সারিটি উপস্থাপন করে সূচকগুলির তালিকার শেষে একটি 0 যুক্ত করে ক্রমশক্তির তালিকায় সূচকগুলি 0 1 2 ... N-1। কারণ N < 4, ফলাফল 2D অ্যারে বাজে।

`1LL]একটি তালিকা তৈরি করে [N, pretty output, 1, "", ""]। তারপরে, (4e<=এই তালিকাটি থেকে প্রথম উপাদানটি পপ করে N, এবং min(N, 4) % 4বাকি অংশ থেকে এটি পুনরুদ্ধার করে । কারণ N >= 4, এটি আউটপুট এবং অন্যথায় এটি প্রথম তিনটি ক্ষেত্রে বিশেষ ক্ষেত্রে আউটপুট।

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

Answer 7

সি ++, 672 * 0.80 645 * 0.80 = 516 বাইট

#include <iostream>
int **b,**x,**y,*d,*a,n;
#define R(i) for(i=0;i<n;i++){
#define E(e) e=new int[n];
int f(int c,int r) {int i=0,p=c-1;if(r>=n)return 1;if(c == n + 1)return f(1,r+1);R(i)int m=r==i,s=r+i==n-1;if(!b[r][i]&&!x[r][p]&&!(m&&d[p])&&!(s&&a[p])&&!y[i][p]){b[r][i]=c;x[r][p]=1;y[i][p]=1;if(m)d[p]=1;if(s)a[p]=1;if(f(c+1,r))return 1;b[r][i]=0;x[r][p]=0;y[i][p]=0;if(m)d[p]=0;if(s)a[p]=0;}}return 0;}
int main(){std::cin>>n;int i=0,j=0;b=new int*[n];x=new int*[n];y=new int*[n];E(d);E(a);R(i)E(b[i]);E(x[i]);E(y[i]); d[i]=0;a[i]=0;R(j)b[i][j]=0;x[i][j]=0;y[i][j]=0;}}if(f(1,0)){R(i)R(j)std::cout<<b[i][j];}std::cout<<std::endl;}}}

এটি এখানে অনলাইনে চেষ্টা করুন

যেহেতু দু'একটি উত্তর ইতিমধ্যে পোস্ট করা হয়েছে, তাই আমি ভেবেছিলাম যে উদাহরণগুলির জন্য আউটপুট উত্পন্ন করার জন্য আমি কোডটির গল্ফ সংস্করণটি পোস্ট করব। কোনও কোড-গল্ফের উত্তর দেওয়ার এটি আমার প্রথমবার , তাই সমস্ত প্রতিক্রিয়া স্বাগত। :)

অবহেলিত + ব্যাখ্যা:

মূলত, কোডটি সমাধানটিকে জোর করে চাপিয়ে দিচ্ছে। এটি 0 দিয়ে প্রথম সারিতে শুরু হয়, এটি প্রথম স্পট থেকে শুরু হয়, যদি সেই দাগগুলি সমস্ত চেক পাস করে তবে এটি পরবর্তী সংখ্যায় চলে যায়। যদি এটি সারিটি পূরণ করে তবে এটি পরবর্তী সারিতে চলে যায়। যদি এটি সারিগুলির সমস্ত হয়ে যায় তবে এর অর্থ একটি সমাধান পাওয়া গেছে। স্পটটি যদি সমস্ত চেক পাস না করে তবে এটি পরবর্তী স্পটে চলে যায়। যদি এটি সারিটি সম্পন্ন হয়, তবে এটি পূর্ববর্তী সারির একটিতে সংখ্যা হিসাবে সমাধানকে সম্ভব হওয়া থেকে বিরত হিসাবে ব্যাকট্র্যাক করে।

#include <iostream>

// global variables to save bytes on passing these are function arguments
int **b, // this will store the state of the board
    **x, // if x[i][j] is true, row i of b contains the number j
    **y, // if y[i][j] is true, column i of b contains the number j
    *d,  // if d[i] the main diagonal of b contains i
    *a,  // if a[i] the antidiagonal of a contains i
    n;

// preprocessor to save bytes on repeated statements
#define R(i) for(i=0;i<n;i++){
#define E(e) e=new int[n];

// Recursively looks for a solution 
// c - the current number to insert in row r
// r - the current row to fill
int f (int c, int r) {
        int i=0,p=c-1;
        if (r >= n) return 1;             // we are done
        if (c == n + 1) return f(1,r+1);  // this row is full, move to the next row
        R(i)                              // go through the positions in this row,
                                                                            // trying to fill them with c
                int m=r==i, s=r+i==n-1;   // check if this position (r,i) is on ones
                                                                            // of the diagonals
                // if this spot isn't filled, and the row (r), column (i) and diagonals
                // (if it's on the diagonal) doesn't contain the number, fill the spot
                if (!b[r][i] && !x[r][p] && !(m&&d[p]) && !(s&&a[p]) && !y[i][p]) {
                        // fill the spot, and indicate that this row, column and diagonals 
                        // contain this number, c
                        b[r][i]=c; x[r][p]=1; y[i][p]=1;
                        if (m) d[p]=1; if (s)a[p]=1;

                        // move onto to the next number, if you find a solution, stop
                        if (f(c+1,r)) return 1;

                        // with this number in this spot, a solution is impossible, clear
                        // its, and clear the checks
                        b[r][i]=0; x[r][p]=0; y[i][p]=0;
                        if (m) d[p]=0; if (s) a[p]=0;
                }
        }

        return 0; // a solution wasn't found
}

int main() {
        std::cin >> n; // get n from STDIN

        // initialization 
        int i=0,j=0;
        b=new int*[n]; x=new int*[n]; y=new int*[n];
        E(d); E(a);
        R(i)
                E(b[i]); E(x[i]); E(y[i]); // initialization the inner arrays of b, x, y
                d[i]=0; a[i]=0;

                R(j)
                        b[i][j]=0; x[i][j]=0; y[i][j]=0; // ensure each point is initialized as 0
                }
        }

        // find a solution starting at the top-left corner and print it if it finds one
        if (f(1,0)) {
                R(i)
                        R(j)
                                std::cout<<b[i][j];
                        }
                        std::cout<<std::endl;
                }
        }
}

Comments

কোডটি পুনরায় পড়ার পরে, আমি বুঝতে পারি কিছু চেকের প্রয়োজন হতে পারে না যেমন if (x[r][p]) return f(c+1,r);। আমি এটি সংক্ষিপ্ত করার কাজ করছি।

— হারগাসিনস্কি

Answer 8

ক্লোজার, (215 + 258) * 0.8 = 378.4 (174 + 255) * 0.8 = 343.2

দুটি ভাগে বিভক্ত করুন: ত্রুটি গণনা Sএবং একটি বেনাম ফাংশন যা তাবু অনুসন্ধানের মাধ্যমে প্রকৃত অপ্টিমাইজেশন করে ।

আপডেট: সংক্ষিপ্ত S(গোষ্ঠীগুলির মধ্যে স্বতন্ত্র মান গণনা করে), কম অনুকূল শুরুর অবস্থা (কোনও পরিবর্তন হবে না)।

(defn S[I n](count(mapcat set(vals(apply merge-with concat(flatten(for[R[(range n)]i R j R v[[(I(+(* n i)j))]]][{[1 i]v}{[2 j]v}(if(= i j){3 v})(if(=(- n 1 i)j){4 v})])))))))
#(if-let[s({1[0]2()3()}%)]s(loop[I(vec(for[R[(range %)]i R j R]i))P #{}](let[[s I](last(sort-by first(for[R[(range(count I))]i R j R I[(assoc(assoc I i(I j))j(I i))]:when(not(P I))][(S I %)I])))](if(=(*(+(* % 2)2)%)s)(partition % I)(recur I(conj P I))))))

4, 5, 6 এবং 7 এর জন্য একক কোর বেঞ্চমার্ক (মিলিসেকেন্ডে) 3 বার চালায়:

[[  131.855337   132.96267    138.745981]
 [ 1069.187325  1071.189488  1077.339372]
 [ 9114.736987  9206.65368   9322.656693]
 [36546.309408 36836.567267 36928.346312]]

মূল:

(defn S[I n](apply +(flatten(for[p(concat(partition n I)(for[p(apply map vector(partition n(range(count I))))](map I p))[(take-nth(inc n)I)][(rest(butlast(take-nth(dec n)I)))])](remove #{1}(vals(frequencies p)))))))
#(if-let[s({1[0]2()3()}%)]s(loop[I(vec(flatten(map shuffle(repeat %(range %)))))P #{}](let[[s I](first(sort-by first(for[R[(range(count I))]i R j R I[(assoc(assoc I i(I j))j(I i))]:when(not(P I))][(S I %)I])))](if(= s 0)(partition % I)(recur I(conj P I))))))

আমি আশা করি Sখাটো ছিল, কিন্তু কারণ এটি শুধুমাত্র একটির বেশি / পার্টিশন এর ঘটনার বড়, মোট ছাত্র বাঁধন নির্ণায়ক সহজ (= s 0)।

অনেক CPU- র চক্র, অ দরকারী অদলবদল জন্য বরবাদ যদি আপনি অদলবদল উদাহরণস্বরূপ এটা স্কোর উন্নতি না হলে 2সঙ্গে 2, এবং তারা সব স্বতন্ত্র মান দিয়ে শুরু করতে আপনি সারি মধ্যে সোয়াপ নম্বরে প্রয়োজন হবে না।

ইন্টেল 6700 কে (মিলিসেকেন্ডে) সহ বেঞ্চমার্ক:

(defn S[I n]( ... )
(def F #( ... ))

(defmacro mytime[expr]
  `(let [start# (. System (nanoTime)) ret# ~expr]
     (/ (double (- (. System (nanoTime)) start#)) 1000000.0)))

(pprint(vec(for[n[4 5 6 7]](vec(sort(repeatedly 5 #(mytime (F n)))))))

[[  43.445902   45.895107   47.277399   57.681634    62.594037]
 [ 222.964582  225.467034  240.532683  330.237721   593.686911]
 [2285.417473 2531.331068 3002.597908 6361.591714  8331.809410]
 [3569.62372  4779.062486 5725.905756 7444.941763 14120.796615]]

এর সাথে বহুবিধ pmap:

[[   8.881905  16.343714   18.87262  18.9717890   22.194430]
 [  90.963870 109.719332  163.00299  245.824443  385.365561]
 [ 355.872233 356.439256 1534.31059 2593.482767 3664.221550]
 [1307.727115 1554.00260 2068.35932 3626.878526 4029.543011]]