শীর্ষে-পাশের ধাঁধা সমাধানকারী তৈরি করুন

Question

শীর্ষ-সামনের দিকের ধাঁধাটি এমন একটি ধাঁধা যেখানে আপনাকে তিনটি অরথোগোনাল ভিউ দেওয়া একটি (3 ঘ) সাধারণত ব্লকগুলির 3-ডি আকার তৈরি করতে হবে: একটি শীর্ষ দৃশ্য, একটি সামনের দৃশ্য এবং একটি দিকের দৃশ্য।

উদাহরণস্বরূপ, নীচে উপরে একটি শীর্ষ, সামনের এবং পাশের ভিউ দেওয়া হয়েছে:

Top:        Front:      Side:
. . . .     . . . .     . . . .
. x x .     . x x .     . x x .
. x x .     . x x .     . x x .
. . . .     . . . .     . . . .

In this problem, the side view is taken from the right.

একটি 2x2x2 ঘনক্ষেত্র (ভলিউম 8 সহ) এই সমাধানটি সন্তুষ্ট করবে তবে এটি আমাদের 4 টি ভলিউমে করণীয়, যদি আমাদের নিম্নলিখিত স্তর কাঠামো থাকে:

. . . .     . . . .
. x . .     . . x .
. . x .     . x . .
. . . .     . . . .

কিছু অবিশ্বস্ত ব্যবস্থাও রয়েছে। উদাহরণস্বরূপ নিন:

Top:        Front:      Side:
. . . .     . . . .     . . . .
. . . .     . . x .     . . . .
. x . .     . . . .     . x . .
. . . .     . . . .     . . . .

যদি শীর্ষ দৃষ্টিভঙ্গি বলছে যে ব্লকটি বাম থেকে দ্বিতীয় স্থানে রয়েছে, সামনের দৃশ্যের সাথে মেলে এমন কোনও উপায় নেই যা বলবে যে ব্লকটি অবশ্যই বাম থেকে তৃতীয় হওয়া উচিত। সুতরাং এই ব্যবস্থা অসম্ভব।

---

আপনার কাজটি এমন একটি প্রোগ্রাম তৈরি করা যা একটি স্বেচ্ছাসেবী 4x4 টপ-ফ্রন্ট-সাইড ধাঁধা দেওয়া, এটি কয়েক কিউবের সংখ্যায় সমাধান করার চেষ্টা করে, বা এটি অকেজো বলে ঘোষণা করে।

আপনার প্রোগ্রামটি শীর্ষ, সামনের এবং পার্শ্বের মতামতগুলিকে উপস্থাপন করে 48 বিটের একটি সিরিজ ইনপুট হিসাবে গ্রহণ করবে। এগুলি আপনার যে কোনও ফর্ম্যাটে থাকতে পারে (একটি 6-বাইট স্ট্রিং, 0 এর এবং 1 এর স্ট্রিং, একটি 12-অঙ্কের হেক্স নম্বর ইত্যাদি) তবে বিটের ক্রমটি অবশ্যই এই জাতীয় মানচিত্রের মানচিত্র:

Top: 0x00   Front: 0x10 Side: 0x20
0 1 2 3     0 1 2 3     0 1 2 3
4 5 6 7     4 5 6 7     4 5 6 7
8 9 a b     8 9 a b     8 9 a b
c d e f     c d e f     c d e f

অন্য কথায়, বিটগুলি বাম থেকে ডানে, উপরে থেকে নীচে ক্রমে, শীর্ষে, তারপরে সামনের, তারপরে পাশের দৃশ্যে যায়।

আপনার প্রোগ্রামটি তখন ভরাট করা 4x4x4 গ্রিডের কিউবগুলিকে নির্দেশ করে b৪ বিটের একটি সিরিজ আউটপুট দেবে, বা গ্রিডটি অবিশ্বাস্য indicate

---

আপনার প্রোগ্রামটি 1,000,000 পরীক্ষার ক্ষেত্রে ব্যাটারি চালিয়ে স্কোর করা হবে।

পরীক্ষার তথ্যটি "990099" এর মাধ্যমে "990099" এর মাধ্যমে "990099" এর এমডি 5 হ্যাশগুলি স্ট্রিং হিসাবে গ্রহণ করে, এই প্রতিটি হ্যাশের প্রথম 48 বিট (12 হেক্সট) বের করে এবং এগুলি শীর্ষ-ফ্রন্ট- এর ইনপুট হিসাবে ব্যবহার করে তৈরি করা হবে পাশ ধাঁধা উদাহরণস্বরূপ, এখানে কিছু পরীক্ষার ইনপুট এবং ধাঁধা তারা উত্পন্ন করে:

Puzzle seed: 000000   hash: 670b14728ad9
Top:        Front:      Side:
. x x .     . . . x     x . . .
x x x x     . x . x     x . x .
. . . .     . x x x     x x . x
x . x x     . . x .     x . . x

Puzzle seed: 000001   hash: 04fc711301f3
Top:        Front:      Side:
. . . .     . x x x     . . . .
. x . .     . . . x     . . . x
x x x x     . . . x     x x x x
x x . .     . . x x     . . x x

Puzzle seed: 000157   hash: fe88e8f9b499
Top:        Front:      Side:
x x x x     x x x .     x . x x
x x x .     x . . .     . x . .
x . . .     x x x x     x . . x
x . . .     x . . x     x . . x

প্রথম দুটি সমাধানযোগ্য নয়, সর্বশেষে নিম্নলিখিতটির সাথে সামনের থেকে পিছনে একটি সমাধান রয়েছে:

x . . .   . . . .   x x x .   x x x .
. . . .   x . . .   . . . .   . . . .
x . . .   . . . .   . . . .   x x x x
x . . .   . . . .   . . . .   x . . x

There are a total of 16 blocks here, but it can probably be done in less.

আপনার প্রোগ্রামের স্কোর অগ্রাধিকারের ক্রমবর্ধমান ক্রমে নিম্নলিখিত মানদণ্ডের দ্বারা নির্ধারিত হবে:

• সর্বাধিক সংখ্যক সমাধান হওয়া মামলা।
• এই মামলাগুলি সমাধানের জন্য সবচেয়ে কম ব্লকের প্রয়োজন।
• বাইটের মধ্যে সংক্ষিপ্ততম কোড।

আপনাকে অবশ্যই নিজের দ্বারা স্কোর জমা এবং গণনা করতে হবে, যার জন্য আপনার প্রোগ্রামটি সমস্ত 1,000,000 পরীক্ষার ক্ষেত্রে চালাতে সক্ষম হওয়া প্রয়োজন।

Comments

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

— জো জেড

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

— isaacg

সময়সীমা যদিও এটি পরীক্ষা করতে তারা বেশি সময় নেয়। যে সমাধানটি চিরতরে চালাতে লাগে তা কখনই ফলাফল তৈরি করে না যা এখানে পোস্ট করা যেতে পারে। আমি কাজ করে সমস্ত অপ্টিমাইজেশন সমস্যা এইভাবে।

— জো জে।

সম্পর্কিত: কোডগল্ফ.স্ট্যাকেক্সেঞ্জার.কমিশন

— জন ডিভোরাক

@JoeZ। orlp ঠিক আছে। আমার এমডি 5-থেকে-ধাঁধা রূপান্তরটিতে আমার একটি বাগ ছিল। 00000-99999 এ 551 দ্রাবনযোগ্য ধাঁধা এবং 000000-999999 এ 5360 দ্রাব্যযোগ্য ধাঁধা।

— জাকুবে

Answer 1

পাইথন: 5360 টেস্ট-কেসগুলি 69519 ব্লক, 594 বাইট ব্যবহার করে সমাধান করা হয়েছে

এটি সর্বোত্তম মান হওয়া উচিত।

দৃষ্টীকোণ:

প্রথমে আমি পরীক্ষা করব যদি টেস্ট-কেসটি আসল সমাধানযোগ্য হয়। আমি এগুলি দ্বারা 64 দৈর্ঘ্যের একটি তালিকা শুরু করে এবং সমস্ত অবস্থানগুলিকে শূন্যতে সেট করে, যদি সেখানে তিনটি দর্শনের সাথে সম্পর্কিত পিক্সেলটি শূন্য হয়। তারপরে আমি সমস্ত 3 দিক থেকে ধাঁধাতে সরল দর্শন করি এবং দেখি যে দর্শনগুলি ইনপুট দর্শনগুলির মত একই। যদি সমান হয়, ধাঁধাটি সমাধানযোগ্য (আমরা ইতিমধ্যে সবচেয়ে খারাপ সমাধানটি পেয়েছি), অন্যথায় এটি অলসযোগ্য।

তারপরে আমি অনুকূল সমাধান সন্ধানের জন্য একটি শাখা-ও-সীমিত পদ্ধতি করি।

ব্রাঞ্চিং: আমার পুনরাবৃত্তির কাজ রয়েছে। পুনরাবৃত্তির গভীরতা কতগুলি মান ইতিমধ্যে ঠিক করা আছে তা জানায়। ফাংশনের প্রতিটি কলটিতে আমি নিজেকে দুটি বার কল করি, যদি বর্তমান সূচকের মানটি 1 হয় (অনুকূল সমাধানে এই মান 0 বা 1 হতে পারে), বা একবার যদি মান 0 হয় (এটিতে শূন্য হতে হবে) সন্তোষজনক সমাধান).

বাউন্ডিং: আমি এখানে দুটি ভিন্ন কৌশল ব্যবহার করি।

1. আমি প্রতিটি ফাংশন কলটিতে 3 টি পক্ষের ভিউগুলি গণনা করি এবং দেখি তারা এখনও ইনপুট মানের সাথে মেলে কিনা। যদি তারা মেলে না, আমি ফাংশনটি পুনরাবৃত্তভাবে বলি না।

2. আমি স্মরণে সেরা সমাধান রাখি। এটি ইতিমধ্যে সর্বোত্তম সমাধানের চেয়ে বর্তমান শাখায় আরও স্থির রয়েছে, আমি ইতিমধ্যে সেই শাখাটি বন্ধ করতে পারি। অতিরিক্ত হিসাবে আমি সক্রিয় ব্লকগুলির সংখ্যার জন্য নিম্ন সীমা নির্ধারণ করতে পারি, যা স্থির নয়। আর অবস্থা হয়ে যায়#number of activated fixed blocks + #lower bound of activated blocks (under the not fixed blocks) < #number of activated blocks in the best solution.

পাইথন কোডটি এখানে। এটি এমন একটি ফাংশন সংজ্ঞায়িত করে fযা 1 ও 0 এর সমন্বয়ে 3 টি তালিকা প্রত্যাশা করে এবং 0 টি (দ্রবণযোগ্য নয়) অথবা সর্বোত্তম সমাধানের প্রতিনিধিত্বকারী 1 ও 0 এর তালিকা দেয়।

S=sum;r=range
def f(t,f,s):
 for i in r(4):s[4*i:4*i+4]=s[4*i:4*i+4][::-1]
 c=[min(t[i%16],f[(i//16)*4+i%4],s[i//4])for i in r(64)]
 m=lambda:([int(S(c[i::16])>0)for i in r(16)],[int(S(c[i+j:i+j+16:4])>0)for i in r(0,64,16)for j in r(4)],[int(S(c[i+j:i+j+4])>0)for i in r(0,64,16)for j in r(0,16,4)])==(t,f,s)
 Z=[65,0];p=[]
 def g(k):
  if k>63and S(c)<Z[0]:Z[:]=[S(c),c[:]]
  if k>63or S(c[:k])+p[k]>=Z[0]:return
  if c[k]:c[k]=0;m()and g(k+1);c[k]=1
  m()and g(k+1)
 for i in r(64):h,R=(i//16)*4+4,(i//4)%4;p+=[max(S(f[h:]),S(s[h:]))+max((R<1)*S(f[h+i%4-3:h]),S(s[h+R-3:h]))]
 g(0);return Z[1]

কোডের দৈর্ঘ্য 596 বাইট / অক্ষর। এবং এখানে পরীক্ষার কাঠামোটি রয়েছে:

from hashlib import md5
from time import time

N = 1000000
start=time();count=blocks=0
for n in range(N):
 bits = list(map(int,"{:048b}".format(int(md5("{:06}".format(n).encode("utf-8")).hexdigest()[:12], 16))))
 result = f(bits[:16], bits[16:32], bits[32:])
 if result:
  count += 1
  blocks += sum(result)
  print("Seed: {:06}, blocks: {}, cube: {}".format(n, sum(result), result))
print()
print("{} out of {} puzzles are solvable using {} blocks.".format(count, N, blocks))
print("Total time: {:.2f} seconds".format(time()-start))

আপনি প্রোগ্রামটির একটি নিরবচ্ছিন্ন সংস্করণটি এখানে পেতে পারেন । এটিও কিছুটা দ্রুত।

ফলাফল:

1000000 ধাঁধা এর মধ্যে 5360 সমাধানযোগ্য। মোট আমাদের 69519 ব্লক প্রয়োজন। ব্লকের সংখ্যা 6 টি ব্লক থেকে 18 ব্লকের মধ্যে পরিবর্তিত হয়। সবচেয়ে কঠিন ধাঁধাটি সমাধান করতে প্রায় 1 সেকেন্ড সময় নিয়েছিল। এটি বীজের সাথে ধাঁধা "347177", যা দেখতে ভাল লাগে

Top:      Front:    Side:
x x . .   x x x x   x . x .
x x x x   x x x x   x x x x
x x x x   x x x x   x x x x
x x . x   x x x x   x . x x

18 টি কিউব সহ একটি সর্বোত্তম সমাধান রয়েছে। প্রতিটি স্তরগুলির জন্য উপরে থেকে নীচে কয়েকটি:

Top 1:    Top 2:    Top 3:    Top 4:
. . . .   . x . .   . x . .   x . . .
. . x x   . . x .   x . . .   . x x .
. . . .   . . . x   x x x .   . . . .
x x . .   x . . .   . . . x   . . . x

সমস্ত পরীক্ষার ক্ষেত্রে মোট চলমান সময়টি প্রায় 90 সেকেন্ড ছিল। আমি আমার প্রোগ্রামটি কার্যকর করতে পাইপাই ব্যবহার করেছি। সিপিথন (ডিফল্ট পাইথন ইন্টারপ্রেটার) কিছুটা ধীরে ধীরে, তবে সমস্ত ধাঁধাটি মাত্র 7 মিনিটের মধ্যে সমাধান করে all

আপনি এখানে সম্পূর্ণ আউটপুট খুঁজে পেতে পারেন : আউটপুটটি স্ব-বর্ণনামূলক। যেমন উপরের ধাঁধার জন্য আউটপুট হল:

Seed: 347177, blocks: 18, cube: [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1]

Answer 2

5360 কেস 69519 ব্লক দিয়ে সমাধান; 923 বাইট

এটিও সর্বোত্তম। যাকে এবং শূন্যদের একটি অ্যারের সাথে কল করুন। NullPointerExceptionঅবৈধ ইনপুট জন্য একটি ছুড়ে । কিছু দক্ষতা এটি গল্ফ বলিদান হয়। এটি এখনও সমস্ত 1000000 পরীক্ষার ইনপুটগুলির জন্য যুক্তিসঙ্গত সময়ের মধ্যে সম্পূর্ণ করে।

import java.util.*;int[]a(int[]a){a b=new a(a);b=b.b(64);return b.d();}class a{List<int[]>a=new ArrayList();List b=new ArrayList();int c;a(int[]d){int e=0,f,g,h,i[]=new int[48];for(;e<64;e++){f=e/16;g=(e%16)/4;h=e%4;if(d[f+12-4*h]+d[16+f+g*4]+d[32+h+g*4]>2){i[f+12-4*h]=i[16+f+g*4]=i[32+h+g*4]=1;a.add(new int[]{f,g,h});c++;}}if(!Arrays.equals(d,i))throw null;b=f();}a(){}a b(int d){if(c-b.size()>d|b.size()<1)return this;a e=c();e.a.remove(b.get(0));e.b.retainAll(e.f());e.c--;e=e.b(d);d=Math.min(e.c,d);a f=c();f=f.b(d);return e.c>f.c?f:e;}a c(){a c=new a();c.a=new ArrayList(a);c.b=new ArrayList(b);c.b.remove(0);c.c=this.c;return c;}int[]d(){int[]d=new int[64];for(int[]e:a)d[e[2]*16+e[1]*4+e[0]]=1;return d;}List f(){List d=new ArrayList();int e,f,g;for(int[]h:a){e=0;f=0;g=0;for(int[]p:a)if(p!=h){e|=h[0]==p[0]&h[1]==p[1]?1:0;f|=h[0]==p[0]&h[2]==p[2]?1:0;g|=h[1]==p[1]&h[2]==p[2]?1:0;}if(e+f+g>2)d.add(h);}return d;}}

কৌশল:

আমি যখন 10 ছিলাম তখন আমি আসলে এই ধাঁধাটি খেলতাম play এটি আমার পদ্ধতির ব্যবহার করে।

ধাপ 1:

প্রদত্ত দর্শনগুলির সাথে খাপ খায় এমন সর্বাধিক ব্লকের সাথে কিউব তৈরি করুন।

ধাপ ২:

অপসারণযোগ্য টুকরাগুলির একটি তালিকা তৈরি করুন। (যে কোনও টুকরোটির সাথে সারিতে অন্য টুকরা রয়েছে এটির কলামটি এর মধ্যে এবং এতে মরীচি রয়েছে।)

ধাপ 3:

প্রতিটি অপসারণযোগ্য টুকরো রাখার বা অপসারণের প্রতিটি সম্ভাব্য উপায়ে পরীক্ষা করুন। (ছাঁটাই সহ পুনরাবৃত্তিমূলক ব্রুট ফোর্স মাধ্যমে।)

পদক্ষেপ 4:

সেরা বৈধ কিউব রাখুন।

Ungolfed:

int[] main(int[] bits) {
    Cube cube = new Cube(bits);
    cube = cube.optimize(64);
    return cube.bits();
}

class Cube {

    List<int[]> points = new ArrayList();
    List removablePoints = new ArrayList();
    int size;

    Cube(int[] bits) {
        int i = 0,x,y,z,placed[] = new int[48];
        for (; i < 64; i++) {
            x = i / 16;
            y = (i % 16) / 4;
            z = i % 4;
            if (bits[x + 12 - 4 * z] + bits[16 + x + y * 4] + bits[32 + z + y * 4] > 2) {
                placed[x + 12 - 4 * z] = placed[16 + x + y * 4] = placed[32 + z + y * 4] = 1;
                points.add(new int[]{x, y, z});
                size++;
            }
        }

        if (!Arrays.equals(bits, placed))
            throw null;

        removablePoints = computeRemovablePoints();
    }

    Cube() {
    }

    Cube optimize(int smallestFound) {
        if (size - removablePoints.size() > smallestFound | removablePoints.size() < 1)
            return this;

        Cube cube1 = duplicate();
        cube1.points.remove(removablePoints.get(0));

        cube1.removablePoints.retainAll(cube1.computeRemovablePoints());
        cube1.size--;

        cube1 = cube1.optimize(smallestFound);
        smallestFound = Math.min(cube1.size, smallestFound);

        Cube cube2 = duplicate();

        cube2 = cube2.optimize(smallestFound);

        return cube1.size > cube2.size ? cube2 : cube1;

    }

    Cube duplicate() {
        Cube c = new Cube();
        c.points = new ArrayList(points);
        c.removablePoints = new ArrayList(removablePoints);
        c.removablePoints.remove(0);
        c.size = size;
        return c;
    }

    int[] bits() {
        int[] bits = new int[64];
        for (int[] point : points)
            bits[point[2] * 16 + point[1] * 4 + point[0]] = 1;
        return bits;
    }

    List computeRemovablePoints(){
        List removablePoints = new ArrayList();
        int removableFront, removableTop, removableSide;
        for (int[] point : points) {
            removableFront = 0;
            removableTop = 0;
            removableSide = 0;
            for (int[] p : points)
                if (p != point) {
                    removableFront |= point[0] == p[0] & point[1] == p[1] ? 1 : 0;
                    removableTop |= point[0] == p[0] & point[2] == p[2] ? 1 : 0;
                    removableSide |= point[1] == p[1] & point[2] == p[2] ? 1 : 0;
                }
            if (removableFront + removableTop + removableSide > 2)
                removablePoints.add(point);
        }
        return removablePoints;
    }

    public String toString() {

        String result = "";
        int bits[] = bits(),x,y,z;

        for (z = 0; z < 4; z++) {
            for (y = 0; y < 4; y++) {
                for (x = 0; x < 4; x++) {
                    result += bits[x + 4 * y + 16 * z] > 0 ? 'x' : '.';
                }
                result += System.lineSeparator();
            }
            result += System.lineSeparator();
        }

        return result;

    }
}

সম্পূর্ণ প্রোগ্রাম:

import java.security.MessageDigest;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Example cube:
 *
 * origin
 * |   ........
 * |  .      ..
 * | . top  . .
 * v.      .  .
 * ........   .  <- side
 * .      .  .
 * . front. .
 * .      ..
 * ........
 *
 *     / z
 *    /
 *  /
 * .-----> x
 * |
 * |
 * |
 * V y
 */

public class PPCG48247 {

    public static void main(String[] args) throws Exception{
        MessageDigest digest = MessageDigest.getInstance("MD5");
        int totalSolved = 0;
        int totalCubes = 0;

        for (int i = 0; i < 1000000; i++){
            byte[] input = String.format("%06d", i).getBytes();

            byte[] hash = digest.digest(input);
            int[] bits = new int[48];

            for (int j = 0, k = 0; j < 6; j++, k += 8){
                byte b = hash[j];
                bits[k] = (b >> 7) & 1;
                bits[k + 1] = (b >> 6) & 1;
                bits[k + 2] = (b >> 5) & 1;
                bits[k + 3] = (b >> 4) & 1;
                bits[k + 4] = (b >> 3) & 1;
                bits[k + 5] = (b >> 2) & 1;
                bits[k + 6] = (b >> 1) & 1;
                bits[k + 7] = b & 1;
            }

            try {
                int[] solution = new PPCG48247().a(bits);
                totalSolved++;
                for (int b : solution){
                    totalCubes += b;
                }
            } catch (NullPointerException ignored){}

        }
        System.out.println(totalSolved);
        System.out.println(totalCubes);
    }

    int[] main(int[] bits) {
        Cube cube = new Cube(bits);
        cube = cube.optimize(64);
        return cube.bits();
    }

    class Cube {

        List<int[]> points = new ArrayList();
        List removablePoints = new ArrayList();
        int size;

        Cube(int[] bits) {
            int i = 0,x,y,z,placed[] = new int[48];
            for (; i < 64; i++) {
                x = i / 16;
                y = (i % 16) / 4;
                z = i % 4;
                if (bits[x + 12 - 4 * z] + bits[16 + x + y * 4] + bits[32 + z + y * 4] > 2) {
                    placed[x + 12 - 4 * z] = placed[16 + x + y * 4] = placed[32 + z + y * 4] = 1;
                    points.add(new int[]{x, y, z});
                    size++;
                }
            }

            if (!Arrays.equals(bits, placed))
                throw null;

            removablePoints = computeRemovablePoints();
        }

        Cube() {
        }

        Cube optimize(int smallestFound) {
            if (size - removablePoints.size() > smallestFound | removablePoints.size() < 1)
                return this;

            Cube cube1 = duplicate();
            cube1.points.remove(removablePoints.get(0));

            cube1.removablePoints.retainAll(cube1.computeRemovablePoints());
            cube1.size--;

            cube1 = cube1.optimize(smallestFound);
            smallestFound = Math.min(cube1.size, smallestFound);

            Cube cube2 = duplicate();

            cube2 = cube2.optimize(smallestFound);

            return cube1.size > cube2.size ? cube2 : cube1;

        }

        Cube duplicate() {
            Cube c = new Cube();
            c.points = new ArrayList(points);
            c.removablePoints = new ArrayList(removablePoints);
            c.removablePoints.remove(0);
            c.size = size;
            return c;
        }

        int[] bits() {
            int[] bits = new int[64];
            for (int[] point : points)
                bits[point[2] * 16 + point[1] * 4 + point[0]] = 1;
            return bits;
        }

        List computeRemovablePoints(){
            List removablePoints = new ArrayList();
            int removableFront, removableTop, removableSide;
            for (int[] point : points) {
                removableFront = 0;
                removableTop = 0;
                removableSide = 0;
                for (int[] p : points)
                    if (p != point) {
                        removableFront |= point[0] == p[0] & point[1] == p[1] ? 1 : 0;
                        removableTop |= point[0] == p[0] & point[2] == p[2] ? 1 : 0;
                        removableSide |= point[1] == p[1] & point[2] == p[2] ? 1 : 0;
                    }
                if (removableFront + removableTop + removableSide > 2)
                    removablePoints.add(point);
            }
            return removablePoints;
        }

        public String toString() {

            String result = "";
            int bits[] = bits(),x,y,z;

            for (z = 0; z < 4; z++) {
                for (y = 0; y < 4; y++) {
                    for (x = 0; x < 4; x++) {
                        result += bits[x + 4 * y + 16 * z] > 0 ? 'x' : '.';
                    }
                    result += System.lineSeparator();
                }
                result += System.lineSeparator();
            }

            return result;

        }
    }

}