তিনটি বর্ণ একটি "গডেল-এসচার-বাচ কিউব" তৈরি করতে পারে কিনা তা পরীক্ষা করুন

Question

এই প্রশ্নটি "গডেল, এসচার, বাচ" বইয়ের প্রচ্ছদে অনুপ্রাণিত হয়েছে:

এখানে চ্যালেঞ্জটি হ'ল একটি ফাংশন লিখুন যা জানায় যে প্রদত্ত তিনটি চিঠি একটি 3 ডি ভাস্কর্য তৈরি করতে পারে যা তিন দিক থেকে পড়া যায়।

এই অনুশীলনের জন্য, আপনি কেবলমাত্র অক্ষরগুলি 26 5px * 5px বিটম্যাপ ব্যবহার করতে পারেন:

বা বাইনারি (এ টু জেড):

01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111

ভাস্কর্যটি নিম্নলিখিত ক্রমে তিনটি বর্ণ দ্বারা গঠিত:

• উপরে একটি চিঠি,
• বাম দিকে দুটি অক্ষর
• ডানদিকে তিনটি অক্ষর
• একটি বর্ণের নীচের অংশটি দুটি বর্ণের শীর্ষে আবদ্ধ।

উদাহরণ:

আপনার ফাংশনটি ইনপুট হিসাবে তিনটি বড় হাতের অক্ষর (তিন অক্ষর বা একটি বর্ণের তিনটি স্ট্রিং) হিসাবে গ্রহণ করতে পারে এবং একটি বুলিয়ান আউটপুট (সত্য / মিথ্যা বা 0/1) প্রাসঙ্গিক ভাস্কর্য থাকতে পারে কিনা তা জানিয়ে দিতে পারে output

উদাহরণ:

f("B","E","G") // true  (because if you "sculpt out" B on top + E on the left + G on the right, and watch the three sides of the sculpture, you'll see exactly B, E and G as they are defined)
f("B","G","E") // false (because if you "sculpt out" B on top + G on the left + E on the right, and watch the three sides of the sculpture, you won't see a complete G and a complete E. Their shapes bother each other)

এনবি: আপনি ভাস্কর্যটিতে "ফ্লাইং পিক্সেল" (কিউবস বা কিউবের গ্রুপ যা কিছুতেই সংযুক্ত নয়) থাকলেও আপনি সত্য ফিরে আসতে পারেন return

স্ট্যান্ডার্ড লুফোলস প্রযোজ্য।

আরও স্পষ্টভাবে, আপনি তিনটি বর্ণ ছাড়াও বাহ্যিক ইনপুট ব্যবহার করতে পারবেন না এবং আপনি আপনার উত্স কোডে 17576 এর উত্তরগুলি হার্ডকোড করতে পারবেন না

যে কোনও ভাষার ভাষায় স্বল্পতম উত্তর!

আনন্দ কর :)

Comments

আপনি ছেলেরা আমাকে মজা করতে হবে।

— মার্টিন এন্ডার

হ্যাঁ, এটি এমইউ ধাঁধা যা আমাকে বইটি আবিষ্কার করতে বাধ্য করেছিল এবং এটিই বইটির প্রচ্ছদ যা আমাকে এই চ্যালেঞ্জ সম্পর্কে ভাবতে বাধ্য করে। একটি সমস্যা আছে? এটি কি আপনার 18 টি গর্তের অংশ ছিল?

— xem

এটি 1 গর্ত প্রতিস্থাপন করার জন্য একটি ভাল বিকল্প হতে পারে।;) ... কিছু মনে করবেন না, কিছু তাড়াতাড়ি কিছু না উঠার জন্য এটি আমার দোষ। এটি একটি সত্যিই শালীন চ্যালেঞ্জ, +1!

— মার্টিন ইন্ডার

আমরা কি কোনও বাহ্যিক ফাইল থেকে অক্ষরের আকারগুলি সংজ্ঞায়িত করে ডেটা পুনরুদ্ধার করতে পারি, বা এটিকে উত্সেও অন্তর্ভুক্ত করা দরকার?

— সিসিয়ামলাইফ জ্যাকেট

আপনার বাইনারি বি এর উপরের বাম কোণে 0 রয়েছে, 1 নয়

— ক্যালভিনের

Answer 1

গণিত 423

আমি "ব্লকিং কীভাবে কাজ করে" নামে একটি বিভাগ যুক্ত করেছি।

Ungolfed

(* বর্ণমালার বাইনারি ডেটা একটি একক স্ট্রিং হিসেবে সংরক্ষণ করা হয় s। varsএকটি অ্যারের মধ্যে আমদানি এবং এটি এটি পরিবর্তন করে।)

vars=IntegerDigits[#,10,5]&/@Transpose[ImportString[s,"Table"]];
get[char_]:=(ToCharacterCode[char]-64)[[1]];
cube=Flatten[Table[{i,j,k},{i,5},{j,5},{k,5}],2];

(* character slice along axis *)
slice[char_,layer_,axis_,bit_]:=Insert[(Reverse@#),layer,axis]&/@Position[Reverse@vars[[get[char]]],bit]

(* cuboid assembly  *)
charBlocks[{char_,axis_,bit_}]:=Flatten[Table[slice[char,k,axis,bit],{k,5}],1]

(* letters are those whose HOLES should be sculped out of the full cube *)
sculpturePoints[letters_(*{char_,axis_,bit_}*)]:=Complement[cube,Union[Join@@(charBlocks/@letters(*{char,axis,bit}*))]];

collapse[letters_(*{char_,axis_,bit_}*),axis_]:=Union[Reverse/@(Delete[#,axis]&/@sculpturePoints[letters(*{char,axis,bit}*)])](*/.{x_,y_}\[RuleDelayed] {6-x,y}*)

vQ[l_]:=collapse[l,3]==collapse[{l[[1]]},3]\[And]collapse[l,2]==collapse[{l[[2]]},2]\[And]collapse[l,1]==collapse[{l[[3]]},1]

validQ@l_:= vQ[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]


perspective[letts_,view_:1]:=
Graphics3D[{AbsolutePointSize[10],Cuboid/@sculpturePoints[letts]},
ImageSize-> 120,
ViewPoint-> Switch[view,1,{0,0,\[Infinity]},2,{0,-\[Infinity],0},3,{\[Infinity],0,0},4,Top,5,Front,6,Right,True,{0,0,\[Infinity]}],
PlotLabel-> Switch[view,1,"top orthogonal view",2,"front orthogonal view",3,"right orthogonal view",4,"top close-up view",5,"front close-up view",6,"right close-up view"],
ImagePadding->10]

---

উদাহরণ

কিউব {"B", "G", "E"}বৈধ? (অর্থাত তিনটি অক্ষর দেওয়ালের উপরে সঠিকভাবে প্রজেক্ট করবে?)

validQ[{"B", "G", "E"}]

মিথ্যা

কনটেন্ট কপিরাইট আইনে পূর্বানুমতি

নীচের পরিসংখ্যানগুলি দেখায় যে কীভাবে বিজিই রেন্ডার করা হয়। পরিসংখ্যানগুলির উপরের সারিটি অরথোগোনাল দৃষ্টিভঙ্গি গ্রহণ করে, যেন দর্শক কিউব থেকে অসীম দূরত্বে অবস্থান করে। নীচের সারিটি দেখায় যে ব্লকগুলি বন্ধ থেকে কীভাবে দেখাবে। পৃথক ইউনিট কিউবস কোথায় অবস্থিত তা সুনির্দিষ্টভাবে পরিদর্শন করতে 3D চিত্রগুলি ম্যানুয়ালি ঘোরানো যেতে পারে।

"জি" অক্ষরটি নিয়ে একটি সমস্যা দেখা দেয়। বাকি চিঠির সাথে সেরিফের সংযোগ করার কিছুই নেই।

pts = {{"B", 3, 0}, {"G", 2, 0}, {"E", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts, view], {view, 1, 6}], 3]

---

বিইজি অবশ্য ঠিকঠাক কাজ করা উচিত।

 validQ[{"B", "E", "G"}]

সত্য

pts2 = {{"B", 3, 0}, {"E", 2, 0}, {"G", 1, 0}}
GraphicsGrid@Partition[Table[perspective[pts2, view], {view, 1, 6}], 3]

---

ব্লকিং কীভাবে কাজ করে?

দয়া করে এটি স্পষ্ট মনে হলে ক্ষমা করুন, তবে সম্ভবত কিছু লোকেরা কীভাবে অক্ষরগুলি একে অপরের সাথে হস্তক্ষেপ করে, তাদের 3 ডি পিক্সেল বাতিল করে তা কল্পনা করতে চায়।

বিজিই কিউব রেন্ডারিংয়ে জি বর্ণটি কী ঘটে তা অনুসরণ করা যাক।

আমরা নীচে ভক্সেল (3 ডি পিক্সেল বা ইউনিট কিউব) এর দিকে বিশেষ মনোযোগ দিচ্ছি । এটি সেই পিক্সেল যা বিজিই কিউবে অদৃশ্য হয়ে যায়। এটি পিক্সেলটি সারি 4, বিট অ্যারেতে কলাম 5 এবং সংশ্লিষ্ট অ্যারে প্লটের সাথে সম্পর্কিত।

---

এক্সআই প্লেনে পিক্সেলটি ধূসর ডিস্কের সাথে বিন্দুতে (5,2) মিলবে। তবে যেহেতু আমরা 3D তে কাজ করতে যাচ্ছি, তাই আমাদের খাদের 5 টি অবস্থান (5,1,2) থেকে (5,5,2) বিবেচনা করা উচিত। যদি এই পিক্সেলগুলির মধ্যে কোনও বি এবং ই বর্ণগুলি দ্বারা ভাস্কর্যে বেঁচে থাকে, আমরা প্রাচীরের 3 ডি প্রজেকশনটিতে পিক্সেলটির আগ্রহ দেখতে পাব।

---

শক্ত ব্লক থেকে পিক্সেল সরানো হলে চিঠিগুলি হস্তক্ষেপ করে। বামদিকে, কালো তীরটি ডানদিকে নীচের ডানদিকে অবস্থিত, পিক্সেলগুলির খোদাই করা প্রতিনিধিত্ব করে; বি বর্ণটির জন্য এটির মান 0 রয়েছে কার্ভআউট আউট পিক্সেলটি সরানো হয়েছে (5,1,2), সরাসরি উপরে এবং নীচের অংশগুলির সাথে। চার পিক্সেল হিসাবে গণনা করা বাকি।

তবে ডান ফলকটি দেখায়, E অক্ষরটি বাকী পিক্সেলের সুদের, (5,2,2) (5,3,2), (5,4,2) এবং (5,5,2) বিভক্ত করে। (এটি এই কারণে যে E অক্ষরটি চতুর্থ সারিতে 0 এর সমান বিট রয়েছে, কলাম 2 থেকে কলাম 5 এর মধ্যে রয়েছে) ফলস্বরূপ, বিন্দুতে ছায়া নিশ্চিত করার জন্য যে পিক্সেল প্রয়োজন ছিল তাদের মধ্যে একটিও পিক্সেল নেই ( , 2) দূর প্রাচীরের (চিঠি জি এর জন্য)। পরিবর্তে, জি বর্ণের একটি গর্তের সাথে মিলিত একটি উজ্জ্বল স্পট থাকবে! কিউব বিজিই কোনও ভাল নয় কারণ এটি ভুলভাবে জি রেন্ডার করে।

গল্ফড 423 টি চর

ফাংশনটি অ-গল্ফড কোডের hমতো একই ভূমিকা পালন করেছিল validQ। উপস্থাপনা ফাংশন,, perspectiveঅন্তর্ভুক্ত করা হয় না কারণ এটি চ্যালেঞ্জটিতে অবদান রাখে না এবং এটির প্রয়োজন হয় না।

x=Reverse;q=Flatten;
g@c_:=(ToCharacterCode[c]-64)[[1]];
r[{c_,a_,b_}]:=q[Table[Insert[(x@#),k,a]&/@Position[x@(IntegerDigits[#,10,5]&/@
Transpose[ImportString[s,"Table"]])[[g[c]]],b],{k,5}],1]
p@l_:=Complement[q[Table[{i,j,k},{i,5},{j,5},{k,5}],2],Union[Join@@(r/@l)]];
w[l_,a_]:=Union[x/@(Delete[#,a]&/@p[l])]
v@l_:=w[l,3]==w[{l[[1]]},3]\[And]w[l,2]==w[{l[[2]]},2]\[And]w[l,1]==w[{l[[3]]},1]

h@l_:= v[{{l[[1]],3,0},{l[[2]],2,0},{l[[3]],1,0}}]

Comments

ওহো, এই 3 ডি ভিউগুলি খুব ঝরঝরে! আপনি কি নিশ্চিত যে শেষ কোড ব্লকটি "আনগল্ফড"? এটা আমার মনে হয়। :)

— xem

আপনি সঠিক. চূড়ান্ত ব্লক গল্ফ হয়। আমি শিরোনাম সংশোধন করেছি। 3 ডি ভিউ সম্পর্কে একটি দুর্দান্ত জিনিস হ'ল এগুলি ইন্টারেক্টিভ: আবর্তন এবং জুমিং মাউস দ্বারা করা যেতে পারে।

— ডেভিডসি

বিটিডাব্লু, আমার গণনা অনুসারে, 15600 সম্ভাব্য অনুমতিের মধ্যে 564 টি বৈধ কিউব রয়েছে।

— ডেভিডসি

এটি একটি দুর্দান্ত তথ্য। এটি গণনা করতে আপনার কতক্ষণ সময় লাগল? এছাড়াও, 26 * 26 * 26 = 17576, 15600 নয় Or অথবা আমি কিছু অনুপস্থিত?

— xem

আমি আদেশ ব্যবহার করি, টিপলস না; অর্থাত্ কোন পুনরাবৃত্তি অক্ষর। 26 * 25 * 24 = 15600। ৫4৪ টি মামলা খুঁজে পেতে এটি 21 সেকেন্ড সময় নিয়েছিল।

— ডেভিডসি

Answer 2

প্রোলগ, 440 , 414

:- encoding(utf8).
i(I) :- between(0,4,I).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),I is 4-X,c(T,Z,I),c(L,Z,Y),c(R,X,Y).
f(T,L,R) :- forall((i(U),i(V),I is 4-V),((\+c(T,U,V);h(T,L,R,I,Y,U)),(\+c(L,U,V);h(T,L,R,X,V,U)),(\+c(R,U,V);h(T,L,R,U,V,Z)))).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

প্রোগ্রামটিকে এভাবে বলা হয়:

?- f('B','E','G').
true.
?- f('B','G','E').
false.

Prologপ্রথম অর্ডার যুক্তিতে সমস্যাটি উপস্থাপন করা সহজ হওয়ার কারণে এটি একটি ভাল পছন্দ বলে মনে হয়েছিল। এছাড়াও Prologসমস্যা এই ধরনের সমাধানের জন্য ক্ষমতাশালী কার্যকারিতা প্রদান করে।

তবে কোডটি যেহেতু গল্ফড, তাই আমি অনুমান করি যে আমার কিছু ব্যাখ্যা যুক্ত করা উচিত।

হালকা গল্ফ সংস্করণ

:- encoding(utf8).
i(I) :- between(0,4,I).
t(C,X,Z) :- I is 4-X,c(C,Z,I).
l(C,Y,Z) :- c(C,Z,Y).
r(C,X,Y) :- c(C,X,Y).
h(T,L,R,X,Y,Z) :- i(X),i(Y),i(Z),t(T,X,Z),l(L,Y,Z),r(R,X,Y).
u(T,L,R) :- forall((i(U),i(V),I is 4-V,c(T,U,V)),h(T,L,R,I,Y,U)).
v(T,L,R) :- forall((i(U),i(V),c(L,U,V)),h(T,L,R,X,V,U)).
w(T,L,R) :- forall((i(U),i(V),c(R,U,V)),h(T,L,R,U,V,Z)).
f(T,L,R) :- u(T,L,R),v(T,L,R),w(T,L,R).
c(C,X,Y) :- char_code(C,N),i(X),i(Y),Z is X+5*Y+25*(N-65),I is floor(Z/15),O is (Z mod 15),string_code(I,"䙎㹟䘑߯硁䙏縑ԁࠟя摟䠑䠑ᐑ粤Ⴟ䔅┉ё籁垑䙑曓䗱㩑䙏㡏晑䘞䕟㡞縐Ⴄ䙄㩑⩑䒪噑⩊䕤ᅱ粤ࢨ?",V),1 is (V-32)>>O/\1.

পাশের প্রতিটি পাশের পিক্সেলের সাথে সম্পর্কিত স্থানাঙ্কগুলি সহজেই একটি 3 ডি স্থানাঙ্ক সিস্টেমে রূপান্তরিত করা যায়। আমি ব্যবহার T, Lএবং Rশীর্ষ (1) জন্য, (2) এবং অধিকার (3) পাশ ত্যাগ করেন। uএবং vচিত্রগুলিতে স্থানাঙ্কের জন্য ব্যবহৃত হয়:

• টি :(u,v) -> (4-v, ?, u)
• এল :(u,v) -> (?, v, u)
• আর :(u,v) -> (u, v, ?)

প্রতিটি অ্যাক্টিভ (অর্থাত্ কালো) পিক্সেলের ফলাফলগুলি "3 ডি-পিক্সেল" এর সংগে সংযুক্ত করা হয় যা এই দিক থেকে অবজেক্টের চেহারা পরিবর্তন না করেই তীব্র করা যায়। প্রতিটি পক্ষের জন্য সেটগুলির ছেদটি সমস্ত 3 ডি-পিক্সেল, যা পিক্সেলগুলি যুক্ত না করে সক্রিয় করা যেতে পারে, যা দর্শনকে বাধা দেয় (অর্থাত্ কমপক্ষে এক দিক থেকে সন্ধান করলে সেখানে একটি পিক্সেল থাকবে না)।

যে সমস্ত অবশিষ্ট রয়েছে তা প্রতিটি পক্ষের জন্য যাচাই করা, যদি ছেদ করে কোনও পিক্সেল রয়েছে যা ভিউটি ব্লক করে, যেখানে এটি প্রয়োজনীয়।

এটি প্রোগ্রামে পূর্বাভাসের দিকে নিয়ে যায়:

• চ : চূড়ান্ত চেক করে; উপরের অক্ষর, বাম দিকে এবং ডানদিকে নেয়
• ইউ , ভি এবং ডাবলু : চেকগুলি করুন, যদি পাশের প্রতিটি পিক্সেলের জন্য সক্রিয় থাকে তবে ছেদক স্থানে একটি 3 ডি-পিক্সেল থাকে যা দর্শনটিকে অবরুদ্ধ করে দেয়
• এইচ : চেক করুন, মোড়ে একটি পিক্সেলের অস্তিত্বের জন্য
• t , l , r : চেকস, যদি কোনও 3 ডি-পিক্সেল উপরে, বাম এবং ডান দিক থেকে অবরুদ্ধ করা যায়।

• সি : একটি চিঠির চিত্রের পিক্সেলের জন্য পরীক্ষা করে। সেখানকার স্ট্রিংটি কিছুটা অদ্ভুত লাগতে পারে তবে এটি চিত্রের ডেটা সঞ্চয় করার একটি কমপ্যাক্ট উপায়। এটি কেবল নীচের মানগুলির সাথে একটি অক্ষরের অনুক্রম (হেক্স নোটেশন):

  [464e,3e5f,4611,7ef,7841,464f,7e11,501,81f,44f,645f,4811,4811,1411,7ca4,10bf,4505,2509,451,7c41,5791,4651,66d3,45f1,3a51,464f,384f,6651,461e,455f,385e,7e10,10a4,4644,3a51,2a51,44aa,5651,2a4a,4564,1171,7ca4,8a8,3f]
  

  এই অক্ষরের প্রতিটি অক্ষর চিত্র (গুলি) (= 15 পিক্সেল) 3 পিক্সেল সারি জন্য ডেটা সঞ্চয় করে। পিক্সেলগুলিও পুনরায় অর্ডার করা হয় যাতে তথ্যটি এক জায়গায় সংরক্ষণ করা হয় এবং ওপির ডেটার মতো একাধিক সারি জুড়ে বিভক্ত হয় না।

গাণিতিক সূত্র

তথ্য অন্তর্ভুক্তী

এক চরে পিক্সেল থেকে রূপান্তর 3 ডি-পিক্সেল সেট করে যা এই পিক্সেলের জন্য দর্শনকে বাধা দেয়

নিরাপদে যুক্ত করা যায় এমন পিক্সেল (ভুল জায়গায় দর্শন ব্যাহত না করে)

প্রতিটি পক্ষের জন্য পরীক্ষা করে দেখুন যে পিক্সেলগুলিকে বাধা দেওয়া দরকার তা নিরাপদে বাধা দেওয়া যেতে পারে

প্রতিটি পক্ষের জন্য চেকের সম্মিলন

Comments

আমি .. আহ .. কি? আমি এই বোধগম্য। (+1 টি)

— seequ

পবিত্র ... আমি শুতে যাচ্ছি ...

— ব্রুনোজে

চিত্তাকর্ষক! এই উত্তরের জন্য ধন্যবাদ

— xem

খুশী হলাম। বিটিডব্লিউ, আমি প্রক্রিয়াটি একটি কঠিন ঘনকোষ দিয়ে শুরু হিসাবে মনে করি। (আপনি এটিকে পিক্সেল যুক্ত হিসাবে ভাবেন বলে মনে হয় যেখানে আগে কখনও ছিল না)) প্রতিটি অক্ষর সেই ব্লক থেকে কিছু 3D পিক্সেল সরিয়ে দেয়। সুতরাং হস্তক্ষেপ দেখা দেয় যখন প্রতিবেশী কোনও চিঠি পিক্সেলগুলি সরিয়ে দেয় যা একটি চিঠি "রাখতে চায়"। হস্তক্ষেপটি অতিরিক্ত পিক্সেলের পরিবর্তে "অনুপস্থিত পিক্সেল" থেকে আসে।

— ডেভিডসি

Answer 3

জে - 223 197 191 চর

আর্গুমেন্ট হিসাবে তিনটি চর তালিকা নিয়ে ফাংশন।

(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:

এই গল্ফ জে নামক র‌্যাঙ্কের একটি শক্তিশালী বৈশিষ্ট্যটির উপর প্রচুর নির্ভর করে যা আমাদের জন্য "ভাস্কর্য আউট" এবং "নিখরচায়িত" অপারেশন প্রায় বিনামূল্যে দেয়। এটিকে কিছুটা বড় করে দেখানোর জন্য, র‌্যাঙ্ক একটি বিশেষ্য বা ক্রিয়াটির প্রাকৃতিক যুক্তিগুলির মাত্রিকতা বোঝায়।

জে বহুমাত্রিক অ্যারে রয়েছে এবং এটি স্পষ্ট যে, বলুন যে, 3 ডি অ্যারেটিকে একটি একক 3 ডি অ্যারে হিসাবে ব্যাখ্যা করা যেতে পারে, বা ম্যাট্রিকের একটি তালিকা হিসাবে, বা ভেক্টরগুলির 2 ডি অ্যারে বা স্কেলারগুলির 3 ডি অ্যারে হিসাবে ব্যাখ্যা করা যেতে পারে। সুতরাং জেতে প্রতিটি অপারেশনে এর প্রয়োগ নিয়ন্ত্রিত থাকতে পারে কীভাবে যুক্তি ছড়িয়ে দেওয়া যায়। র‌্যাঙ্ক 0 এর অর্থ স্কেলারের উপর প্রয়োগ করা, 1 নম্বর মানে ভেক্টরগুলিতে প্রয়োগ করা ইত্যাদি and

   1 + 2 + 3 + 4  NB. add these things together
10
   +/ 1 2 3 4     NB. sum the list by adding its items together
10
   i. 3 4         NB. 2D array, with shape 3-by-4
0 1  2  3
4 5  6  7
8 9 10 11
   +/"2 i. 3 4    NB. add the items of the matrix together
12 15 18 21
   0 1 2 3 + 4 5 6 7 + 8 9 10 11    NB. equivalent
12 15 18 21
   +/"1 i. 3 4    NB. now sum each vector!
6 22 38
   +/"0 i. 3 4    NB. now sum each scalar!
0 1  2  3
4 5  6  7
8 9 10 11

এটি যখন আপনি ডায়াডিক (দ্বি-যুক্তি) ফাংশনগুলি প্রবর্তন করেন তখন এটি খুব শক্তিশালী হয়ে ওঠে, কারণ যদি দুটি আর্গুমেন্টের আকার (র‍্যাঙ্কের জন্য অ্যাকাউন্টিংয়ের পরে) রাজি হয় তবে জে কিছু অন্তর্নিহিত লুপিং করবেন:

   10 + 1             NB. scalar addition
11
   10 20 30 + 4 5 6   NB. vector addition, pointwise
14 25 36
   10 + 4 5 6         NB. looping! 
14 15 16
   10 20 + 4 5 6      NB. shapes do not agree...
|length error
|   10 20    +4 5 6

যখন আপনার সমস্ত আকার সম্মত হয় এবং আপনি নিজেই র‌্যাঙ্কটি নির্দিষ্ট করতে পারেন, তর্কগুলি একত্রিত করার অনেকগুলি উপায় রয়েছে। এখানে আমরা কয়েকটি উপায় দেখিয়েছি যে আপনি 2 ডি ম্যাট্রিক্স এবং 3 ডি অ্যারের গুণ করতে পারেন।

   n =: i. 5 5
   n
 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
   <"2 n *"2 (5 5 5 $ 1)  NB. multiply by 2-cells
+--------------+--------------+--------------+--------------+--------------+
| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4| 0  1  2  3  4|
| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9| 5  6  7  8  9|
|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|10 11 12 13 14|
|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|15 16 17 18 19|
|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|20 21 22 23 24|
+--------------+--------------+--------------+--------------+--------------+
   <"2 n *"1 (5 5 5 $ 1)  NB. multiply by vectors
+---------+---------+--------------+--------------+--------------+
|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|
|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|
|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|
|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|
|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|
+---------+---------+--------------+--------------+--------------+
   <"2 n *"0 (5 5 5 $ 1)  NB. multiply by scalars
+---------+---------+--------------+--------------+--------------+
|0 0 0 0 0|5 5 5 5 5|10 10 10 10 10|15 15 15 15 15|20 20 20 20 20|
|1 1 1 1 1|6 6 6 6 6|11 11 11 11 11|16 16 16 16 16|21 21 21 21 21|
|2 2 2 2 2|7 7 7 7 7|12 12 12 12 12|17 17 17 17 17|22 22 22 22 22|
|3 3 3 3 3|8 8 8 8 8|13 13 13 13 13|18 18 18 18 18|23 23 23 23 23|
|4 4 4 4 4|9 9 9 9 9|14 14 14 14 14|19 19 19 19 19|24 24 24 24 24|
+---------+---------+--------------+--------------+--------------+

আপনি লক্ষ্য করবেন যে এটি প্রশ্নটি যে ধরণের অভিমুখীকরণের চিঠিতে খোদাই করে না, এটি কেবল তাদের লেখায় তবে র‌্যাঙ্ক যুক্তির পক্ষে সুবিধাজনক। অক্ষরগুলিকে প্রয়োগ করার আগে আমরা উল্টো বা ঘোরানো না হলে এটি সঠিকভাবে কাজ করবে না। তবে এর মতো জিনিসগুলি সংশোধন করা মূল্যবান চরিত্রগুলি গ্রহণ করতে পারে, সুতরাং পরিবর্তে আমরা এই জাতীয় অক্ষরগুলি এনকোড করব, যখন জে প্রাকৃতিকভাবে তাদের খোদাই করবে তখন কিছু ত্রিগুণ মুখগুলি সঠিক দিকনির্দেশ এবং আপেক্ষিক অবস্থানে থাকবে। এটি সংক্ষিপ্ততম সমাধানটি হ'ল সমস্ত লেটারফর্মগুলি একটি চতুর্থাংশ-পাল্টা ঘড়ির কাঁটার দিকে ঘোরানো। সামনের থেকে পিছনে অক্ষটি উপস্থাপনের জন্য জেদের তৃতীয় মাত্রা বিবেচনা করে, নীচে অপরিশোধিত চিত্রটি দেখায় যে এই প্রকল্পটি কেন কাজ করে।

_{চিত্র এ: জে ঘনক্ষেত্রের তিনটি দিক। চিত্র বি: যে তিনটি পক্ষেই প্রশ্নগুলি জিজ্ঞাসার মতো বর্ণগুলি কেন্দ্রিক রয়েছে have}

এনকোডিংয়ের এই পছন্দটি আগের পদ্ধতির চেয়ে 12 টি অক্ষর সংরক্ষণ করে এবং পুরো জিনিসটি আরও সুন্দর করে তোলে। আসল গল্ফটি কিউবটিকে বাইরে থেকে বাইরে তৈরি করে "1এবং "2কোনও সম্পর্কযুক্ত অপ্টিমাইজেশনের কারণে কিছু মজাদার যুক্তি দিয়ে খোদাই করে।

তারপরে আমাদের মুখগুলি পরীক্ষা করতে হবে। যেহেতু আমরা 1s এবং 0 সেঃ যেমন ব্লক এনকোড, আমরা শুধু আমরা যেভাবে চাই (এগুলো প্রতিটি অক্ষ বরাবর যোগফল করতে +/"1, +/"2এবং +/বিট), Booleans (সমন্বয় 0<), এবং তারপর তাদের মূল 90 সব সরাসরি তুলনা ° - পরিণত-অক্ষর।

সংক্ষেপণ স্কিমটি বাইনারি সংখ্যার 32 টি বেস উপস্থাপনা হিসাবে প্রতিটি বর্ণের প্রতিটি 5px সারি এনকোড করে। বেশ কয়েকটি সিনট্যাকটিক সুগার এবং অপারেটর ওভারলোডিংগুলি ".'1b',"#:ব্যবহার করে অক্ষরের তালিকাকে বেস 36 সংখ্যায় পরিণত করার সবচেয়ে সংক্ষিপ্ততম উপায়। ভাল, প্রযুক্তিগতভাবে, বেস 32, কিন্তু জে মনে করে এটি অবিচ্ছিন্ন, সুতরাং কে গণনা করছে?

ব্যবহার নীচে। নোট করুন যে স্ট্রিংগুলি জেতে অক্ষর অ্যারে, সুতরাং একটি তিনটি আইটেমের তালিকা সংক্ষেপে 'A','B','C'লেখা যেতে পারে 'ABC'। এছাড়াও, বুলিয়ানগুলি 1/0 হয়।

   NB. can be used inline...
   (_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:'BEG'
1
   NB. or assigned to a name
   geb=:(_5#:\".'1b',"#:'fiiifalllvhhhheehhhvhhllvgkkkvnlhhvv444vhhvhhggvhjha44v1111vv848vv248vehhheciiivfjhhedmkkvilll9ggvggu111uo616ou121uha4ahg878ghpljh')((-:0<+/"1,+/"2,:+/)*`(*"1/)/)@:{~_65+3&u:
   geb 'BGE'
0

Answer 4

পাইথন, 687 682 671

import itertools as t,bz2
s=range(5)
c=dict([(i,1)for i in t.product(*3*[s])])
z=dict([(chr(i+65),[map(int,bz2.decompress('QlpoOTFBWSZTWXndUmsAATjYAGAQQABgADABGkAlPJU0GACEkjwP0TQlK9lxsG7aomrsbpyyosGdpR6HFVZM8bntihQctsSiOLrWKHHuO7ueAyiR6zRgxbMOLU2IQyhAEAdIJYB0ITlZwUqUlAzEylBsw41g9JyLx6RdFFDQEVJMBTQUcoH0DEPQ8hBhXBIYkXDmCF6E/F3JFOFCQed1Saw='.decode('base64')).split('\n')[j].split()[i])for j in s])for i in range(26)])
def m(a,g):
 for e in c:c[e]&=g[e[a]][e[a-2]]
def f(a):
 g=map(list,[[0]*5]*5)
 for e in c:g[e[a]][e[a-2]]|=c[e]
 return g
r=lambda g:map(list,zip(*g)[::-1])
def v(T,L,R):T,L,R=r(r(z[T])),r(z[L]),z[R];m(1,T);m(2,L);m(0,R);return(T,L,R)==(f(1),f(2),f(0))

সাথে কল করুন v:

v('B','E','G') => True
v('B','G','E') => False

নীচের সমস্ত কিছুই আমার আগের অলগল্ফড সংস্করণ থেকে এসেছে যার মধ্যে সহায়ক অঙ্কনের কাজ রয়েছে includes এটিকে জাম্পিং পয়েন্ট হিসাবে নির্দ্বিধায় ব্যবহার করুন।

import string as s
import itertools as t

az = """01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111""".split('\n')

dim = range(len(az))
az = dict([(c, [map(int, az[j].split()[i]) for j in dim]) for i, c in enumerate(s.uppercase)])
cube = dict([(i, 1) for i in t.product(*3*[dim])])

def mask(axis, grid):
    for c in cube:
        if not grid[c[axis]][c[axis - 2]]:
            cube[c] = 0

def face(axis):
    grid = [[0 for j in dim] for i in dim]
    for c in cube:
        if cube[c]:
            grid[c[axis]][c[axis - 2]] = 1
    return grid

def rot(grid):
    return map(list, zip(*grid)[::-1])

def draw(grid, filled='X', empty=' '):
    s = ''
    for y in dim:
        for x in dim:
            s += filled if grid[y][x] else empty
        s += '\n'
    print s

def drawAll():
    print 'TOP:\n'
    draw(rot(rot(face(1))))
    print 'LEFT:\n'
    draw(rot(rot(rot(face(2)))))
    print 'RIGHT:\n'
    draw(face(0))

def valid(top, left, right):
    top, left, right = rot(rot(az[top])), rot(az[left]), az[right]
    mask(1, top)
    mask(2, left)
    mask(0, right)
    return top == face(1)and left == face(2) and right == face(0)

letters = 'BEG'

if valid(*letters):
    print letters, 'is valid.\n'
else:
    print letters, 'is not valid!\n'

drawAll()

validএটি চালানোর জন্য কল করুন :

valid('B', 'E', 'G') #returns True
valid('B', 'G', 'E') #returns False

এই মুহুর্তে কোডটি সেটআপ করা B E Gহয়েছে যা ফলাফলগুলির মুখগুলির বৈধতা পরীক্ষা করতে এবং মুদ্রণ করতে পারে:

BEG is valid.

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
XXX  
X    
XXXXX

RIGHT:

XXXXX
X    
X  XX
X   X
XXXXX

এটি চালিয়ে B G Eগেলে আমরা দেখতে পাচ্ছি যে জিটি ভুল:

BGE is not valid!

TOP:

XXXX 
X   X
XXXX 
X   X
XXXX 

LEFT:

XXXXX
X    
X  XX
X    
XXXXX

RIGHT:

XXXXX
X    
XXX  
X    
XXXXX

Comments

বাহ, ভাল কাজ! অঙ্কনের জন্য এবং উত্তরটির সম্পূর্ণতার জন্য +1। এই জাতীয় একটি সংক্ষিপ্ত অ্যালগরিদম ব্যবহারের জন্য +1। <3 এটি

— xem

@xem ধন্যবাদ! আমি অবশেষে এটি গল্ফ। যদিও আমি ইউনিকোডের অক্ষরগুলি সংক্ষেপিত করতে bz2 কীভাবে পেতে পারি তা বুঝতে পারি না।

— ক্যালভিনের শখ 9

+1 টি। চমৎকার উত্তর. আশা করি আরও লোকেরা ছোট গল্ফগুলির সমন্বয়ে গঠিত গল্ফগুলিকে উজ্জীবিত করবে, কারণ এটি সত্যই চেষ্টা করে।

— ভেক্টরাইজড

g=[[0 for j in s]for i in s]সংক্ষিপ্ত করা যেতে পারে g=map(list,[[0]*5]*5)। এছাড়াও আপনি ব্লক ইন্ডেন্ট করেও যদি তারা একটি একক বিবৃতি হয় এড়াতে পারেন: if c[e]:g[e[a]][e[a-2]]=1।

— বাকুরিউ

@ বাকুরিউ এবং বিটপউনার, পরামর্শ এবং সম্পাদনাগুলির জন্য ধন্যবাদ :)

— ক্যালভিনের

Answer 5

পাইথন 3 + নমপি, 327 সি

from numpy import*
B=hstack([ord(x)>>i&1for x in'옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'for i in range(16)])[:-6].reshape(26,5,5)
T=transpose
def f(*X):
 A=ones((5,5,5));F=list(zip([A,T(A,(1,0,2)),T(fliplr(A),(2,0,1))],[B[ord(x)-65]for x in X]))
 for r,f in F:r[array([f]*5)==0]=0
 return all([all(r.sum(0)>=f)for r,f in F])

এই গল্ফ সমাধানটির জন্য একটি বাহ্যিক গ্রন্থাগার দরকার, নম্পি, যা বেশ জনপ্রিয় তাই আমি মনে করি এটি ব্যবহার করা ভাল।

ইউনিকোড স্ট্রিংটি ৪১ টি অক্ষরে রয়েছে, যখন @ ফ্যাবিয়ানের প্রলম্ব উত্তরের একই জিনিসটি 44।

এখানে সর্বাধিক আকর্ষণীয় হ'ল নাম্পার অ্যারেটির সূচি। ইন a[ix], ixএকই আকারের সাথে বুলিয়ান অ্যারে হতে পারে a। এটি বলার মতোই a[i, j, k] where ix[i, j, k] == True।

অবহেলিত সংস্করণ

import numpy as np
table = '옮弟ჹ羂옱쏷）ជ࿂︹缘龌ℿ쓥剴ℌᾄ起츱ꎚㆋឺ௣옮忬⧼ﯠႄ挒⺌ꕆ豈ꪱ袨冊䈑∾Ϣ'

def expand_bits(x):
    return [ord(x) >> i & 1 for i in range(16)]

# B.shape = (26, 5, 5), B[i] is the letter image matrix of the i(th) char
B = np.hstack([expand_bits(x) for x in table])[:-6].reshape(26, 5, 5)

def f(*chars):
    """
    cube:    ----------   axis:           
            /         /|      --------->2  
           /   1     / |     /|            
          /         /  |    / |            
         /         /   |   /  |            
        |---------|  3 |  v   |           
        |         |    /  1   |           
        |    2    |   /       v          
        |         |  /        0         
        |         | /                  
        -----------
    """
    cube = np.ones((5, 5, 5))
    cube_views = [
        cube,
        cube.transpose((1, 0, 2)),  # rotate to make face 2 as face 1
        np.fliplr(cube).transpose(2, 0, 1),  # rotate to make face 3 as face 1
    ]
    faces = [B[ord(char) - ord('A')] for char in chars]
    # mark all white pixels as 0 in cube
    for cube_view, face in zip(cube_views, faces):
        # extrude face to create extractor
        extractor = np.array([face] * 5)
        cube_view[extractor == 0] = 0

    return np.all([
        # cube_view.sum(0): sum along the first axis
        np.all(cube_view.sum(0) >= face)
        for cube_view, face in zip(cube_views, faces)
    ])

টেবিলটি সংক্ষেপে স্ক্রিপ্ট করুন

import numpy as np

def make_chars():
    s = """
01110  11110  01111  11110  11111  11111  11111  10001  11111  11111  10001  10000  10001  10001  01110  11110  01110  11110  01111  11111  10001  10001  10001  10001  10001  11111
10001  10001  10000  10001  10000  10000  10000  10001  00100  00100  10010  10000  11011  11001  10001  10001  10001  10001  10000  00100  10001  10001  10001  01010  01010  00010
10001  11110  10000  10001  11100  11110  10011  11111  00100  00100  11100  10000  10101  10101  10001  10001  10001  11111  01110  00100  10001  01010  10001  00100  00100  00100
11111  10001  10000  10001  10000  10000  10001  10001  00100  10100  10010  10000  10001  10011  10001  11110  10011  10010  00001  00100  10001  01010  10101  01010  00100  01000
10001  11110  01111  11110  11111  10000  11111  10001  11111  11100  10001  11111  10001  10001  01110  10000  01111  10001  11110  00100  01110  00100  01010  10001  00100  11111
""".strip().split('\n')
    bits = np.zeros((26, 5, 5), dtype=np.bool)
    for c_id in range(26):
        for i in range(5):
            for j in range(5):
                bits[c_id, i, j] = s[i][j + c_id * 7] == '1'
    bits = np.hstack([bits.flat, [0] * 7])
    bytes_ = bytearray()
    for i in range(0, len(bits) - 8, 8):
        x = 0
        for j in range(8):
            x |= bits[i + j] << j
        bytes_.append(x)
    chars = bytes_.decode('utf16')
    return chars