এই গেমের পিছনে গাণিতিক / গুণগত নীতিগুলি কী কী?


196

আমার বাচ্চাদের স্পট ইট নামে এই মজাদার খেলাটি রয়েছে ! গেমের সীমাবদ্ধতা (সর্বোপরি আমি বর্ণনা করতে পারি) হ'ল:

  • এটি 55 কার্ডের একটি ডেক
  • প্রতিটি কার্ডে 8 টি অনন্য ছবি রয়েছে (অর্থাত্ কোনও কার্ডে একই চিত্রের 2 টি থাকতে পারে না)
  • কোন 2 কার্ড ডেক থেকে নির্বাচিত দেওয়া, সেখানে 1 এবং মাত্র 1 ম্যাচিং ছবি
  • চিত্রের মিলগুলি বিভিন্ন কার্ডে আলাদাভাবে স্কেল করা যেতে পারে তবে এটি কেবল গেমটিকে আরও শক্ত করতে (যেমন একটি ছোট গাছ এখনও একটি বড় গাছের সাথে মেলে)

গেমটির মূলনীতি হ'ল: 2 টি কার্ডের ওপরে ফ্লিপ করুন এবং যে কেউ প্রথমে ম্যাচের ছবিটি তুলবে সে পয়েন্ট পায়।

স্পষ্টতার জন্য এখানে একটি চিত্র:

বের করো

(উদাহরণ: আপনি উপরের নীচে 2 টি কার্ড থেকে দেখতে পাচ্ছেন যে মিলানো ছবিটি সবুজ ডাইনোসর the নীচের ডান এবং মাঝের-ডান চিত্রের মধ্যে এটি একটি ভাঁড়ের মাথা)

আমি নিম্নলিখিতটি বোঝার চেষ্টা করছি:

  1. এই মানদণ্ডগুলি পূরণ করতে বিভিন্ন ন্যূনতম ছবির প্রয়োজনীয় সংখ্যা কী কী এবং আপনি এটি কীভাবে নির্ধারণ করবেন?

  2. সিউডোকোড (বা রুবি) ব্যবহার করে আপনি কীভাবে এন ছবিগুলির একটি অ্যারে থেকে 55 টি গেম কার্ড তৈরি করবেন (যেখানে প্রশ্নটি 1 থেকে ন্যূনতম সংখ্যা)?

হালনাগাদ:

ছবিগুলি প্রতিটি ডেকে প্রতি দ্বিগুণের বেশি ঘটে (কিছু লোকেরা যা দেখেছিল তার বিপরীতে)। 3 টি কার্ডের এই চিত্রটি দেখুন প্রতিটি বিদ্যুতের বল্ট সহ:3 টি কার্ড


64
গেমটিকে এমন কিছুতে পরিণত করার জন্য +1 যা আমার মস্তিষ্ককে ব্যাথা দেয়।
ক্যাবারে

3
প্রতি কার্ডে ছবিগুলির ন্যূনতম সংখ্যা, বা প্রতি কার্ডে 8 টি দেওয়া ছবি দেওয়া ন্যূনতম সংখ্যা? এছাড়াও, প্রতিটি ছবি ম্যাচযোগ্য হতে হবে?
ট্রুথিলিটি

7
আমার মনে হয় আপনার আরও প্রতিবন্ধকতা যুক্ত করতে হবে। অন্যথায়, আপনি প্রতিটি কার্ডে একটি আপেল রাখতে পারেন, এবং তারপরে প্রতিটি কার্ডে কয়েকটি সংখ্যক অনন্য চিত্র যুক্ত করতে পারেন। প্রতিটি জোড়া কার্ড কেবল অ্যাপলের চিত্রের সাথে মিলবে।
এমবিকেশ

8
@ ক্যাবারে: সেক্ষেত্রে আপনি সেটটি পছন্দ করবেন । অবিশ্বাস্যভাবে মজাদার এবং উত্তেজক।
ডিএমকেকে --- প্রাক্তন মডারেটর বিড়ালছানা

4
যদিও এটি দুর্দান্ত প্রশ্ন, এটি ইতিমধ্যে গণিত সাইটে (আমার দ্বারা) জিজ্ঞাসা করা হয়েছে। এটি এখানে কিছুটা বন্ধ বিষয় মনে হচ্ছে। - math.stackexchange.com/questions/36798/…
জাবিদ জামে

উত্তর:


148

সীমাবদ্ধ প্রকল্পের জ্যামিতি

উপপাদ্য ব্যবহার এর প্রক্ষিপ্তভাবে (সমতল) জ্যামিতি ইউক্লিডিয় জ্যামিতি চেয়ে কিছুটা ভিন্ন আছেন:

  • প্রতি দুটি পয়েন্টের ঠিক এক লাইন থাকে যা তাদের মধ্য দিয়ে যায় (এটি একই)।
  • প্রতি দুটি লাইন একেবারে এক বিন্দুতে মিলিত হয় (এটি ইউক্লিড থেকে কিছুটা আলাদা)।

এখন স্যুপে "সসীম" যুক্ত করুন এবং আপনার প্রশ্ন রয়েছে:

আমরা কি মাত্র 2 পয়েন্ট সহ জ্যামিতি পেতে পারি? 3 পয়েন্ট সহ? 4 দিয়ে? 7 দিয়ে?

এই সমস্যাটি নিয়ে এখনও খোলা প্রশ্ন রয়েছে তবে আমরা এটি জানি:

  • সেখানে সঙ্গে জ্যামিতি হন Qপয়েন্ট, তারপর Q = n^2 + n + 1এবং nবলা হয় orderজ্যামিতি।
  • আছে n+1যে লাইনে পয়েন্ট।
  • প্রতিটি বিন্দু থেকে, ঠিক n+1লাইন পাস ।
  • মোট লাইন সংখ্যা Q

  • এবং পরিশেষে, যদি nপ্রধান হয়, তবে সেখানে অর্ডারের জ্যামিতি উপস্থিত রয়েছে n


যে ধাঁধা সঙ্গে কি আছে, কেউ জিজ্ঞাসা করতে পারে।

cardপরিবর্তে pointএবং pictureপরিবর্তে রাখুন lineএবং অক্ষগুলি হয়ে যায়:

  • প্রতি দুটি কার্ডের মধ্যে একটি করে ছবি মিল রয়েছে।
  • প্রতি দুটি ছবির জন্য হুবহু একটি করে কার্ড রয়েছে যার মধ্যে দুটি রয়েছে।

এখন, নেওয়া যাক n=7এবং আমাদের order-7সাথে সীমাবদ্ধ জ্যামিতি রয়েছে Q = 7^2 + 7 + 1। করে নির্মিত হয় Q=57লাইন (ছবিগুলির) এবং Q=57পয়েন্ট (কার্ড)। আমার ধারণা ধাঁধা নির্মাতারা সিদ্ধান্ত নিয়েছেন যে 55 টি 57 এর চেয়ে বেশি গোল সংখ্যা এবং 2 টি কার্ড রেখে গেছে।

আমরাও পাই n+1 = 8, সুতরাং প্রতিটি পয়েন্ট (কার্ড) থেকে, 8 টি লাইন পাস (8 টি চিত্র প্রদর্শিত হবে) এবং প্রতিটি লাইনে (চিত্রের) 8 পয়েন্ট রয়েছে (8 টি কার্ডে প্রদর্শিত হবে)।


নোয়েল ইভানস থেকে অনুলিপি করা - ফানো প্লেন নামে পরিচিত 7 পয়েন্ট সহ সর্বাধিক বিখ্যাত সীমাবদ্ধ প্রজেক্টিভ (অর্ডার -2) বিমান (জ্যামিতি) এর উপস্থাপনা এখানে রয়েছে - সীমাবদ্ধ জ্যামিতি সমস্যা পৃষ্ঠা

এখানে চিত্র বর্ণনা লিখুন

আমি এমন একটি চিত্র ব্যাখ্যা কিভাবে উপরে অর্ডার-2 সমতল 7 কার্ড এবং 7 ছবির সঙ্গে একটি অনুরূপ ধাঁধা করা সম্ভব হয়েছে তৈরি করার চিন্তা ছিল, কিন্তু তারপর math.exchange যমজ প্রশ্ন থেকে একটি লিঙ্ক ঠিক যেমন একটি ডায়াগ্রাম আছে: গান Dobble-et- লা-geometrie-finie

ফানো প্লেন


9
তাহলে এই গেমটি ইউক্লিডিয়ান জ্যামিতি প্রদর্শন করে? কার্ডগুলি সঠিক কিনা তা বলা কি সঠিক হবে?
আরএমরিসি

2
এটি দুর্দান্ত লাগছে, তবে আমার আসলে কোনও সমস্যা নেই যে সমস্যাটি আসলে এটি মডেল করে। @ টিউবারকিউ, আপনি কার্ড / চিত্র এবং পয়েন্ট / লাইনের মধ্যে সাদৃশ্যটি কেন বৈধ বলে মনে করেন আপনি আরও কিছুটা ব্যাখ্যা করতে পারেন?
নাট কোহল

@ নাট: প্রথম সাদৃশ্যটি প্রশ্নটিতে every two cards have exactly one picture in commonবর্ণিত হয়েছে। ২ য় for every two pictures there is exactly one card that has both of them, গেমস সেটটি সন্তুষ্ট হলে এটি ওপি আমাদের জানাতে পারে।
ypercubeᵀᴹ

4
দুর্দান্ত উত্তর! দুর্দান্ত অন্তর্দৃষ্টি, উপলব্ধি করে যে গেমটি অর্ডার -7 প্রজেক্টিভ প্লেনের বৈশিষ্ট্যগুলির সাথে মেলে, এবং আমি দেখেছি যে ল্যাপারসনের জন্য প্রজেক্টিভ প্লেনগুলির সেরা ব্যাখ্যাগুলির একটি।
আরবেরি ইয়ং

3
উজ্জ্বল। পাইথনে কার্ড সেট কীভাবে তৈরি করা যায় তা বোঝার চেষ্টা করার জন্য আমি আরও 100 বার এটি পড়তে চাই ...
জারেড

22

যারা picturing 57 পয়েন্ট সঙ্গে প্রক্ষিপ্তভাবে সমতল জ্যামিতি সমস্যা, সেখানে একটি সত্যিই চমৎকার, 57 কার্ড এবং 57 প্রতীক (দ্বারা উত্তর ভিত্তিক সঙ্গে খেলা গঠন করা স্বজ্ঞাত উপায় ইউভাল Filmus জন্য এই প্রশ্নের ):

  1. 8 টি চিহ্ন সহ কার্ডগুলির জন্য, অনন্য প্রতীকগুলির একটি 7x7 গ্রিড তৈরি করুন।
  2. "Opালু" জন্য 0 থেকে 6 পর্যন্ত অতিরিক্ত 8 টি প্রতীক যুক্ত করুন, অনন্ত slালের জন্য প্লাস একটি।
  3. প্রতিটি কার্ড গ্রিডের একটি লাইন (symb টি প্রতীক) এবং রেখার opeালের জন্য opeাল সেট থেকে একটি প্রতীক। রেখাগুলির একটি অফসেট রয়েছে (অর্থাত্ বাম দিকে সূচনা পয়েন্ট), এবং একটি opeাল (অর্থাত প্রতিটি পদক্ষেপে ডানদিকে কত চিহ্ন যেতে হবে)। লাইনটি শীর্ষে গ্রিডটি ছেড়ে গেলে নীচে আবার প্রবেশ করুন। এই জাতীয় দুটি কার্ডের জন্য উদাহরণ চিত্রটি দেখুন ( বোর্ডগেমেজিকের ছবিগুলি ):

গ্রিড থেকে লাইন হিসাবে নেওয়া দুটি উদাহরণ কার্ড (লাল এবং সবুজ)

উদাহরণস্বরূপ, আমি lineাল শূন্য (লাল) এবং একটি opeাল 1 (সবুজ) এর সাথে একটি লাইন নিয়েছি। এগুলি একেবারে একটি সাধারণ পয়েন্টে (পেঁচা) ছেদ করে।

এই পদ্ধতিটি নিশ্চিত করে যে কোনও দুটি কার্ডের ঠিক একটি সাধারণ প্রতীক রয়েছে, কারণ

  1. যদি opালু পৃথক হয় তবে লাইনগুলি সর্বদা ঠিক এক পর্যায়ে ছেদ করে।
  2. যদি opালগুলি একই হয় তবে লাইনগুলি ছেদ করবে না এবং গ্রিড থেকে কোনও সাধারণ চিহ্ন থাকবে না। এই ক্ষেত্রে, opeাল প্রতীক একই হবে।

এইভাবে, আমরা 7x7 কার্ড (7 অফসেট এবং 7 opাল) তৈরি করতে পারি।

আমরা গ্রিডের মাধ্যমে উল্লম্ব লাইনগুলি থেকে সাতটি অতিরিক্ত কার্ডও তৈরি করতে পারি (অর্থাত প্রতিটি কলাম নেওয়া)। তাদের জন্য, অনন্ত opeাল আইকন ব্যবহার করা হয়।

যেহেতু প্রতিটি কার্ড গ্রিড থেকে সাতটি প্রতীক এবং ঠিক একটি "symbolাল" প্রতীক নিয়ে গঠিত, আমরা একটি অতিরিক্ত কার্ড তৈরি করতে পারি, যা কেবলমাত্র 8 টি opeালের প্রতীক নিয়ে গঠিত।

এটি আমাদের 7x8 + 1 = 57 টি সম্ভাব্য কার্ড এবং 7 x 7 + 8 = 57 প্রয়োজনীয় চিহ্ন সহ ছেড়ে দেয়।

(স্বাভাবিকভাবেই, এটি কেবলমাত্র প্রাইম-সংখ্যা-আকারের গ্রিডের সাথে কাজ করে (উদাঃ এন =)) sl


18

সুতরাং মোট n টি পুলের পুল থেকে m = 8 টি ছবি সমেত কে = 55 টি কার্ড রয়েছে । আমরা প্রশ্নটি পুনঃস্থাপন করতে পারি 'আমাদের কয়টি ছবি এন দরকার, যাতে আমরা কোনও জোড়া কার্ডের মধ্যে কেবল একটি ভাগ করা ছবি দিয়ে কে কার্ডের একটি সেট তৈরি করতে পারি ?' সমানভাবে জিজ্ঞাসা করে:

একটি এন- ডাইমেনশনাল ভেক্টর স্পেস এবং সমস্ত ভেক্টরগুলির সেট দেওয়া হয়েছে, যার মধ্যে এক এবং অন্যান্য সমস্ত শূন্যের সমান মি m উপাদান রয়েছে, যাতে কতগুলি বড় n হওয়া দরকার, যাতে আমরা কে ভেক্টরগুলির একটি সেট খুঁজে পেতে পারি , যার যুগল বিন্দুর পণ্যগুলি সব 1 সমান ?

এর থেকে জোড়া তৈরি করার জন্য যথাযথভাবে ( এন বেছে নিন এম ) সম্ভাব্য ভেক্টর রয়েছে। সুতরাং আমাদের কমপক্ষে একটি বৃহত্তর পর্যাপ্ত এন দরকার যাতে ( এন চয়ন এম )> = কে । এটি কেবল একটি নিম্ন সীমাবদ্ধ, সুতরাং জোড়াযুক্ত সামঞ্জস্যতার সীমাবদ্ধতা পূরণের জন্য আমাদের সম্ভবত আরও অনেক বেশি এন প্রয়োজন

কিছুটা পরীক্ষার জন্য আমি বৈধ কার্ড সেটগুলি গণনা করার জন্য একটি ছোট্ট হাসকল প্রোগ্রাম লিখেছি:

সম্পাদনা: আমি কেবল নীল এবং গাজেটের সমাধান দেখে বুঝতে পেরেছি যে আমি যে অ্যালগরিদম ব্যবহার করি তা সর্বদা সর্বোত্তম সম্ভাব্য সমাধান খুঁজে পায় না, সুতরাং নীচের সমস্ত কিছু প্রয়োজনীয়ভাবে বৈধ নয়। আমি শীঘ্রই আমার কোড আপডেট করার চেষ্টা করব।

module Main where

cardCandidates n m = cardCandidates' [] (n-m) m
cardCandidates' buildup  0  0 = [buildup]
cardCandidates' buildup zc oc
    | zc>0 && oc>0 = zerorec ++ onerec
    | zc>0         = zerorec
    | otherwise    = onerec
    where zerorec = cardCandidates' (0:buildup) (zc-1) oc
          onerec  = cardCandidates' (1:buildup) zc (oc-1)

dot x y = sum $ zipWith (*) x y
compatible x y = dot x y == 1

compatibleCards = compatibleCards' []
compatibleCards' valid     [] = valid
compatibleCards' valid (c:cs)
  | all (compatible c) valid = compatibleCards' (c:valid) cs
  |                otherwise = compatibleCards'    valid  cs

legalCardSet n m = compatibleCards $ cardCandidates n m

main = mapM_ print [(n, length $ legalCardSet n m) | n<-[m..]]
  where m = 8

প্রথম কয়েকটি এন এর জন্য এন থেকে বেছে নেওয়া বিভিন্ন সংখ্যক চিত্রের জন্য মি = 8 টি চিত্রের জন্য সর্বাধিক সংযুক্ত কার্ডের ফলস্বরূপ :

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

মজার ব্যাপার হচ্ছে, তা দেওয়া যে মনে হয় মি , সঙ্গে বাড়ে এন কেবল একটি নির্দিষ্ট করতে এন , যার পরে এটা ধ্রুব থাকে।

এর অর্থ হ'ল, প্রতি কার্ডের জন্য প্রতিটি সংখ্যক চিত্রের জন্য বেছে নেওয়া নির্দিষ্ট সংখ্যা রয়েছে, যার ফলে সর্বাধিক সম্ভাব্য আইনী কার্ড পাওয়া যায়। অতীত থেকে বেছে নিতে আরও ছবি যুক্ত করা আইনী কার্ডের সংখ্যা আর বাড়ায় না।

প্রথম কয়েকটি অনুকূল কে হ'ল :

অনুকূল কে টেবিল


এটি কেবল একটি বাউন্ডে প্রাথমিক প্রচেষ্টা, তাই না? আপনি "জোড়াওয়ালা ডট পণ্য সমান 1" প্রয়োজনের সাথে সংযুক্ত করেন নি ...
নিমো

স্পষ্টতই এখানে সিনট্যাক্স হাইলাইটারটি এখনও হ্যাস্কেলকে এখনও সমর্থন করে না ( meta.stackexchange.com/questions/78363/… ), তবে ভবিষ্যতে এমনটি করার ক্ষেত্রে আমি ইঙ্গিতটিতে টস করব।
বোল্টক্লক

আপনার সম্পাদনার জন্য ব্লটক্লক ধন্যবাদ! আমি জানতাম না যে আপনি ভাষা-নির্দিষ্ট সিনট্যাক্স হাইলাইট করার জন্য ইঙ্গিত দিতে পারেন।
থিজ হেইডেকে

এটি এখনও খুব সুপরিচিত নয় :)
বোল্টক্লক

9

অন্যরা ডিজাইনের জন্য সাধারণ কাঠামো (সসীম প্রজেক্টিভ প্লেন) বর্ণনা করেছেন এবং দেখিয়েছেন কীভাবে প্রাইম অর্ডারের সীমাবদ্ধ প্রজেক্টিভ প্লেন তৈরি করা যায়। আমি কিছু শূন্যস্থান পূরণ করতে চাই।

সীমাবদ্ধ প্রজেক্টিভ প্লেনগুলি বিভিন্ন বিভিন্ন অর্ডারের জন্য তৈরি করা যেতে পারে তবে প্রাইম অর্ডারের ক্ষেত্রে এগুলি সবচেয়ে সোজা p। তারপরে পূর্ণসংখ্যার মডুলো pএকটি সীমাবদ্ধ ক্ষেত্র গঠন করে যা বিমানের পয়েন্ট এবং লাইনগুলির স্থানাঙ্ক বর্ণনা করতে ব্যবহার করা যেতে পারে। পয়েন্টের জন্য স্থানাঙ্ক 3 বিভিন্ন ধরণের আছে: (1,x,y), (0,1,x), এবং (0,0,1), যেখানে xএবং yথেকে মানগুলি নিতে পারেন 0করতে p-1। 3 টি বিভিন্ন ধরণের পয়েন্ট p^2+p+1সিস্টেমে পয়েন্টের সংখ্যার সূত্রটি ব্যাখ্যা করে । আমরা স্থানাঙ্ক একই 3 বিভিন্ন ধরণের সঙ্গে লাইন বর্ণনা করতে পারেন: [1,x,y], [0,1,x], এবং [0,0,1]

আমরা তাদের গুণাবলীর বিন্দুর পণ্য 0 মডের সমান কিনা তা দ্বারা বিন্দু এবং রেখার ঘটনা কিনা তা আমরা গণনা করি p। উদাহরণস্বরূপ, বিন্দু (1,2,5)এবং লাইনটি [0,1,1]যখন তখন ঘটনা , তবে বিন্দু এবং লাইনটি তখন p=7থেকে ঘটনা নয় ।1*0+2*1+5*1 = 7 == 0 mod 7(1,3,3)[1,2,6]1*1+3*2+3*6 = 25 != 0 mod 7

কার্ড এবং ছবিগুলির ভাষায় অনুবাদ করা, এর অর্থ হ'ল স্থানাঙ্কযুক্ত কার্ডটিতে স্থানাঙ্ক (1,2,5)সহ ছবি থাকে তবে স্থানাঙ্ক [0,1,1]সহ কার্ডটিতে স্থানাঙ্ক (1,3,3)সহ ছবি থাকে না [1,2,6]। কার্ড এবং তাদের থাকা ছবিগুলির একটি সম্পূর্ণ তালিকা তৈরি করতে আমরা এই পদ্ধতিটি ব্যবহার করতে পারি।

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

একই নির্মাণ কোনও সীমাবদ্ধ ক্ষেত্রের জন্য কাজ করে। আমরা জানি যে এখানে একটি সীমাবদ্ধ ক্ষেত্র রয়েছে qকেবলমাত্র যদি q=p^kএকটি প্রধান শক্তি। ক্ষেত্রটি বলা হয় GF(p^k)যা "গ্যালোইস ক্ষেত্র" এর জন্য দাঁড়িয়েছে। ফিল্ডগুলি প্রাইম পাওয়ারের ক্ষেত্রে প্রাইম কেসের মতো নির্মাণ করা তত সহজ নয়।

ভাগ্যক্রমে, কঠোর পরিশ্রম ইতিমধ্যে সেজে নামক ফ্রি সফটওয়্যারটিতে করা হয়েছে এবং প্রয়োগ করা হয়েছে । অর্ডার 4-এর একটি প্রজেটিভ প্লেন ডিজাইন পেতে, উদাহরণস্বরূপ, কেবল টাইপ করুন

print designs.ProjectiveGeometryDesign(2,1,GF(4,'z'))

এবং আপনি দেখতে যে আউটপুট পাবেন

ProjectiveGeometryDesign<points=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20], blocks=[[0, 1, 2, 3, 20], [0,
4, 8, 12, 16], [0, 5, 10, 15, 19], [0, 6, 11, 13, 17], [0, 7, 9, 14,
18], [1, 4, 11, 14, 19], [1, 5, 9, 13, 16], [1, 6, 8, 15, 18], [1, 7,
10, 12, 17], [2, 4, 9, 15, 17], [2, 5, 11, 12, 18], [2, 6, 10, 14, 16],
[2, 7, 8, 13, 19], [3, 4, 10, 13, 18], [3, 5, 8, 14, 17], [3, 6, 9, 12,
19], [3, 7, 11, 15, 16], [4, 5, 6, 7, 20], [8, 9, 10, 11, 20], [12, 13,
14, 15, 20], [16, 17, 18, 19, 20]]>

আমি উপরোক্ত বিষয়গুলি নীচে ব্যাখ্যা করি: 0 থেকে 20 পর্যন্ত লেবেলযুক্ত 21 টি ছবি রয়েছে Each উদাহরণস্বরূপ, প্রথম কার্ডে 0, 1, 2, 3 এবং 20 টি ছবি থাকবে; দ্বিতীয় কার্ডে ছবি 0, 4, 8, 12, এবং 16 থাকবে; ইত্যাদি।

অর্ডার 7 সিস্টেমটি তৈরি করা যেতে পারে

print designs.ProjectiveGeometryDesign(2,1,GF(7)) 

যা আউটপুট উত্পন্ন করে

ProjectiveGeometryDesign<points=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46,
47, 48, 49, 50, 51, 52, 53, 54, 55, 56], blocks=[[0, 1, 2, 3, 4, 5, 6,
56], [0, 7, 14, 21, 28, 35, 42, 49], [0, 8, 16, 24, 32, 40, 48, 50], [0,
9, 18, 27, 29, 38, 47, 51], [0, 10, 20, 23, 33, 36, 46, 52], [0, 11, 15,
26, 30, 41, 45, 53], [0, 12, 17, 22, 34, 39, 44, 54], [0, 13, 19, 25,
31, 37, 43, 55], [1, 7, 20, 26, 32, 38, 44, 55], [1, 8, 15, 22, 29, 36,
43, 49], [1, 9, 17, 25, 33, 41, 42, 50], [1, 10, 19, 21, 30, 39, 48,
51], [1, 11, 14, 24, 34, 37, 47, 52], [1, 12, 16, 27, 31, 35, 46, 53],
[1, 13, 18, 23, 28, 40, 45, 54], [2, 7, 19, 24, 29, 41, 46, 54], [2, 8,
14, 27, 33, 39, 45, 55], [2, 9, 16, 23, 30, 37, 44, 49], [2, 10, 18, 26,
34, 35, 43, 50], [2, 11, 20, 22, 31, 40, 42, 51], [2, 12, 15, 25, 28,
38, 48, 52], [2, 13, 17, 21, 32, 36, 47, 53], [3, 7, 18, 22, 33, 37, 48,
53], [3, 8, 20, 25, 30, 35, 47, 54], [3, 9, 15, 21, 34, 40, 46, 55], [3,
10, 17, 24, 31, 38, 45, 49], [3, 11, 19, 27, 28, 36, 44, 50], [3, 12,
14, 23, 32, 41, 43, 51], [3, 13, 16, 26, 29, 39, 42, 52], [4, 7, 17, 27,
30, 40, 43, 52], [4, 8, 19, 23, 34, 38, 42, 53], [4, 9, 14, 26, 31, 36,
48, 54], [4, 10, 16, 22, 28, 41, 47, 55], [4, 11, 18, 25, 32, 39, 46,
49], [4, 12, 20, 21, 29, 37, 45, 50], [4, 13, 15, 24, 33, 35, 44, 51],
[5, 7, 16, 25, 34, 36, 45, 51], [5, 8, 18, 21, 31, 41, 44, 52], [5, 9,
20, 24, 28, 39, 43, 53], [5, 10, 15, 27, 32, 37, 42, 54], [5, 11, 17,
23, 29, 35, 48, 55], [5, 12, 19, 26, 33, 40, 47, 49], [5, 13, 14, 22,
30, 38, 46, 50], [6, 7, 15, 23, 31, 39, 47, 50], [6, 8, 17, 26, 28, 37,
46, 51], [6, 9, 19, 22, 32, 35, 45, 52], [6, 10, 14, 25, 29, 40, 44,
53], [6, 11, 16, 21, 33, 38, 43, 54], [6, 12, 18, 24, 30, 36, 42, 55],
[6, 13, 20, 27, 34, 41, 48, 49], [7, 8, 9, 10, 11, 12, 13, 56], [14, 15,
16, 17, 18, 19, 20, 56], [21, 22, 23, 24, 25, 26, 27, 56], [28, 29, 30,
31, 32, 33, 34, 56], [35, 36, 37, 38, 39, 40, 41, 56], [42, 43, 44, 45,
46, 47, 48, 56], [49, 50, 51, 52, 53, 54, 55, 56]]>

8

আমি 57 বা 58 টি ছবি দিয়ে এটি করার একটি উপায় খুঁজে পেয়েছি তবে এখন আমার খুব খারাপ মাথাব্যথা আছে, আমি ভাল ঘুমানোর পরে 8-10 ঘন্টা পরে আমি রুবি কোডটি পোস্ট করব! আমার সমাধান হিসাবে প্রতি 7 টি কার্ড একই চিহ্ন হিসাবে একটি ইঙ্গিত দেয় এবং আমার দ্রবণটি ব্যবহার করে মোট 56 কার্ড তৈরি করা যায়।

এখানে কোডটি হ'ল ইপার্কিউব যে সমস্ত 57 কার্ড তৈরি করে তা উত্পন্ন করে। এটি vector <something>হ'ল 57 টি ছবি ব্যবহার করে, এবং দুঃখিত লোকটি আমি আসল সি ++ কোড লিখেছি কিন্তু somethingএটির কোডটি কী করে তা বোঝা সহজ type এবং এই কোডটি প্রতিটি প্রধান ছবিতে প্রতিটি ছবিযুক্ত ছবি P^2+P+1ব্যবহার করে এবং কেবল 1 টি ছবি ভাগ করে কার্ড ব্যবহার করে gene যার অর্থ আমাদের cards টি কার্ড ব্যবহার করে প্রতিটি ছবিতে ৩ টি ছবি রয়েছে (পি = ২ এর জন্য), ১৩ টি কার্ড ব্যবহার করে ১৩ টি ছবি (পি = ৩ এর জন্য), ৩১ টি কার্ড ব্যবহার করে ৩১ টি ছবি (পি = ৫ এর জন্য), 57 টি কার্ডের জন্য 57 টি কার্ড (পি = 7 এর জন্য) এবং আরও ...P^2+P+1P+1

#include <iostream>
#include <vector>

using namespace std;

vector <vector<int> > cards;

void createcards(int p)
{
    cards.resize(0);
    for (int i=0;i<p;i++)
    {
        cards.resize(cards.size()+1);
        for(int j=0;j<p;j++)
        {
            cards.back().push_back(i*p+j);
        }
        cards.back().push_back(p*p+1);
    }

    for (int i=0;i<p;i++)
    {
        for(int j=0;j<p;j++)
        {
            cards.resize(cards.size()+1);
            for(int k=0;k<p;k++)
            {
                cards.back().push_back(k*p+(j+i*k)%p);
            }
            cards.back().push_back(p*p+2+i);
        }
    }

    cards.resize(cards.size()+1);

    for (int i=0;i<p+1;i++)
        cards.back().push_back(p*p+1+i);
}

void checkCards()
{
    cout << "---------------------\n";
    for(unsigned i=0;i<cards.size();i++)
    {
        for(unsigned j=0;j<cards[i].size();j++)
        {
            printf("%3d",cards[i][j]);
        }
        cout << "\n";
    }
    cout << "---------------------\n";
    for(unsigned i=0;i<cards.size();i++)
    {
        for(unsigned j=i+1;j<cards.size();j++)
        {
            int sim = 0;
            for(unsigned k=0;k<cards[i].size();k++)
                for(unsigned l=0;l<cards[j].size();l++)
                    if (cards[i][k] == cards[j][l])
                        sim ++;
            if (sim != 1)
                cout << "there is a problem between cards : " << i << " " << j << "\n";

        }
    }
}

int main()
{
    int p;
    for(cin >> p; p!=0;cin>> p)
    {
        createcards(p);
        checkCards();
    }
}

আবার বিলম্বিত কোডের জন্য দুঃখিত


37
আমার এটির মার্জিত প্রমাণ রয়েছে তবে হায় আফসোস এই মন্তব্য বাক্সটি এটির জন্য খুব ছোট।
sarnold

@ গেজেট: আপনি এটি চালিয়েছেন p=4? (এবং 21 কার্ড / ছবি)
ypercubeᵀᴹ

4 আমার অ্যালগরিদমে কাজ করে না 4 যেহেতু 4 একটি মৌলিক সংখ্যা নয়, আমার অ্যালগরিদমে এটি গুরুত্বপূর্ণ যে পি প্রধান হওয়া উচিত।
Ali1S232

@ পিপারকিউব আবার যাচাই করার পরে আমার অ্যালগরিদমে কিছু ছোটখাটো ভুল ছিল তবে আমি এটি 2,3,5,7 ডলার করে যাচাই করেছিলাম এবং এটি যে কোনও প্রধান সংখ্যাটির জন্য কাজ করবে তা প্রমাণ করতে পারি, সুতরাং আমার সম্পূর্ণ কোডটি এখানে রয়েছে (তবে সি ++ এ)
Ali1S232

1
@ গেজেট: শীতল সমাধান! এখন আমি পেয়েছি কেন আমার লোভী অ্যালগরিদম সর্বদা সর্বোত্তম সমাধান উত্পাদন করে না।
থিজ হেইডেক

6

পাইথনটিতে গাজেটের সমাধান এখানে, যেহেতু আমি পাইথনকে আরও পাঠযোগ্য। আমি এটি পরিবর্তন করেছি যাতে এটি অ-প্রাইম সংখ্যাগুলির সাথেও কাজ করে। আমি আরও কিছু সহজে বোঝা ডিসপ্লে কোড উত্পন্ন করতে আপনার অন্তর্দৃষ্টি ব্যবহার করেছি।

from __future__ import print_function
from itertools import *

def create_cards(p):
    for min_factor in range(2, 1 + int(p ** 0.5)):
        if p % min_factor == 0:
            break
    else:
        min_factor = p
    cards = []
    for i in range(p):
        cards.append(set([i * p + j for j in range(p)] + [p * p]))
    for i in range(min_factor):
        for j in range(p):
            cards.append(set([k * p + (j + i * k) % p
                              for k in range(p)] + [p * p + 1 + i]))

    cards.append(set([p * p + i for i in range(min_factor + 1)]))
    return cards, p * p + p + 1

def display_using_stars(cards, num_pictures):
    for pictures_for_card in cards:
        print("".join('*' if picture in pictures_for_card else ' '
                      for picture in range(num_pictures)))

def check_cards(cards):
    for card, other_card in combinations(cards, 2):
        if len(card & other_card) != 1:
            print("Cards", sorted(card), "and", sorted(other_card),
                  "have intersection", sorted(card & other_card))

cards, num_pictures = create_cards(7)
display_using_stars(cards, num_pictures)
check_cards(cards)

আউটপুট সহ:

***      *   
   ***   *   
      ****   
*  *  *   *  
 *  *  *  *  
  *  *  * *  
*   *   *  * 
 *   **    * 
  **   *   * 
*    * *    *
 * *    *   *
  * * *     *
         ****

2
আমি মনে করি আপনার উদাহরণের শেষ তিনটি কার্ড বৈধ নয়, কারণ তারা পঞ্চম কার্ডের সাথে কোনও ছবি ভাগ করে না। আমি বুঝতে পারার এক ঘণ্টার বেশি সময় ধরে আমার কোডটি যাচাই করে ফেলেছে :) মজার বিষয় হল, এটি মনে হয় যে কোনও আইনী কার্ডসেটের সর্বোচ্চ আকার প্রতিটি কার্ডের জন্য 4 টি চিত্রের জন্য 5 এবং চয়ন করার জন্য আরও ছবি সহ এমনকি বাড়েনি doesn't
হেইডেক

1
@ গেজেটের কোড ব্যবহার করে আমি যে চিত্রটি তৈরি করেছি তার মধ্যে তিনটি, কেন সঠিক (p) + (p * p) + (1)কনফিগারেশন রয়েছে তা দেখতে অনেক সহজ ।
নিল জি

1
@ নীল: আপডেট করা চিত্রের জন্য ধন্যবাদ, গজেটের সমাধান কীভাবে কাজ করে তা দেখতে এটি আরও সহজ করে তোলে!
থিজ হেইডেক

1
@ গেজেট: আমার মনে হয় আপনার সম্পর্কে ভুল all p except 4 and 6। আপনি যদি সীমাবদ্ধ বিমান তৈরি করতে চান যেখানে p*p+p+1পয়েন্ট এবং লাইন রয়েছে (কার্ড এবং ছবি), তবে এটি সম্পর্কিত finite fieldsএবং না ringspপি primeবা এ যখন সীমাবদ্ধ ক্ষেত্র আছে prime power। আপনার কোড মৌলিক জন্য সঠিকভাবে কাজ করে পছন্দ করি কারণ এক্সপ্রেশন k * p + (j + i * k) % pপ্রকাশ করছে k*p + j + i*kগুণ শৃঙ্খলা সসীম ক্ষেত্র উপরন্তু পরিপ্রেক্ষিতে p
ypercubeᵀᴹ

1
এটা খুবই প্রধানমন্ত্রী শক্তিগুলি সঠিকভাবে কাজ হবে যদি আপনি সেই আদেশের সসীম ক্ষেত্র এই ক্রিয়াকলাপগুলি (। একাধিক এবং উপরন্তু) প্রকাশ করতে পারেন p^2, p^3ইত্যাদি সুতরাং, জন্য কাজ করবে4, 8, 9, 16, 25, 27, ...
ypercubeᵀᴹ

4

z3উপপাদ্য প্রবাদটি ব্যবহার করে

Pপ্রতিটি কার্ডে প্রতীক সংখ্যা হওয়া যাক । এই নিবন্ধ এবং ypercubeᵀᴹএর উত্তর অনুসারে N = P**2 - P + 1যথাক্রমে কার্ড এবং চিহ্ন রয়েছে। কার্ডগুলির একটি ডেকে তার ঘটনা ম্যাট্রিক্সের সাথে প্রতিনিধিত্ব করা যেতে পারে যা প্রতিটি কার্ডের জন্য একটি সারি এবং প্রতিটি সম্ভাব্য চিহ্নের জন্য একটি কলাম রয়েছে। কার্ডের এটিতে চিহ্ন থাকলে এটির (i,j)উপাদান । আমাদের কেবল এই বাধাগুলি মাথায় রেখে এই ম্যাট্রিক্স পূরণ করতে হবে:1ij

  • প্রতিটি উপাদান হয় শূন্য বা এক
  • প্রতিটি সারির যোগফল হুবহু P
  • প্রতিটি কলামের যোগফল হুবহু P
  • যে কোনও দুটি সারিতে অবশ্যই একটি চিহ্ন থাকা উচিত

এর অর্থ N**2ভেরিয়েবল এবং N**2 + 2*N + (N choose 2)সীমাবদ্ধতা। এটি z3ছোট ইনপুটগুলির সাথে অল্প দিনের মধ্যে পরিচালনাযোগ্য বলে মনে হচ্ছে ।

সম্পাদনা : দুর্ভাগ্যক্রমে P = 8 এই পদ্ধতির জন্য খুব বড় বলে মনে হচ্ছে। আমি গণনার সময় 14 ঘন্টা পরে প্রক্রিয়া হত্যা।

from z3 import *
from itertools import combinations

def is_prime_exponent(K):
    return K > 1 and K not in 6  # next non-prime exponent is 10, 
                                 # but that is too big anyway

def transposed(rows):
    return zip(*rows)

def spotit_z3(symbols_per_card):
    K = symbols_per_card - 1
    N = symbols_per_card ** 2 - symbols_per_card + 1
    if not is_prime_exponent(K):
        raise TypeError("Symbols per card must be a prime exponent plus one.")

    constraints = []

    # the rows of the incidence matrix
    s = N.bit_length()
    rows = [[BitVec("r%dc%d" % (r, c), s) for c in range(N)] for r in range(N)]

    # every element must be either 1 or 0
    constraints += [Or([elem == 1, elem == 0]) for row in rows for elem in row]

    # sum of rows and cols must be exactly symbols_per_card
    constraints += [Sum(row) == symbols_per_card for row in rows]
    constraints += [Sum(col) == symbols_per_card for col in transposed(rows)]

    # Any two rows must have exactly one symbol in common, in other words they
    # differ in (symbols_per_card - 1) symbols, so their element-wise XOR will
    # have 2 * (symbols_per_card - 1) ones.
    D = 2 * (symbols_per_card - 1)
    for row_a, row_b in combinations(rows, 2):
        constraints += [Sum([a ^ b for a, b in zip(row_a, row_b)]) == D]

    solver = Solver()
    solver.add(constraints)

    if solver.check() == unsat:
        raise RuntimeError("Could not solve it :(")

    # create the incidence matrix
    model = solver.model()
    return [[model[elem].as_long() for elem in row] for row in rows]


if __name__ == "__main__":
    import sys
    symbols_per_card = int(sys.argv[1])
    incidence_matrix = spotit_z3(symbols_per_card)
    for row in incidence_matrix:
        print(row)

ফলাফল

$python spotit_z3.py 3
[0, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 1, 1, 1]
[0, 1, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0]
[0, 1, 1, 0, 1, 0, 0]
[1, 0, 0, 1, 1, 0, 0]
[1, 0, 1, 0, 0, 0, 1]
python spotit_z3.py 3  1.12s user 0.06s system 96% cpu 1.225 total

$ time python3 spotit_z3.py 4
[0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0]
[0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0]
[0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0]        
[0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1]
[0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1]
[0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0]
[0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0]
[1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]
[1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
[1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0]
python spotit_z3.py 4  664.62s user 0.15s system 99% cpu 11:04.88 total

$ time python3 spotit_z3.py 5
[1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0]
[0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0]
[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1]
[0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]
[0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]
[0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
[1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]
[0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0]
[0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1]
[1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0]
[0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0]
[0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1]
[1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
python spotit_z3.py 5  1162.72s user 20.34s system 99% cpu 19:43.39 total

$ time python3 spotit_z3.py 8
<I killed it after 14 hours of run time.>

4

আমি এই সুতোটি খুব পছন্দ করি। আমি পিএনজি হিসাবে কাস্টম কার্ড আঁকার জন্য এই কোডটির কিছু অংশ নিয়ে এই গিথুব পাইথন প্রকল্পটি তৈরি করি (যাতে ইন্টারনেটে কাস্টম কার্ড গেম অর্ডার করতে পারে)।

https://github.com/plagtag/ProjectiveGeometry-Game


3

পার্ল কোড সহ এই জাতীয় ডেক কীভাবে উত্পন্ন করা যায় সে সম্পর্কে আমি একটি নিবন্ধ লিখেছিলাম । কোডটি অপ্টিমাইজ করা হয়নি তবে এটি "যুক্তিসঙ্গত" অর্ডারগুলির ডেক জেনারেট করতে সক্ষম ... এবং আরও কিছু।

এখানে অর্ডার 8 এর একটি উদাহরণ রয়েছে যা একে আরও জটিল জটিল অন্তর্নিহিত গণিত বিবেচনা করতে হবে, কারণ 8 টি প্রধান নয় যদিও এই ধরণের ডেক তৈরির জন্য একটি বৈধ আদেশ রয়েছে। উপরে বা আরও বিশদ ব্যাখ্যার জন্য নিবন্ধটি দেখুন, নীচে আপনি যদি আরও কিছুটা স্পট-ইট তৈরি করতে চান তবে :-)

$ time pg2 8
elements in field: 8
  0. (1, 9, 17, 25, 33, 41, 49, 57, 65)
  1. (0, 9, 10, 11, 12, 13, 14, 15, 16)
  2. (2, 9, 18, 27, 36, 45, 54, 63, 72)
  3. (6, 9, 22, 26, 37, 43, 56, 60, 71)
  4. (7, 9, 23, 32, 34, 46, 52, 59, 69)
  5. (8, 9, 24, 30, 35, 42, 55, 61, 68)
  6. (3, 9, 19, 29, 39, 44, 50, 64, 70)
  7. (4, 9, 20, 31, 38, 48, 53, 58, 67)
  8. (5, 9, 21, 28, 40, 47, 51, 62, 66)
  9. (0, 1, 2, 3, 4, 5, 6, 7, 8)
 10. (1, 10, 18, 26, 34, 42, 50, 58, 66)
 11. (1, 14, 22, 30, 38, 46, 54, 62, 70)
 12. (1, 15, 23, 31, 39, 47, 55, 63, 71)
 13. (1, 16, 24, 32, 40, 48, 56, 64, 72)
 14. (1, 11, 19, 27, 35, 43, 51, 59, 67)
 15. (1, 12, 20, 28, 36, 44, 52, 60, 68)
 16. (1, 13, 21, 29, 37, 45, 53, 61, 69)
 17. (0, 17, 18, 19, 20, 21, 22, 23, 24)
 18. (2, 10, 17, 28, 35, 46, 53, 64, 71)
 19. (6, 14, 17, 29, 34, 48, 51, 63, 68)
 20. (7, 15, 17, 26, 40, 44, 54, 61, 67)
 21. (8, 16, 17, 27, 38, 47, 50, 60, 69)
 22. (3, 11, 17, 31, 37, 42, 52, 62, 72)
 23. (4, 12, 17, 30, 39, 45, 56, 59, 66)
 24. (5, 13, 17, 32, 36, 43, 55, 58, 70)
 25. (0, 49, 50, 51, 52, 53, 54, 55, 56)
 26. (3, 10, 20, 30, 40, 43, 49, 63, 69)
 27. (2, 14, 21, 32, 39, 42, 49, 60, 67)
 28. (8, 15, 18, 28, 37, 48, 49, 59, 70)
 29. (6, 16, 19, 31, 36, 46, 49, 61, 66)
 30. (5, 11, 23, 26, 38, 45, 49, 64, 68)
 31. (7, 12, 22, 29, 35, 47, 49, 58, 72)
 32. (4, 13, 24, 27, 34, 44, 49, 62, 71)
 33. (0, 57, 58, 59, 60, 61, 62, 63, 64)
 34. (4, 10, 19, 32, 37, 47, 54, 57, 68)
 35. (5, 14, 18, 31, 35, 44, 56, 57, 69)
 36. (2, 15, 24, 29, 38, 43, 52, 57, 66)
 37. (3, 16, 22, 28, 34, 45, 55, 57, 67)
 38. (7, 11, 21, 30, 36, 48, 50, 57, 71)
 39. (6, 12, 23, 27, 40, 42, 53, 57, 70)
 40. (8, 13, 20, 26, 39, 46, 51, 57, 72)
 41. (0, 65, 66, 67, 68, 69, 70, 71, 72)
 42. (5, 10, 22, 27, 39, 48, 52, 61, 65)
 43. (3, 14, 24, 26, 36, 47, 53, 59, 65)
 44. (6, 15, 20, 32, 35, 45, 50, 62, 65)
 45. (2, 16, 23, 30, 37, 44, 51, 58, 65)
 46. (4, 11, 18, 29, 40, 46, 55, 60, 65)
 47. (8, 12, 21, 31, 34, 43, 54, 64, 65)
 48. (7, 13, 19, 28, 38, 42, 56, 63, 65)
 49. (0, 25, 26, 27, 28, 29, 30, 31, 32)
 50. (6, 10, 21, 25, 38, 44, 55, 59, 72)
 51. (8, 14, 19, 25, 40, 45, 52, 58, 71)
 52. (4, 15, 22, 25, 36, 42, 51, 64, 69)
 53. (7, 16, 18, 25, 39, 43, 53, 62, 68)
 54. (2, 11, 20, 25, 34, 47, 56, 61, 70)
 55. (5, 12, 24, 25, 37, 46, 50, 63, 67)
 56. (3, 13, 23, 25, 35, 48, 54, 60, 66)
 57. (0, 33, 34, 35, 36, 37, 38, 39, 40)
 58. (7, 10, 24, 31, 33, 45, 51, 60, 70)
 59. (4, 14, 23, 28, 33, 43, 50, 61, 72)
 60. (3, 15, 21, 27, 33, 46, 56, 58, 68)
 61. (5, 16, 20, 29, 33, 42, 54, 59, 71)
 62. (8, 11, 22, 32, 33, 44, 53, 63, 66)
 63. (2, 12, 19, 26, 33, 48, 55, 62, 69)
 64. (6, 13, 18, 30, 33, 47, 52, 64, 67)
 65. (0, 41, 42, 43, 44, 45, 46, 47, 48)
 66. (8, 10, 23, 29, 36, 41, 56, 62, 67)
 67. (7, 14, 20, 27, 37, 41, 55, 64, 66)
 68. (5, 15, 19, 30, 34, 41, 53, 60, 72)
 69. (4, 16, 21, 26, 35, 41, 52, 63, 70)
 70. (6, 11, 24, 28, 39, 41, 54, 58, 69)
 71. (3, 12, 18, 32, 38, 41, 51, 61, 71)
 72. (2, 13, 22, 31, 40, 41, 50, 59, 68)
errors in check: 0

real    0m0.303s
user    0m0.200s
sys 0m0.016s

থেকে প্রতিটি শনাক্তকারী 0করতে 72উভয় একটি কার্ড শনাক্তকারী হিসাবে এবং একটি ছবি শনাক্তকারী হিসাবে পড়া যায়। উদাহরণস্বরূপ, শেষ সারিটির অর্থ এটি:

  • কার্ড 72রয়েছে ছবি 2, 13, 22, ..., 59, 68, এবং
  • ছবি 72কার্ড দেখা 2, 13, 22, ..., 59, এবং 68
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.