প্রতিটি কক্ষে ম্যাট্রিক্সে 0 তে সেট করুন যদি সেই সারি বা কলামে 0 থাকে

152

0 এবং 1 এস সহ একটি এনএক্সএন ম্যাট্রিক্স দিয়েছেন। প্রত্যেক সারি করে একটি রয়েছে সেট 0সব থেকে 0s এবং প্রতিটি কলামের একটি রয়েছে সেট 0সব থেকে 0গুলি।

উদাহরণ স্বরূপ

1 0 1 1 0
0 1 1 1 0
1 1 1 1 1
1 0 1 1 1
1 1 1 1 1

ফলাফল স্বরূপ

0 0 0 0 0
0 0 0 0 0
0 0 1 1 0
0 0 0 0 0
0 0 1 1 0

একজন মাইক্রোসফ্ট ইঞ্জিনিয়ার আমাকে বলেছিলেন যে একটি সমাধান রয়েছে যাতে অতিরিক্ত মেমরির অন্তর্ভুক্ত নেই, কেবল দুটি বুলিয়ান ভেরিয়েবল এবং একটি পাস, সুতরাং আমি সেই উত্তরটি সন্ধান করছি।

বিটিডাব্লু, ধারণা করুন এটি কিছুটা ম্যাট্রিক্স, অতএব মাত্র 1s এবং 0s ম্যাট্রিক্সে থাকতে দেয়।

algorithm  optimization  puzzle 
— jaircazarin-পুরোনো অ্যাকাউন্ট
সূত্র
1
তাই না? "যখনই আপনি মুখোমুখি হন" কী? আপনি কোন ক্রমে ম্যাট্রিক্সের উপাদানগুলির মুখোমুখি হচ্ছেন? এবং যদি আপনি সমস্ত বিটগুলির মুখোমুখি হন, তবে আপনি কি সব 0s পাবেন না?
— শ্রীভাতসার
ঠিক আছে, আপনি যে ক্রমে উপাদানগুলির মুখোমুখি হওয়ার সিদ্ধান্ত নিয়েছেন তা হ'ল আপনার সিদ্ধান্ত, জিনিসটি হ'ল আপনাকে অবশ্যই যথাযথ উপাদানগুলি 0-এ সেট করতে হবে। আপনার যদি 0 তে সেট করা সমস্ত বিট মুখোমুখি হয় তবে হ্যাঁ ম্যাট্রিক্সটি এখনও শূন্যে পূর্ণ হবে।
— জাইরকাজারিন-পুরাতন অ্যাকাউন্ট 0
"সঠিক উপাদান" কি? আপনি কি দুটি ম্যাট্রিক দিয়েছেন , একটি "উত্স" ম্যাট্রিক্স এবং একটি "টার্গেট" ম্যাট্রিক্স এবং আপনাকে অবশ্যই সিদ্ধান্ত নিতে হবে যে "আদেশ" ম্যাট্রিক্স পেতে উপাদানগুলি "মুখোমুখি" হবে?
— শ্রীভাতসার
1
আমি মনে করি আপনি '1 পাস' ভাবার জন্য কোনও কিছু ভুল প্রবণতা দেখিয়েছেন। এটি 2 পাসে রৈখিকভাবে করা যায় যদিও অতিরিক্ত স্মৃতি ছাড়াই কেবল 2 বুলিয়ান ;-) তাই আমি
— দৃ strongly়ভাবে ধরেই নিয়েছি
1
সমস্যার বর্ণনাটি যদি সঠিক হয় তবে আপনি কি দয়া করে আপনার বন্ধুর সাথে ডাবল-চেক করতে পারেন? আমি ভেবেছিলাম হামিং কোড বা প্যারিটি বিট দিয়ে আমি এটি করতে পারি তবে এখন পর্যন্ত আমার কোনও সাফল্য হয়নি, এবং সমস্যাটি আমার মাথার মধ্যে বসে আছে। :)
— সিএসএল

উত্তর:

96

ঠিক আছে, তাই আমি এখানে সকাল 3 টা বাজানোর সাথে সাথে ক্লান্ত হয়ে পড়েছি, তবে ম্যাট্রিক্সের প্রতিটি সংখ্যায় ঠিক 2 পাসের সাথে আমার প্রথম চেষ্টা করার জায়গা রয়েছে, সুতরাং ও (এনএক্সএন) এ এবং এটি ম্যাট্রিক্সের আকারে লিনিয়ার।

আমি কেবল 1 টির সাথে সারি / কর্সগুলি কোথায় তা জানতে চিহ্নিতকারী হিসাবে প্রথম কলাম এবং প্রথম সারিটি ব্যবহার করি। তারপরে, 2 টি ভেরিয়েবল রয়েছে l এবং c মনে রাখার জন্য যদি প্রথম সারিতে / কলামটি সমস্ত 1 এর হয়। সুতরাং প্রথম পাসটি চিহ্নিতকারীকে সেট করে এবং বাকিটি 0-এ পুনরায় সেট করে।

দ্বিতীয় পাস যেখানে সারি এবং কলস যেখানে 1 হিসাবে চিহ্নিত হয়েছে সেখানে 1 সেট করে এবং l এবং c এর উপর নির্ভর করে 1 ম লাইন / করল পুনরায় সেট করে।

আমি দৃ strongly়ভাবে সন্দেহ করি যে শুরুতে স্কোয়ারগুলি শেষের স্কোয়ারের উপর নির্ভরশীল হিসাবে আমি 1 টি পাস হতে পারি। হতে পারে আমার ২ য় পাসটি আরও দক্ষ করা যায় ...

import pprint

m = [[1, 0, 1, 1, 0],
     [0, 1, 1, 1, 0],
     [1, 1, 1, 1, 1],
     [1, 0, 1, 1, 1],
     [1, 1, 1, 1, 1]]



N = len(m)

### pass 1

# 1 rst line/column
c = 1
for i in range(N):
    c &= m[i][0]

l = 1
for i in range(1,N):
    l &= m[0][i]


# other line/cols
# use line1, col1 to keep only those with 1
for i in range(1,N):
    for j in range(1,N):
        if m[i][j] == 0:
            m[0][j] = 0
            m[i][0] = 0
        else:
            m[i][j] = 0

### pass 2

# if line1 and col1 are ones: it is 1
for i in range(1,N):
    for j in range(1,N):
        if m[i][0] & m[0][j]:
            m[i][j] = 1

# 1rst row and col: reset if 0
if l == 0:
    for i in range(N):
        m [i][0] = 0

if c == 0:
    for j in range(1,N):
        m [0][j] = 0


pprint.pprint(m)
— পাইওটার লেসনিকি
সূত্র
এখানে একটি সমস্যা হ'ল এন> আকারের (সি) এর পরে এটি ভেঙে যায়। এটিকে এন এর সাধারণ ক্ষেত্রে কাজ করতে প্রসারিত করতে আপনার বিট ফিল্ডটি গতিশীল আকারের করতে হবে যা আমি মনে করি যে সমস্যাটি দেওয়া সীমাবদ্ধতা লঙ্ঘন করবে।
— আদম
না, সি একটি বিটফিল্ড নয়, এটি কেবল একটি বুল। & = সামান্য দিক থেকে অপ্ট নয় (ভাল, এটি কিন্তু 1-বিট মানের উপর), এটি সেখানে রয়েছে কারণ সি আপনাকে প্রথম কলামটি 1 (সত্য) বা একটি 0 (মিথ্যা) রয়েছে কিনা তা বলে দেয়।
— স্টিভ জেসোপ
2
উপরের সারিটি যদি [0,1,1,1 ...] হয় তবে এটি ব্যর্থ হয় আমার বাগ ফিক্সটি 1 থেকে l থেকে এম শুরু করতে হবে [0] [0]
— কাগজের ঘোড়া
প্রকৃতপক্ষে আমি রেঞ্জের (1, এন) এর জন্য l = 1: l & = m [0] [i] আমার পরিসীমা (এন) এর জন্য l = 1 হওয়া উচিত: l ও = মি [0] [i]
— ক্রিস্টোফ নেইরিন্যাক
1
বিটিডাব্লু, আমি বিশ্বাস করি যে দ্বিতীয় পাসের শর্তটি এমন কিছু হওয়া উচিত: যদি এম [i] [0] | মি [0] [জে]:
— জাইরকাজারিন-পুরাতন অ্যাকাউন্ট
16

এটি একটি পাসে করা যায় না যেহেতু কোনও অর্ডারে এর আগে এবং পরে বিটগুলিতে একক বিটের প্রভাব থাকে। IOW আপনি যে কোনও আদেশটিতে অ্যারেটি অতিক্রম করেন না কেন, আপনি পরে 0 টি পেরিয়ে আসতে পারেন যার অর্থ আপনাকে ফিরে যেতে হবে এবং আগের 1 টি 0 তে পরিবর্তন করতে হবে।

হালনাগাদ

লোকেরা মনে করে যে N কে কিছু নির্দিষ্ট মান (8 বলুন) এর মধ্যে সীমাবদ্ধ রেখে আপনি এটি সমাধান করতে পারেন one আচ্ছা এটি ক) পয়েন্টটি মিস করছেন এবং খ) মূল প্রশ্নটি নয়। আমি বাছাইয়ের বিষয়ে কোনও প্রশ্ন পোস্ট করব না এবং এমন একটি উত্তরের প্রত্যাশা করব যা "আপনি কেবলমাত্র 8 টি জিনিস সাজানোর বিষয়ে ধারণা করছেন ..." শুরু করে।

এটি বলেছে, এটি যদি একটি যুক্তিসঙ্গত পদ্ধতির হয় তবে আপনি যদি জানেন যে এন আসলে 8 এর মধ্যে সীমাবদ্ধ রয়েছে তবে আমার উপরের উত্তরটি মূল প্রশ্নের উত্তর দেয় যা এরকম পুনঃসংশোধন নেই।

— Draemon
সূত্র
অতিরিক্ত স্মৃতি ছাড়া এটি একটি পাসে করা যায় না। ফলাফল সংরক্ষণের জন্য যদি আরও কোনও এনএক্সএন ম্যাট্রিক্স থাকে তবে এটি একটি পাসে করা সম্ভব Like
— paxos1977
2
আপনি অস্থায়ী ম্যাট্রিক্স ব্যবহার করলেও আপনি একটি পাসে এটি করতে পারবেন না অন্যথায় এখানে কিছু অদ্ভুত কিছু রয়েছে যা আমি এখানে পাচ্ছি না। সারি / কলামের তথ্য কমানোর জন্য আপনার একটি পাস এবং সবকিছু সেট করার জন্য একটি পাস দরকার।
— লাসে ভি কার্লসেন
আমি এই সমস্যাটি সমাধান করেছিলাম যে প্রতি সারিতে কেবলমাত্র একটি অনন্য-শূন্য মান সম্ভব এবং কেবলমাত্র রেফারেন্স দ্বারা এটি নির্ধারণ করে।
— ড্যানিয়েল পাপাসিয়ান
@ সেরেটুলিস, লাসেভেক: আমি এখনও মনে করি এটি এক পাসে করা সম্ভব নয়। দ্বিতীয় ম্যাট্রিক্সের পাসগুলি গণনা করতে হবে - অন্যথায় আপনি কেবল একটি পাসে ম্যাট্রিক্স অনুলিপি করতে পারেন, এবং আপনি চাইলেও অনুলিপি দিয়ে কাজ করতে পারেন। @ ড্যানিয়েল পাপাসিয়ান: আপনার সমাধানটি স্কেল করে না যেখানে এন> # বিটগুলি দীর্ঘ / দীর্ঘ / যাই হোক না কেন
— ড্রিমোন
ড্রিমন, কৌশলটি সূক্ষ্মভাবে স্কেল করে, এটি কেবল গণিত - আপনি হয় এটি তৈরি করে এমন হার্ডওয়্যার তৈরি করতে পারেন, বা আপনি নিজের শব্দের আকারের চেয়ে বড় সংখ্যাগুলি ম্যানিপুলেট করতে সফ্টওয়্যার কৌশলগুলি ব্যবহার করতে পারেন।
— উভয়ই
10

সুতরাং আমার ধারণাটি হ'ল শেষ সারিতে / কলামের মানগুলিকে পতাকা হিসাবে চিহ্নিত করতে সংশ্লিষ্ট কলাম / সারিতে থাকা সমস্ত মান 1s কিনা তা চিহ্নিত করতে।

সম্পূর্ণ ম্যাট্রিক্সের মাধ্যমে একটি জিগ জাগ স্ক্যান ব্যবহার করে চূড়ান্ত সারি / কলামটি ছাড়ুন। প্রতিটি উপাদানগুলিতে, আপনি চূড়ান্ত সারি / কলামে বর্তমানের উপাদানটির মান সহ লজিকাল এবং নিজের হিসাবে নির্ধারণ করেন। অন্য কথায়, আপনি যদি একটি 0 টি আঘাত করেন তবে চূড়ান্ত সারি / কলামটি 0 এ সেট করা হবে আপনি যদি এটি 1 করে থাকেন তবে চূড়ান্ত সারি / কলামের মান 1 হবে কেবল যদি এটি ইতিমধ্যে 1 ছিল। যে কোনও ক্ষেত্রে বর্তমান উপাদানটিকে 0 তে সেট করুন।

আপনি যখন শেষ করেছেন, আপনার চূড়ান্ত সারি / কলামটিতে 1s থাকা উচিত যদি সংশ্লিষ্ট কলাম / সারিটি 1s দিয়ে পূর্ণ হয়।

চূড়ান্ত সারি এবং কলাম এবং 1 সন্ধানে লিনিয়ার স্ক্যান করুন for ম্যাট্রিক্সের শরীরে সংশ্লিষ্ট উপাদানগুলিতে 1s সেট করুন যেখানে চূড়ান্ত সারি এবং কলাম উভয়ই 1s রয়েছে।

কোডিং করা একে অপরের বাইরের ত্রুটিগুলি এড়ানো সহজতর হবে তবে এটি একটি পাসে কাজ করা উচিত।

— অ্যালিস্টার
সূত্র
খুব সুন্দর ... আমি একই লাইনগুলিতে ভাবছিলাম, তবে সেই তথ্যটি সংরক্ষণ করতে চূড়ান্ত সারি / কলামটি ব্যবহার করা মিস করলাম, তাই আমি Nx1 অ্যারেতে একজোড়া অতিরিক্ত স্মৃতিতে আটকে গিয়েছিলাম।
— ডেভ শেরোহমান
1
এটি আমার কাছে দুটি পাসের মতো দেখায় - একটি পাস হ'ল জিগ-জাগ স্ক্যান, দ্বিতীয়টি হ'ল ম্যাট্রিক্সের শরীরে সংশ্লিষ্ট উপাদানগুলিতে 1 সেট 1 সেট যেখানে চূড়ান্ত সারি এবং কলাম উভয়ই 1s "।
— অ্যাডাম রোজেনফিল্ড
জিগ-জাগ স্ক্যান (যা কেউ আমাকে দেখিয়ে দিয়েছে তা কঠোরভাবে প্রয়োজনীয় নয়) সমস্ত চূড়ান্ত সারি / কলামকে অনুসরণ করে। সুতরাং চূড়ান্ত / সারির কলামটি স্ক্যান করা আগে স্ক্যান করা উপাদানগুলির সদৃশ হয় না। অতএব একটি পাস। অন্য কথায় এটি এন * এন ম্যাট্রিক্সের জন্য ও (এন ^ 2)।
— অ্যালাস্টার
6

আমি এখানে একটি সমাধান পেয়েছি, এটি একটি একক পাসে চলে এবং সমস্ত প্রসেসিং কোনও "অতিরিক্ত জায়গায়" মেমরি ছাড়াই "জায়গায়" থাকে (স্ট্যাক বাড়ানোর জন্য সংরক্ষণ করুন)।

এটি শূন্যগুলির লেখায় বিলম্ব করতে পুনরাবৃত্তি ব্যবহার করে যা অবশ্যই অন্যান্য সারি এবং কোলের জন্য ম্যাট্রিক্সকে ধ্বংস করবে:

#include <iostream>

/**
* The idea with my algorithm is to delay the writing of zeros
* till all rows and cols can be processed. I do this using
* recursion:
* 1) Enter Recursive Function:
* 2) Check the row and col of this "corner" for zeros and store the results in bools
* 3) Send recursive function to the next corner
* 4) When the recursive function returns, use the data we stored in step 2
*       to zero the the row and col conditionally
*
* The corners I talk about are just how I ensure I hit all the row's a cols,
* I progress through the matrix from (0,0) to (1,1) to (2,2) and on to (n,n).
*
* For simplicities sake, I use ints instead of individual bits. But I never store
* anything but 0 or 1 so it's still fair ;)
*/

// ================================
// Using globals just to keep function
// call syntax as straight forward as possible
int n = 5;
int m[5][5] = {
                { 1, 0, 1, 1, 0 },
                { 0, 1, 1, 1, 0 },
                { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 },
                { 1, 1, 1, 1, 1 }
            };
// ================================

// Just declaring the function prototypes
void processMatrix();
void processCorner( int cornerIndex );
bool checkRow( int rowIndex );
bool checkCol( int colIndex );
void zeroRow( int rowIndex );
void zeroCol( int colIndex );
void printMatrix();

// This function primes the pump
void processMatrix() {
    processCorner( 0 );
}

// Step 1) This is the heart of my recursive algorithm
void processCorner( int cornerIndex ) {
    // Step 2) Do the logic processing here and store the results
    bool rowZero = checkRow( cornerIndex );
    bool colZero = checkCol( cornerIndex );

    // Step 3) Now progress through the matrix
    int nextCorner = cornerIndex + 1;
    if( nextCorner < n )
        processCorner( nextCorner );

    // Step 4) Finially apply the changes determined earlier
    if( colZero )
        zeroCol( cornerIndex );
    if( rowZero )
        zeroRow( cornerIndex );
}

// This function returns whether or not the row contains a zero
bool checkRow( int rowIndex ) {
    bool zero = false;
    for( int i=0; i<n && !zero; ++i ) {
        if( m[ rowIndex ][ i ] == 0 )
            zero = true;
    }
    return zero;
}

// This is just a helper function for zeroing a row
void zeroRow( int rowIndex ) {
    for( int i=0; i<n; ++i ) {
        m[ rowIndex ][ i ] = 0;
    }
}

// This function returns whether or not the col contains a zero
bool checkCol( int colIndex ) {
    bool zero = false;
    for( int i=0; i<n && !zero; ++i ) {
        if( m[ i ][ colIndex ] == 0 )
            zero = true;
    }

    return zero;
}

// This is just a helper function for zeroing a col
void zeroCol( int colIndex ) {
    for( int i=0; i<n; ++i ) {
        m[ i ][ colIndex ] = 0;
    }
}

// Just a helper function for printing our matrix to std::out
void printMatrix() {
    std::cout << std::endl;
    for( int y=0; y<n; ++y ) {
        for( int x=0; x<n; ++x ) {
            std::cout << m[y][x] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

// Execute!
int main() {
    printMatrix();
    processMatrix();
    printMatrix();
}
— আদম
সূত্র
2
দুর্দান্ত সমাধান, তবে আপনি প্রযুক্তিগতভাবে দুটি অনুমোদিত বুলিয়ান (যদিও স্ট্যাকের উপরে) এর চেয়ে বেশি মেমরি ব্যবহার করছেন।
— সিএসএল
1
এটি> 1 পাস। যদি আপনি (রোআইএনডেক্স, i) এবং (i, কলইন্ডেক্স) মুদ্রণ করেন যা তারা চেকরো এবং চেক কোলে অ্যাক্সেসিত হয় আপনি দেখতে পাবেন যে প্রতিটি উপাদান একাধিকবার অ্যাক্সেস করেছে।
— ড্রাগন
ড্রিমন: আপনি সঠিক, আমি মনে করি ধাঁধা নির্মাতার কাছ থেকে আমাদের "সিঙ্গল পাস" এর একটি পরিষ্কার সংজ্ঞা প্রয়োজন। যদি তার সত্যিকারের অর্থ হ'ল প্রতিটি উপাদান কেবল একবারে অ্যাক্সেস করা যায় তবে আমাদের আলাদা সমাধান দরকার।
— অ্যাডাম
আমি কল্পনা করি যে আসল সমস্যাটি (যা টেলিফোনের গেমের মাধ্যমে আমাদের কাছে এসেছিল) এর অর্থ সমস্যাটি "স্থানে" সমাধান করা উচিত যার অর্থ আপনার কাছে ম্যাট্রিক্সের আর একটি অনুলিপি নেই। এবং আরও অনুকূল সমাধানগুলির এমনকি প্রক্রিয়াজাতকরণের জন্য স্টোরেজের মতো অস্থায়ী swap () এর প্রয়োজনও হয় না।
— অ্যাডাম
এছাড়াও আমি সন্দেহের ধরণের সীমাবদ্ধতাগুলি ফলাফলকারী মেশিন কোডকে উল্লেখ করছি। অর্থ, "প্রদত্ত" কোডটি কেবলমাত্র 2 টি বুল ব্যবহার করে। আমার সংকলকটি কী অপ্টিমাইজেশন করে তার উপর নির্ভর করে পুরো ডার্ন জিনিসটি inোকানো যেতে পারে বা কে কী জানে। আমি মনে করি আমার সমাধানটি সঠিক;)
— আদম
4

আমি মনে করি না এটি করণীয়। আপনি যখন প্রথম স্কোয়ারে রয়েছেন এবং এর মান 1 হয়, তখন একই সারি এবং কলামের অন্যান্য স্কোয়ারের মানগুলি কী তা জানার আপনার কোনও উপায় নেই। সুতরাং আপনাকে সেগুলি পরীক্ষা করে দেখতে হবে এবং যদি শূন্য থাকে তবে প্রথম স্কোয়ারে ফিরে আসুন এবং এর মানটি শূন্যে পরিবর্তন করুন। আমি এটি দুটি পাসে করার পরামর্শ দিচ্ছি - প্রথম পাসটি এমন তথ্য সংগ্রহ করে যা সম্পর্কে সারি এবং কলামগুলি শূন্য করতে হবে (তথ্যটি একটি অ্যারেতে সঞ্চিত আছে, তাই আমরা কিছু অতিরিক্ত স্মৃতি ব্যবহার করছি)। দ্বিতীয় পাস মান পরিবর্তন করে। আমি জানি এটি যে সমাধান আপনি সন্ধান করছেন তা নয়, তবে আমি মনে করি এটি একটি ব্যবহারিক। আপনার প্রদত্ত প্রতিবন্ধকতাগুলি সমস্যার সমাধানযোগ্য নয়।

— Boyan
সূত্র
অতিরিক্ত অ্যারে ছাড়াই আমার প্রায় একই সমাধান (নীচে দেখুন) রয়েছে। এবং এটি লিনিয়ার সময় (তবে 2 টি পাস হলেও)
— পিয়োটার লেসনিকিকে
@ পাইওটর: হ্যাঁ, দ্বিতীয় পাসটি অনিবার্য বলে মনে হচ্ছে। সারণি এবং কলামগুলির তথ্য যে প্রস্তাবিত হয়েছিল তা সংরক্ষণ করার জন্য অ্যারেগুলির পরিচিতি অ্যালগরিদমকে আরও সোজা-সামনের দিকে এবং সামান্য কিছুটা দ্রুততর করে তোলে কারণ সেখানে কম পরীক্ষা এবং মান পরিবর্তন হচ্ছে and এটি স্টোরেজ এবং দক্ষতার মধ্যে একটি বাণিজ্য।
— বায়ান
3

আমি এটি দুটি পূর্ণসংখ্যের ভেরিয়েবল এবং দুটি পাস (32 টি সারি এবং কলাম পর্যন্ত ...) দিয়ে করতে পারি

bool matrix[5][5] = 
{ 
    {1, 0, 1, 1, 0},
    {0, 1, 1, 1, 0},
    {1, 1, 1, 1, 1},
    {1, 0, 1, 1, 1},
    {1, 1, 1, 1, 1}
};

int CompleteRows = ~0;
int CompleteCols = ~0;

// Find the first 0
for (int row = 0; row < 5; ++row)
{
    for (int col = 0; col < 5; ++col)
    {
        CompleteRows &= ~(!matrix[row][col] << row);
        CompleteCols &= ~(!matrix[row][col] << col);
    }
}

for (int row = 0; row < 5; ++row)
    for (int col = 0; col < 5; ++col)
        matrix[row][col] = (CompleteRows & (1 << row)) && (CompleteCols & (1 << col));
— অন্ধকার
সূত্র
এটি কি সি #? ~ এর অর্থ কী?
— স্কয়ার
এটি সি ++। ~ভেরিয়েবলের সমস্ত বিট উল্টে দেয়। 0x00000000 0x00000000 হয়। আমি মূলত সমস্তটি দিয়েই শুরু করি, এবং আমি যখন একটি 0 পাই তখন সারি / কলামের জন্য বিটটি সাফ করি Comp
— অন্ধকার
তারপরে আপনি কেবল মেট্রিক্সে বিটস সেট করেছেন কমপ্লেটকোলস এবং কমপ্লিটআরও উভয়ের মধ্যে একটির জন্য।
— অন্ধকার
3

সমস্যাটি একটি পাসে সমাধান করা যায়

একটি আই এক্স জে অ্যারেতে ম্যাট্রিক্স সংরক্ষণ করা।

1 0 1 1 0
0 1 1 1 0
1 1 1 1 1
1 0 1 1 1 
1 1 1 1 1

one each pass save the values of i and j for an element which is 0 in arrays a and b
when first row is scanned a= 1 b = 2,5
when second row is scanned a=1,2 b= 1,2,5
when third row is scanned no change
when fourth row is scanned a= 1,2,4 and b= 1,2,5
when fifth row is scanned no change .

i এবং j এর মানগুলির জন্য 0 এবং সমস্ত মানগুলিকে মুদ্রণ করুন এবং a এবং b এর মধ্যে সংরক্ষণ করা মানগুলি হ'ল 1 (3,3) (3,4) (5,3) এবং (5,4)

— সিদ্ধার্থ
সূত্র
1

অন্য সমাধান যা দুটি পাস নেয়, হ'ল অনুভূমিকভাবে এবং উল্লম্বভাবে ANDs জড়ো করা:

1 0 1 1 0 | 0
0 1 1 1 0 | 0
1 1 1 1 1 | 1
1 0 1 1 1 | 0
1 1 1 1 1 | 1
----------+
0 0 1 1 0

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

আপনি কি দয়া করে আপনার ইঞ্জিনিয়ারের সাথে সমস্যার বিবৃতিটি আবার পরীক্ষা করতে পারেন এবং আমাদের জানান? যদি সত্যিই কোনও সমাধান হয় তবে আমি সমস্যাটি এড়াতে চাই।

— সিএসএল
সূত্র
1

অ্যান্ডড হওয়া সারিগুলির সবগুলি কী তা ট্র্যাক করে রাখতে একক ভেরিয়েবল রাখুন।

যদি একটি সারি -1 (সমস্ত 1s) হয়, তবে পরবর্তী সারিতে সেই চলকটির রেফারেন্স করুন

যদি একটি সারিতে কিছু না হয় তবে এটি 0 হয় one আপনি একটি পাসে সবকিছু করতে পারেন। Psuedo-কোড:

foreach (my $row) rows {
     $andproduct = $andproduct & $row;
     if($row != -1) {
        zero out the row
     }  else {
        replace row with a reference to andproduct
     }
}

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

সিটিতে এটি কীভাবে করা যায় তার একটি উদাহরণ এখানে উল্লেখ করুন নোট আমি যুক্তি দিয়েছি যে মান এবং অ্যারের একসাথে নেওয়া অ্যারের প্রতিনিধিত্ব করে, এবং p এবং numpr Prodct হয় আমার পুনরাবৃত্তকারী এবং এবং সমস্যাটির প্রয়োগের জন্য পণ্য ভেরিয়েবল ব্যবহার করে। (আমার কাজটি যাচাই করার জন্য আমি পয়েন্টার পাটিগণিতের সাথে আরআর লুপ করতে পারতাম, তবে একবার যথেষ্ট ছিল!)

int main() {
    int values[] = { -10, 14, -1, -9, -1 }; /* From the problem spec, converted to decimal for my sanity */
    int *arr[5] = { values, values+1, values+2, values+3, values+4 };
    int **p;
    int numproduct = 127;

    for(p = arr; p < arr+5; ++p) {
        numproduct = numproduct & **p;
        if(**p != -1) {
            **p = 0;
        } else {
            *p = &numproduct;
        }
    }

    /* Print our array, this loop is just for show */
    int i;
    for(i = 0; i < 5; ++i) {
        printf("%x\n",*arr[i]);
    }
    return 0;
}

এটি 0, 0, 6, 0, 6 উত্পাদন করে যা প্রদত্ত ইনপুটগুলির ফলাফল।

বা পিএইচপি-তে, লোকেরা যদি মনে করে যে আমার স্ট্যাক গেমগুলি প্রতারণা করছে (আমি আপনাকে প্রস্তাব দিচ্ছি যে এটি তা নয়, কারণ যেভাবেই আমি ম্যাট্রিক্স সঞ্চয় করতে সক্ষম হব):

<?php

$values = array(-10, 14, -1, -9, -1);
$numproduct = 127;

for($i = 0; $i < 5; ++$i) {
    $numproduct = $numproduct & $values[$i];
    if($values[$i] != -1) {
        $values[$i] = 0;
    } else {
        $values[$i] = &$numproduct;
    }
}

print_r($values);

আমি কিছু অনুপস্থিত করছি?

— ড্যানিয়েল পাপাসিয়ান
সূত্র
এনটি যদি কোন দীর্ঘ / দীর্ঘ / যা কিছু বিটের সংখ্যার চেয়ে বড় হয় তবে এটি কাজ করে না তাই আমি এটি গণনা করি বলে মনে করি না।
— ড্রাগন
0 টি অ্যারের নীচে থাকলে এটি জিনিসগুলিও ধরতে পারে না (মানগুলি [] = {-1, -9, -1, 14, -10। দিয়ে চেষ্টা করুন)।
— সূর্যগ্রহণ
ড্রিমন, আমি আমার উত্তরে উল্লেখ করেছি যে প্রশ্নের অংশ হিসাবে হার্ডওয়্যার সীমাবদ্ধতা ছাড়াই আপনি "এনপি-বিট পাটিগণিত সমর্থন করে এমন একটি সিপিইউ তৈরি করুন" দিয়ে শুরু করবেন।
— ড্যানিয়েল পাপাসিয়ান
জোশ, আমি অনুসরণ করি না। সি বা পিএইচপি সমাধান এবং আপনার প্রস্তাবিত অ্যারে দিয়ে আমি 6 0 6 0 0 পাই, যা আমার বিশ্বাস সঠিক উত্তর।
— ড্যানিয়েল পাপাসিয়ান
@ ড্যানিয়েল - আপনি পারবেন না, কারণ এন ধ্রুবক নয়। এছাড়াও "1 এমবিট শব্দের সাহায্যে একটি নতুন কম্পিউটার তৈরি করা যুক্তিসঙ্গত একটি অ্যালগরিদমিক পদক্ষেপ নয়
— ড্রিমোন
1

ভাল চালান। এই সমাধানের ধরণের স্ট্যাকের উপর তৈরি দুটি মাত্র বুলিয়ান ব্যবহার করে, তবে ফাংশনটি পুনরাবৃত্ত হওয়ার কারণে বুলিয়ানগুলি স্ট্যাকের উপরে বেশ কয়েকবার তৈরি করা হয়।

typedef unsigned short     WORD;
typedef unsigned char      BOOL;
#define true  1
#define false 0
BYTE buffer[5][5] = {
1, 0, 1, 1, 0,
0, 1, 1, 1, 0,
1, 1, 1, 1, 1,
1, 0, 1, 1, 1,
1, 1, 1, 1, 1
};
int scan_to_end(BOOL *h,BOOL *w,WORD N,WORD pos_N)
{
    WORD i;
    for(i=0;i<N;i++)
    {
        if(!buffer[i][pos_N])
            *h=false;
        if(!buffer[pos_N][i])
            *w=false;
    }
    return 0;
}
int set_line(BOOL h,BOOL w,WORD N,WORD pos_N)
{
    WORD i;
    if(!h)
        for(i=0;i<N;i++)
            buffer[i][pos_N] = false;
    if(!w)
        for(i=0;i<N;i++)
            buffer[pos_N][i] = false;
    return 0;
}
int scan(int N,int pos_N)
{
    BOOL h = true;
    BOOL w = true;
    if(pos_N == N)
        return 0;
    // Do single scan
    scan_to_end(&h,&w,N,pos_N);
    // Scan all recursive before changeing data
    scan(N,pos_N+1);
    // Set the result of the scan
    set_line(h,w,N,pos_N);
    return 0;
}
int main(void)
{
    printf("Old matrix\n");
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[0][0],(WORD)buffer[0][1],(WORD)buffer[0][2],(WORD)buffer[0][3],(WORD)buffer[0][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[1][0],(WORD)buffer[1][1],(WORD)buffer[1][2],(WORD)buffer[1][3],(WORD)buffer[1][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[2][0],(WORD)buffer[2][1],(WORD)buffer[2][2],(WORD)buffer[2][3],(WORD)buffer[2][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[3][0],(WORD)buffer[3][1],(WORD)buffer[3][2],(WORD)buffer[3][3],(WORD)buffer[3][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[4][0],(WORD)buffer[4][1],(WORD)buffer[4][2],(WORD)buffer[4][3],(WORD)buffer[4][4]);
    scan(5,0);
    printf("New matrix\n");
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[0][0],(WORD)buffer[0][1],(WORD)buffer[0][2],(WORD)buffer[0][3],(WORD)buffer[0][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[1][0],(WORD)buffer[1][1],(WORD)buffer[1][2],(WORD)buffer[1][3],(WORD)buffer[1][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[2][0],(WORD)buffer[2][1],(WORD)buffer[2][2],(WORD)buffer[2][3],(WORD)buffer[2][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[3][0],(WORD)buffer[3][1],(WORD)buffer[3][2],(WORD)buffer[3][3],(WORD)buffer[3][4]);
    printf( "%d,%d,%d,%d,%d \n", (WORD)buffer[4][0],(WORD)buffer[4][1],(WORD)buffer[4][2],(WORD)buffer[4][3],(WORD)buffer[4][4]);
    system( "pause" );
    return 0;
}

এটি একটি প্যাটার্নে স্ক্যান করে:

s,s,s,s,s
s,0,0,0,0
s,0,0,0,0
s,0,0,0,0
s,0,0,0,0



0,s,0,0,0
s,s,s,s,s
0,s,0,0,0
0,s,0,0,0
0,s,0,0,0

ইত্যাদি

এবং তারপরে প্রতিটি স্ক্যান ফাংশনটির বিনিময়ে এই প্যাটার্নটিতে মানগুলি পরিবর্তন করা। (নীচে আপ):

0,0,0,0,c
0,0,0,0,c
0,0,0,0,c
0,0,0,0,c
c,c,c,c,c



0,0,0,c,0
0,0,0,c,0
0,0,0,c,0
c,c,c,c,c
0,0,0,c,0

ইত্যাদি

— eaanon01
সূত্র
আমি অনুমান করব যে এটি সঠিক নয়, যেহেতু আপনি এখনও আপনার স্ট্যাকের উপরে আরও দুটি বুলিয়ান ব্যবহার করেন।
— সিএসএল
আমি দুজন বুুলিয়ান দু: খজনক হিসাবে। এই যে চশমাগুলি তিনি সরবরাহ করেছিলেন তার মধ্যে এটিই আমি ভাবতে পারি। আমি এখানে একটি বাস্তব সমাধান দেখতে চাই। এটা যদি অখাদ্য হয়।
— eaanon01
আমি মনে করি না প্রয়োজনীয়তাগুলি স্ট্যাক বাড়ানোর বিষয়ে উল্লেখ করছে। আমি মনে করি এটি একটি সম্পূর্ণ বৈধ সমাধান।
— আদম
এটি আমার থাবাটও। সোমেন অন্য কোনও ভাল সমাধান পোস্ট না করা পর্যন্ত আমি নিশ্চিত নই। কমপক্ষে আমার সমাধানটি সংকলনযোগ্য এবং যে কেউই যাচাই করতে পারবেন। :) ... আমি ব্যবহারিক সমস্যার জন্য স্যুডো কোড খুঁজে পাই না। Thnx
— eaanon01
1

ঠিক আছে এটি একটি সমাধান যে

  • কাজের সঞ্চয়স্থানের জন্য মাত্র একটি অতিরিক্ত দীর্ঘ মান ব্যবহার করে।
  • কোন পুনরাবৃত্তি ব্যবহার করে।
  • শুধু এন এর একটি পাস, এমনকি এন * এনও নয়।
  • N এর অন্যান্য মানগুলির জন্য কাজ করবে তবে নতুন # নির্দিষ্টকরণের প্রয়োজন হবে।
#include <stdio.h>
#define BIT30 (1<<24)
#define COLMASK 0x108421L
#define ROWMASK 0x1fL

unsigned long long STARTGRID = 
((0x10 | 0x0 | 0x4 | 0x2 | 0x0) << 20) |
((0x00 | 0x8 | 0x4 | 0x2 | 0x0) << 15) |
((0x10 | 0x8 | 0x4 | 0x2 | 0x1) << 10) |
((0x10 | 0x0 | 0x4 | 0x2 | 0x1) << 5) |
((0x10 | 0x8 | 0x4 | 0x2 | 0x1) << 0);


void dumpGrid (char* comment, unsigned long long theGrid) {
    char buffer[1000];
    buffer[0]='\0';
    printf ("\n\n%s\n",comment);
    for (int j=1;j<31; j++) {
        if (j%5!=1)
            printf( "%s%s", ((theGrid & BIT30)==BIT30)? "1" : "0",(((j%5)==0)?"\n" : ",") );    
        theGrid = theGrid << 1;
    }
}

int main (int argc, const char * argv[]) {
    unsigned long long rowgrid = STARTGRID;
    unsigned long long colGrid = rowgrid;

    unsigned long long rowmask = ROWMASK;
    unsigned long long colmask = COLMASK;

    dumpGrid("Initial Grid", rowgrid);
    for (int i=0; i<5; i++) {
        if ((rowgrid & rowmask)== rowmask) rowgrid |= rowmask;
        else rowgrid &= ~rowmask;
        if ((colGrid & colmask) == colmask) colmask |= colmask;
        else colGrid &=  ~colmask;
        rowmask <<= 5;
        colmask <<= 1;
    }
    colGrid &= rowgrid;
    dumpGrid("RESULT Grid", colGrid);
    return 0;
    }
— AnthonyLambert
সূত্র
এটি নিশ্চিত হওয়া একটি দুর্দান্ত সমাধান। এবং আমি অনুমান করি যে এখানে প্রতিটি সমাধান কমপক্ষে প্রয়োজনীয়তার একটিটিকে অবহেলা করে। সুতরাং এন এর জন্য সর্বাধিক অনুমোদিত মান সহ একটি সমাধান থাকা বিশ্বের সবচেয়ে খারাপ জিনিস নয়, এটির জন্য খুব সুন্দর কাজ :)
— আদম
8 থেকে এন-তে সীমাবদ্ধ করা এবং এটির জন্য একটি পাসের প্রয়োজনীয়তা পূরণ করা দাবি করা কেবল সহজ বোবা। এটি কোনও সাধারণ সমাধান নয়। প্রশ্নে এন আকারের কোনও সীমাবদ্ধতা বলা হয়নি, সুতরাং আপনি কেবল একটি উপ-সমস্যা সমাধান করেছেন।
— ড্রাগন
তবে এই সমস্ত সমাধানগুলির একটি উপায় বা অন্যভাবে এন এর একটি সীমা রয়েছে।
— অ্যান্থনি ল্যামবার্ট
এটি এন এর একটি পাস বলে বলা স্পষ্টতই সম্পূর্ণ ভুল। এমনকি আসল ম্যাট্রিক্সের প্রতিটি অবস্থানের মূল্য পড়ার বিষয়টি হ'ল (এন ^ 2) এবং সমাধানের গণনা করতে সক্ষম হওয়ার জন্য কমপক্ষে একবারে প্রতিটি পজিশনে মানটি পড়া সবচেয়ে অবশ্যই প্রয়োজন। এমনকি যদি আপনি দীর্ঘ দীর্ঘ সময়ের মধ্যে একক বিট হিসাবে মান সংরক্ষণ করেন তবে প্রতিটি বিট অ্যাক্সেস করা ও (এন ^ 2) হতে পারে কারণ ও (এন ^ 2) বিট রয়েছে।
— আলদারথ
এটি স্পষ্টভাবে একটি পাস রোগ্রিড মান পুরো গ্রিড সংরক্ষণ করে এবং 1 ম পড়ার পরে অপ্টিমাইজারটি কোনও ভাল হলে পুরো অ্যালগরিদমের জন্য প্রসেসরের একটি হতে হবে।
— অ্যান্টনি ল্যামবার্ট
1

বাস্তবিক। আপনি যদি কেবল অ্যালগরিদম চালাতে চান এবং ফলাফলগুলি মুদ্রণ করতে চান (তবে এগুলি পুনরুদ্ধার করবেন না, তবে এটি সহজেই একটি পাসে করা যেতে পারে। সমস্যাটি তখন আসে যখন আপনি অ্যালগরিদমটি চালাচ্ছেন বলে অ্যারেটি সংশোধন করার চেষ্টা করবেন।

এখানে আমার সমাধানটি দেওয়া হয়েছে এতে কেবল একটি গিভিন (আই, জে) এর উপাদানটির জন্য সারি / কলাম মানগুলি অন্তর্ভুক্ত করা এবং এটি মুদ্রণ করা অন্তর্ভুক্ত। 

#include <iostream>
#include "stdlib.h"

void process();

int dim = 5;
bool m[5][5]{{1,0,1,1,1},{0,1,1,0,1},{1,1,1,1,1},{1,1,1,1,1},{0,0,1,1,1}};


int main() {
    process();
    return 0;
}

void process() {
    for(int j = 0; j < dim; j++) {
        for(int i = 0; i < dim; i++) {
            std::cout << (
                          (m[0][j] & m[1][j] & m[2][j] & m[3][j] & m[4][j]) &
                          (m[i][0] & m[i][1] & m[i][2] & m[i][3] & m[i][4])
                          );
        }
        std::cout << std::endl;
    }
}
— কেনি কেসন
সূত্র
1

আমি সি # তে এই সমস্যাটি সমাধান করার চেষ্টা করেছি।

আমি প্রকৃত ম্যাট্রিক্স এবং n এর মাত্রা উপস্থাপন করে দুটি লুপ ভেরিয়েবল (i এবং j) ব্যবহার করেছি

যুক্তি আমি চেষ্টা করেছিলাম:

  1. ম্যাট্রিক্সের প্রতিটি ঘনক স্কয়ারে জড়িত সারি এবং কলগুলির জন্য এবং গণনা করুন AND
  2. এটিকে তার কোণার কক্ষে সংরক্ষণ করুন (আমি এগুলি ঘড়ির কাঁটার বিপরীতে ক্রমে সংরক্ষণ করেছি)
  3. নির্দিষ্ট বর্গের মূল্যায়ন করার সময় দুটি কোণগুলির মান ধরে রাখতে দুটি বুল ভেরিয়েবল ব্যবহার করা হয়।
  4. এই প্রক্রিয়াটি শেষ হবে যখন বাইরের লুপ (i) মাঝ পথে হয়।
  5. কোণার কোষের উপর ভিত্তি করে অন্যান্য কোষের ফলাফলগুলি মূল্যায়ন করুন (i) এই প্রক্রিয়া চলাকালীন কোণার ঘরগুলি এড়িয়ে যান।
  6. আমি যখন এন পৌঁছে যাই, কোণার কোষ ব্যতীত সমস্ত কক্ষের ফলাফল হবে।
  7. কোণার ঘরগুলি আপডেট করুন। সমস্যাটিতে উল্লিখিত একক পাসের বাধা ব্যতীত এটি n / 2 দৈর্ঘ্যের অতিরিক্ত পুনরাবৃত্তি।

কোড:

void Evaluate(bool [,] matrix, int n)
{
    bool tempvar1, tempvar2;

    for (var i = 0; i < n; i++)
    {
        tempvar1 = matrix[i, i];
        tempvar2 = matrix[n - i - 1, n - i - 1];

        var j = 0;

        for (j = 0; j < n; j++)
        {
            if ((i < n/2) || (((n % 2) == 1) && (i == n/2) && (j <= i)))
            {
                // store the row and col & results in corner cells of concentric squares
                tempvar1 &= matrix[j, i];
                matrix[i, i] &= matrix[i, j];
                tempvar2 &= matrix[n - j - 1, n - i - 1];
                matrix[n - i - 1, n - i - 1] &= matrix[n - i - 1, n - j - 1];
            }
            else
            {
                // skip corner cells of concentric squares
                if ((j == i) || (j == n - i - 1)) continue;

                // calculate the & values for rest of them
                matrix[i, j] = matrix[i, i] & matrix[n - j - 1, j];
                matrix[n - i - 1, j] = matrix[n - i - 1, n - i - 1] & matrix[n - j - 1, j];

                if ((i == n/2) && ((n % 2) == 1))
                {
                    // if n is odd
                    matrix[i, n - j - 1] = matrix[i, i] & matrix[j, n - j - 1];
                }
            }
        }

        if ((i < n/2) || (((n % 2) == 1) && (i <= n/2)))
        {
            // transfer the values from temp variables to appropriate corner cells of its corresponding square
            matrix[n - i - 1, i] = tempvar1;
            matrix[i, n - i - 1] = tempvar2;
        }
        else if (i == n - 1)
        {
            // update the values of corner cells of each concentric square
            for (j = n/2; j < n; j++)
            {
                tempvar1 = matrix[j, j];
                tempvar2 = matrix[n - j - 1, n - j - 1];

                matrix[j, j] &= matrix[n - j - 1, j];
                matrix[n - j - 1, j] &= tempvar2;

                matrix[n - j - 1, n - j - 1] &= matrix[j, n - j - 1];
                matrix[j, n - j - 1] &= tempvar1;
            }
        }
    }
}
— বি কে
সূত্র
1

একটি পাস - আমি কেবল একবার ইনপুট ট্র্যাভার করেছি তবে একটি নতুন অ্যারে এবং মাত্র দুটি অতিরিক্ত বুলিয়ান ভেরিয়েবল ব্যবহার করেছি।

public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.nextLine();

        boolean rowDel = false, colDel = false;
        int arr[][] = new int[n][n];
        int res[][] = new int[n][n];
        int i, j;
        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                arr[i][j] = sc.nextInt();
                res[i][j] = arr[i][j];  
            }
        }

        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                if (arr[i][j] == 0)
                    colDel = rowDel = true; //See if we have to delete the
                                            //current row and column
                if (rowDel == true){
                    res[i] = new int[n];
                    rowDel = false;
                }
                if(colDel == true){
                    for (int k = 0; k < n; k++) {
                        res[k][j] = 0;
                    }
                    colDel = false;
                }

            }

        }

        for (i = 0; i < n; i++) {

            for (j = 0; j < n; j++) {
                System.out.print(res[i][j]);
            }
            System.out.println();
        }
        sc.close();

    }
— রাহুলদীপ অত্রি
সূত্র
0

প্রতিবন্ধকতাগুলি দেওয়া অসম্ভব হলেও, এটি করার সর্বাধিক স্পেস দক্ষ উপায় হ'ল একটি ওভারল্যাপিং, পর্যায়ক্রমে সারি / কলাম ফ্যাশনে ম্যাট্রিক্সকে অনুসরণ করা, যা জিগ-জাগ ফ্যাশনে ইট স্থাপনের অনুরূপ একটি নকশা তৈরি করবে:

-----
|----
||---
|||--
||||-

এটি ব্যবহার করে, আপনি প্রতিটি সারি / কলামে যাবেন, যেমনটি নির্দেশিত হয়েছে, এবং যদি আপনি কোনও সময়ে 0 এর মুখোমুখি হন তবে একটি বুলিয়ান ভেরিয়েবল সেট করুন এবং সেই সারি / কলামটি আবার হাঁটাবেন এবং প্রবেশের সময় 0 টি প্রবেশ করুন।

এটির জন্য অতিরিক্ত মেমরির প্রয়োজন হবে না এবং এটি কেবল একটি বুলিয়ান ভেরিয়েবল ব্যবহার করবে। দুর্ভাগ্যক্রমে, "দূরে" প্রান্তটি যদি সবার সাথে সেট করা থাকে তবে এটি সবচেয়ে খারাপ পরিস্থিতি এবং আপনি পুরো অ্যারেটি দু'বার হাঁটেন।

— cdeszaq
সূত্র
আমি ভুল হতে পারি, তবে আপনি কি নিশ্চিত যে এটি কাজ করে? আপনি যখন তৃতীয় কলামটি করছেন, তখন বলুন, আপনি কীভাবে জানবেন যে প্রথম সারিতে প্রথম সারিতে এটির শীর্ষের মানটি 1 বা 0 ছিল কিনা?
— স্টিভ জেসোপ
আপনি জানেন না, তবে আপনারও দরকার নেই। এটি যদি 0 হয়, পুরো কলামটি 0 হওয়া দরকার the যদি পূর্ববর্তী সারির মান 1 হয় তবে আপনি জানেন যে এটির উপরের সমস্ত সারি 1 (এবং সর্বদা ছিল)।
— ডেভ শেরোহমান
0

একটি ফলাফল ম্যাট্রিক্স তৈরি করুন এবং সমস্ত মান 1 তে সেট করুন 0 ব্যবহারের সাথে সাথে ডেটা ম্যাট্রিক্সের মধ্য দিয়ে যান, ফলাফল ম্যাট্রিক্স সারি কলামটি 0 এ সেট করুন

প্রথম পাস শেষে, ফলাফল ম্যাট্রিক্সের সঠিক উত্তর থাকবে।

দেখতে খুব সহজ লাগছে। আমি কি অনুপস্থিত একটি কৌশল আছে? আপনি কি ফলাফল সেট ব্যবহার করার অনুমতি পাচ্ছেন না?

সম্পাদনা করুন:

দেখতে এফ # ফাংশনের মতো, তবে এটি কিছুটা প্রতারণা করছে যেহেতু আপনি একক পাস করছেন, ফাংশনটি পুনরাবৃত্তি হতে পারে।

দেখে মনে হচ্ছে সাক্ষাত্কারকারক যদি আপনি কার্যকরী প্রোগ্রামিং জানেন তবে তা নির্ধারণের চেষ্টা করছেন।

— mson
সূত্র
1
ফলাফল সেট ব্যবহার করা অতিরিক্ত মেমরি গ্রহণ করবে।
— সিডেসেক
কার্যকরী প্রোগ্রামিংয়ে মূল অ্যারেটি পরিবর্তিত হবে না।
— সোভান্তে
0

ঠিক আছে, আমি 4 টি বুল এবং 2 লুপ কাউন্টার ব্যবহার করে একটি একক-পাস, ইন-প্লেস (স্থিতিবিহীন) সমাধান নিয়ে এসেছি। আমি এটিকে 2 টি বল এবং 2 ইনস্ট কমাতে পরিচালিত হইনি, তবে এটি সম্ভব হলে আমি অবাক হব না। এটি প্রতিটি কক্ষের প্রায় 3 টি পঠন এবং 3 টি লেখায় এবং এটি ও (এন ^ 2) হওয়া উচিত। অ্যারে আকারে রৈখিক।

এটিকে ধাঁধা দেওয়ার জন্য আমাকে কয়েক ঘন্টা সময় নিয়েছে - আমি কোনও সাক্ষাত্কারের চাপে এটি নিয়ে আসতে চাই না! আমি যদি কোনও বুবু তৈরি করি তবে আমি এটি স্পষ্ট করতে খুব ক্লান্ত হয়ে পড়েছি ...

উম ... আমি প্রতিটি মান একবারে স্পর্শ না করে ম্যাট্রিক্সের মাধ্যমে একটি ঝাড়ু তৈরির হিসাবে "সিঙ্গল-পাস" সংজ্ঞায়িত করতে বেছে নিচ্ছি! :-)

#include <stdio.h>
#include <memory.h>

#define SIZE    5

typedef unsigned char u8;

u8 g_Array[ SIZE ][ SIZE ];

void Dump()
{
    for ( int nRow = 0; nRow < SIZE; ++nRow )
    {
        for ( int nColumn = 0; nColumn < SIZE; ++nColumn )
        {
            printf( "%d ", g_Array[ nRow ][ nColumn ] );
        }
        printf( "\n" );
    }
}

void Process()
{
    u8 fCarriedAlpha = true;
    u8 fCarriedBeta = true;
    for ( int nStep = 0; nStep < SIZE; ++nStep )
    {
        u8 fAlpha = (nStep > 0) ? g_Array[ nStep-1 ][ nStep ] : true;
        u8 fBeta = (nStep > 0) ? g_Array[ nStep ][ nStep - 1 ] : true;
        fAlpha &= g_Array[ nStep ][ nStep ];
        fBeta &= g_Array[ nStep ][ nStep ];
        g_Array[ nStep-1 ][ nStep ] = fCarriedBeta;
        g_Array[ nStep ][ nStep-1 ] = fCarriedAlpha;
        for ( int nScan = nStep + 1; nScan < SIZE; ++nScan )
        {
            fBeta &= g_Array[ nStep ][ nScan ];
            if ( nStep > 0 )
            {
                g_Array[ nStep ][ nScan ] &= g_Array[ nStep-1 ][ nScan ];
                g_Array[ nStep-1][ nScan ] = fCarriedBeta;
            }

            fAlpha &= g_Array[ nScan ][ nStep ];
            if ( nStep > 0 )
            {
                g_Array[ nScan ][ nStep ] &= g_Array[ nScan ][ nStep-1 ];
                g_Array[ nScan ][ nStep-1] = fCarriedAlpha;
            }
        }

        g_Array[ nStep ][ nStep ] = fAlpha & fBeta;

        for ( int nScan = nStep - 1; nScan >= 0; --nScan )
        {
            g_Array[ nScan ][ nStep ] &= fAlpha;
            g_Array[ nStep ][ nScan ] &= fBeta;
        }
        fCarriedAlpha = fAlpha;
        fCarriedBeta = fBeta;
    }
}

int main()
{
    memset( g_Array, 1, sizeof(g_Array) );
    g_Array[0][1] = 0;
    g_Array[0][4] = 0;
    g_Array[1][0] = 0;
    g_Array[1][4] = 0;
    g_Array[3][1] = 0;

    printf( "Input:\n" );
    Dump();
    Process();
    printf( "\nOutput:\n" );
    Dump();

    return 0;
}
0

আমি আশা করি আপনি আমার 1-পাস সি # সমাধানটি উপভোগ করবেন

আপনি হে (1) দিয়ে একটি উপাদান পুনরুদ্ধার করতে পারেন এবং কেবলমাত্র একটি সারি এবং ম্যাট্রিক্সের একটি কলামের স্থান প্রয়োজন

bool[][] matrix =
{
    new[] { true, false, true, true, false }, // 10110
    new[] { false, true, true, true, false }, // 01110
    new[] { true, true, true, true, true },   // 11111
    new[] { true, false, true, true, true },  // 10111
    new[] { true, true, true, true, true }    // 11111
};

int n = matrix.Length;
bool[] enabledRows = new bool[n];
bool[] enabledColumns = new bool[n];

for (int i = 0; i < n; i++)
{
    enabledRows[i] = true;
    enabledColumns[i] = true;
}

for (int rowIndex = 0; rowIndex < n; rowIndex++)
{
    for (int columnIndex = 0; columnIndex < n; columnIndex++)
    {
        bool element = matrix[rowIndex][columnIndex];
        enabledRows[rowIndex] &= element;
        enabledColumns[columnIndex] &= element;
    }
}

for (int rowIndex = 0; rowIndex < n; rowIndex++)
{
    for (int columnIndex = 0; columnIndex < n; columnIndex++)
    {
        bool element = enabledRows[rowIndex] & enabledColumns[columnIndex];
        Console.Write(Convert.ToInt32(element));
    }
    Console.WriteLine();
}

/*
    00000
    00000
    00110
    00000
    00110
*/
— শুভক্ষণ
সূত্র
আমি মনে করি একমাত্র সমস্যাটি হ'ল আপনি এই কাজটি করতে দুটি অতিরিক্ত অ্যারে ডেটা ব্যবহার করছেন। অন্যতম শর্ত হ'ল অতিরিক্ত স্মৃতিশক্তি ব্যবহার না করা। তবে সুন্দর! এটি আমার
— উত্তরটিতে
0

1 পাস, 2 বুলিয়ান। আমি কেবল পুনরাবৃত্তির মধ্যে পূর্ণসংখ্য সূচকগুলি গণনা করি না।

এটি সম্পূর্ণ সমাধান নয় তবে আমি এই পয়েন্টটি পাস করতে পারি না।

যদি আমি কেবল এটি নির্ধারণ করতে পারি যে 0 0 একটি মূল 0 বা 1 1 যা 0 এ রূপান্তরিত হয়েছিল তবে আমাকে -1 ব্যবহার করতে হবে না এবং এটি কাজ করবে।

আমার আউটপুটটি এরকম:

-1  0 -1 -1  0
 0 -1 -1 -1  0
-1 -1  1  1 -1
-1  0 -1 -1 -1
-1 -1  1  1 -1

আমার পদ্ধতির মৌলিকতা সারি বা কলামের পরীক্ষার প্রথমার্ধটি ব্যবহার করে এটির মান নির্ধারণে 0 এবং শেষ অর্ধেক রয়েছে কিনা তা নির্ধারণ করতে - এটি এক্স এবং প্রস্থ-এক্স এবং তারপরে y এবং উচ্চতা দেখে সম্পন্ন করা হয় -আর প্রতিটি পুনরাবৃত্তিতে পুনরাবৃত্তির প্রথমার্ধের ফলাফলের উপর ভিত্তি করে, যদি সারি বা কলামে 0 পাওয়া যায়, তবে আমি পুনরাবৃত্তির শেষ অর্ধেক 1-এর -1 এর পরিবর্তন করতে ব্যবহার করি।

আমি কেবল বুঝতে পেরেছিলাম যে এটি 1 টি বুলিয়ান 1 থেকে 1 রেখে ...

আমি এই পোস্টটি করছি এই আশায় যে কেউ বলতে পারে, "আহা, কেবল এটি করুন ..." (এবং আমি পোস্ট না করার জন্য অনেক বেশি সময় ব্যয় করেছি))

ভিবিতে কোডটি এখানে:

Dim D(,) As Integer = {{1, 0, 1, 1, 1}, {0, 1, 1, 0, 1}, {1, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {0, 0, 1, 1, 1}}

Dim B1, B2 As Boolean

For y As Integer = 0 To UBound(D)

    B1 = True : B2 = True

    For x As Integer = 0 To UBound(D)

        // Scan row for 0's at x and width - x positions. Halfway through I'll konw if there's a 0 in this row.
        //If a 0 is found set my first boolean to false.
        If x <= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
            If D(x, y) = 0 Or D(UBound(D) - x, y) = 0 Then B1 = False
        End If

        //If the boolean is false then a 0 in this row was found. Spend the last half of this loop
        //updating the values. This is where I'm stuck. If I change a 1 to a 0 it will cause the column
        //scan to fail. So for now I change to a -1. If there was a way to change to 0 yet later tell if
        //the value had changed this would work.
        If Not B1 Then
            If x >= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
                If D(x, y) = 1 Then D(x, y) = -1
                If D(UBound(D) - x, y) = 1 Then D(UBound(D) - x, y) = -1
            End If
        End If

        //These 2 block do the same as the first 2 blocks but I switch x and y to do the column.
        If x <= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
            If D(y, x) = 0 Or D(y, UBound(D) - x) = 0 Then B2 = False
        End If

        If Not B2 Then
            If x >= (Math.Ceiling((UBound(D) + 1) / 2) - 1) Then
                If D(y, x) = 1 Then D(y, x) = -1
                If D(y, UBound(D) - x) = 1 Then D(y, UBound(D) - x) = -1
            End If
        End If

    Next
Next
— rvarcher
সূত্র
0

কেউ বাইনারি ফর্ম ব্যবহার করছে না? যেহেতু এটি কেবল 1 এবং 0। আমরা বাইনারি ভেক্টর ব্যবহার করতে পারি।

def set1(M, N):
    '''Set 1/0s on M according to the rules.

    M is a list of N integers. Each integer represents a binary array, e.g.,
    000100'''
    ruler = 2**N-1
    for i,v in enumerate(M):
        ruler = ruler & M[i]
        M[i] = M[i] if M[i]==2**N-1 else 0  # set i-th row to all-0 if not all-1s
    for i,v in enumerate(M):
        if M[i]: M[i] = ruler
    return M

পরীক্ষাটি এখানে:

M = [ 0b10110,
      0b01110,
      0b11111,
      0b10111,
      0b11111 ]

print "Before..."
for i in M: print "{:0=5b}".format(i)

M = set1(M, len(M))
print "After..."
for i in M: print "{:0=5b}".format(i)

এবং আউটপুট:

Before...
10110
01110
11111
10111
11111
After...
00000
00000
00110
00000
00110
— KFL
সূত্র
0

আপনি একটি পাস ব্যবহার করতে এই জাতীয় কিছু করতে পারেন তবে একটি ইনপুট এবং আউটপুট ম্যাট্রিক্স:

output(x,y) = col(xy) & row(xy) == 2^n

col(xy)পয়েন্টটি সহ কলামে বিটগুলি কোথায় xy; row(xy)পয়েন্ট সহ সারিতে থাকা বিটগুলি xy। nম্যাট্রিক্সের আকার।

তারপরে কেবল ইনপুটটি লুপ করুন। সম্ভবত আরও স্থান দক্ষ হতে প্রসারিত?

— Warbum
সূত্র
0

একটি ম্যাট্রিক্স স্ক্যান, দুটি বুলিয়ান, পুনরাবৃত্তি নেই।

কীভাবে দ্বিতীয় পাস এড়ানো যায়? দ্বিতীয় পাসের সীমা বা কলামগুলি সাফ করার জন্য যখন তাদের শেষে শূন্য প্রদর্শিত হবে প্রয়োজন needed

তবে এই সমস্যাটি সমাধান করা যেতে পারে, কারণ যখন আমরা সারি # i স্ক্যান করি আমরা ইতিমধ্যে # i-1 সারির সারি স্থিতিটি জানি। সুতরাং, যখন আমরা #i সারিটি স্ক্যান করছি আমরা প্রয়োজন হয় তবে আমরা একই সাথে সারি # i-1 সাফ করতে পারি।

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

প্রথম সারি এবং প্রথম কলামের স্থিতি সংরক্ষণ করতে দুটি বুলিয়ান প্রয়োজন, কারণ অ্যালগরিদমের মূল অংশটি কার্যকর করার সময় তাদের মানগুলি পরিবর্তন করা হবে।

আরও বুলিয়ান যুক্ত এড়ানোর জন্য আমরা ম্যাট্রিক্সের প্রথম সারিতে এবং কলামে সারি এবং কলামগুলির জন্য "পরিষ্কার" পতাকাটি সংরক্ষণ করছি।

public void Run()
{
    const int N = 5;

    int[,] m = new int[N, N] 
                {{ 1, 0, 1, 1, 0 },
                { 1, 1, 1, 1, 0 },
                { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 },
                { 1, 1, 1, 1, 1 }};

    bool keepFirstRow = (m[0, 0] == 1);
    bool keepFirstColumn = keepFirstRow;

    for (int i = 1; i < N; i++)
    {
        keepFirstRow = keepFirstRow && (m[0, i] == 1);
        keepFirstColumn = keepFirstColumn && (m[i, 0] == 1);
    }

    Print(m); // show initial setup

    m[0, 0] = 1; // to protect first row from clearing by "second pass"

    // "second pass" is performed over i-1 row/column, 
    // so we use one more index just to complete "second pass" over the 
    // last row/column
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= N; j++)
        {
            // "first pass" - searcing for zeroes in row/column #i
            // when i = N || j == N it is additional pass for clearing 
            // the previous row/column
            // j >= i because cells with j < i may be already modified 
            // by "second pass" part
            if (i < N && j < N && j >= i) 
            {
                m[i, 0] &= m[i, j];
                m[0, j] &= m[i, j];

                m[0, i] &= m[j, i];
                m[j, 0] &= m[j, i];
            }

            // "second pass" - clearing the row/column scanned 
            // in the previous iteration
            if (m[i - 1, 0] == 0 && j < N)
            {
                m[i - 1, j] = 0;
            }

            if (m[0, i - 1] == 0 && j < N)
            {
                m[j, i - 1] = 0;
            }
        }

        Print(m);
    }

    // Clear first row/column if needed
    if (!keepFirstRow || !keepFirstColumn)
    {
        for (int i = 0; i < N; i++)
        {
            if (!keepFirstRow)
            {
                m[0, i] = 0;
            }
            if (!keepFirstColumn)
            {
                m[i, 0] = 0;
            }
        }
    }

    Print(m);

    Console.ReadLine();
}

private static void Print(int[,] m)
{
    for (int i = 0; i < m.GetLength(0); i++)
    {
        for (int j = 0; j < m.GetLength(1); j++)
        {
            Console.Write(" " + m[i, j]);
        }
        Console.WriteLine();
    }
    Console.WriteLine();
}
— Artemix
সূত্র
0

অতিরিক্ত স্থানের প্রয়োজনীয়তা ছাড়াই নিম্নলিখিতটি কাজ করে বলে মনে হচ্ছে:

প্রথম নোট করুন যে সারির উপাদানগুলিকে রেখার যে উপাদানগুলিতে রেখাঙ্কন করা হয় তার গুণকে গুণিত করে কাঙ্ক্ষিত মান দেয়।

কোনও অতিরিক্ত স্থান ব্যবহার না করার জন্য (নতুন ম্যাট্রিক্স তৈরি না করে এটি পূরণ করা নয় বরং পরিবর্তে সরাসরি ম্যাট্রিক্সে পরিবর্তনগুলি প্রয়োগ করুন), ম্যাট্রিক্সের উপরের বামদিকে শুরু করুন এবং কোনও ixi ম্যাট্রিক্সের জন্য গণনা করুন (এটি "শুরু হয়" (0 এ) , 0)) কোনও সূচক> i। এর সাথে কোনও উপাদান বিবেচনা করার আগে।

আশা করি এই কাজ (হ্যাঁ টেস্টেট)

— DFF
সূত্র
ভুল বলে মনে হচ্ছে। ধরুন যে সারি 0 টির 1 টি মান রয়েছে। আপনি যদি (0,0) এর জন্য নির্ধারিত চূড়ান্ত মান 0 হয় তবে আপনি পরে সম্পূর্ণ সারি 0 তে সেট করবেন যা প্রয়োজনীয়ভাবে সঠিক নয়। আপনার নীতিটি ব্যবহার করে গতিশীল প্রোগ্রামিং স্টাইলটি করার জন্য আপনাকে আসলে প্রতি ঘরে দুটি মান সংরক্ষণ করতে হবে।
— আইয়াল স্নাইডার
অবশ্যই, আপনি ঠিক বলেছেন। দুটি মান সংরক্ষণ করার পরিবর্তে আমি তৃতীয় পজিটিবিলিটিও ব্যবহার করতে পারি, বলুন -1, যা "পুরাতন" ম্যাট্রিক্সের 1 টির জন্য রয়েছে যা শেষ পর্যন্ত 0 দ্বারা প্রতিস্থাপন করা হবে অবশ্যই, এইভাবে, একজনকে নিখুঁত পদক্ষেপ নিতে হবে গুণনের পরে মানগুলি। শেষ পর্যন্ত, সমস্ত -1 0 এর দ্বারা প্রতিস্থাপিত হয়।
— DFF
0

এই হয় পরীক্ষিত C ++ বিভিন্ন এন জন্য, এবং হল:
এক পাস , দুই BOOLS , কোন recursion , কোন অতিরিক্ত মেমরি , ARBITRARLY বড় এন জন্য ঝুলিতে
(এ পর্যন্ত সমাধান এখানে কেউই কি এই সব।)

আরও সুনির্দিষ্টভাবে, আমি দু'টি লুপের কাউন্টার ঠিক করছি। আমার দুটি কনস্টে স্বাক্ষর নেই, যা কেবলমাত্র পঠনযোগ্যতার জন্য প্রতিবার গণনা করার পরিবর্তে বিদ্যমান। বাহ্যিক লুপের ব্যবধান [0, N] এবং অভ্যন্তরীণ লুপের বিরতি [1, n - 1] হয়। স্যুইচ স্টেটমেন্টটি লুপটিতে রয়েছে বেশিরভাগ স্পষ্টভাবে দেখানোর জন্য যে এটি সত্যই কেবল একটি পাস।

অ্যালগরিদম কৌশল:

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

অ্যালগরিদম সারসংক্ষেপ:

  • প্রথম সারিটি স্ক্যান করুন এবং যদি তারা সবগুলি বুলিয়ান থাকে তবে এটি দ্বিতীয় বুলিয়ান-এ ফলাফল সংরক্ষণের জন্য প্রথম কলামের জন্য একই করুন।
  • প্রথম সারি এবং প্রথম কলাম ব্যতীত সাব-ম্যাট্রিক্সের জন্য: পুনরাবৃত্তি করুন, বাম থেকে ডানে, উপরে থেকে নীচে, যেমন কোনও অনুচ্ছেদ পড়বে read প্রতিটি উপাদান পরিদর্শন করার পরে, বিপরীতে সাব-ম্যাট্রিক্স পরিদর্শন করা হলে সংশ্লিষ্ট উপাদানটিও পরিদর্শন করুন। প্রতিটি উপাদান দেখার জন্য এবং তার মানটি যেখানে সারিটি প্রথম কলামটি অতিক্রম করে সেখানে এবং তার কলামটি প্রথম সারিতে যে জায়গাটি অতিক্রম করে সেখানে value
  • সাব-ম্যাট্রিক্সের কেন্দ্রটি পৌঁছে গেলে উপরের মত দুটি উপাদান এক সাথে দেখতে যাওয়া চালিয়ে যান। তবে এখন যেখানে পরিদর্শন করা উপাদানগুলির মানটিকে তার সারিটি প্রথম কলামটি অতিক্রম করবে এবং যেখানে এর কলামটি প্রথম সারিটি অতিক্রম করবে সেখানে সেট করুন। এর পরে, সাব-ম্যাট্রিক্স সম্পূর্ণ।
  • প্রথম সারিতে সেট করার জন্য ভিক্ষাবৃত্তিতে গণনা করা দুটি বুলিয়ান ভেরিয়েবল এবং তাদের সঠিক মানগুলিতে প্রথম কলামটি ব্যবহার করুন।

ছদ্মবেশী সি ++ বাস্তবায়ন:

template<unsigned n>
void SidewaysAndRowColumn(int((&m)[n])[n]) {
    bool fcol = m[0][0] ? true : false;
    bool frow = m[0][0] ? true : false;
    for (unsigned d = 0; d <= n; ++d) {
        for (unsigned i = 1; i < n; ++i) {
            switch (d) {
                case 0:
                    frow    = frow && m[d][i];
                    fcol    = fcol && m[i][d];
                    break;
                default:
                {
                    unsigned const rd = n - d;
                    unsigned const ri = n - i;
                    if (d * n + i < rd * n + ri)
                    {
                        m[ d][ 0] &= m[ d][ i];
                        m[ 0][ d] &= m[ i][ d];
                        m[ 0][ i] &= m[ d][ i];
                        m[ i][ 0] &= m[ i][ d];
                        m[rd][ 0] &= m[rd][ri];
                        m[ 0][rd] &= m[ri][rd];
                        m[ 0][ri] &= m[rd][ri];
                        m[ri][ 0] &= m[ri][rd];
                    }
                    else
                    {
                        m[ d][ i] = m[ d][0] & m[0][ i];
                        m[rd][ri] = m[rd][0] & m[0][ri];
                    }
                    break;
                }
                case n:
                    if (!frow)
                        m[0][i] = 0;
                    if (!fcol)
                        m[i][0] = 0;
            };
        }
    }
    m[0][0] = (frow && fcol) ? 1 : 0;
}
— অবরোহী
সূত্র
0

ঠিক আছে, আমি বুঝতে পেরেছি যে এটি কোনও মিল নয়, তবে আমি দুটি পাসের পরিবর্তে একটি বুল এবং একটি বাইট ব্যবহার করে একটি পাসে পেয়েছি ... বন্ধ। আমি এর দক্ষতার জন্যও নিশ্চয়তা দিই না তবে এই ধরণের প্রশ্নগুলির প্রায়শই সর্বোত্তম সমাধানগুলির চেয়ে কম প্রয়োজন।

private static void doIt(byte[,] matrix)
{
    byte zeroCols = 0;
    bool zeroRow = false;

    for (int row = 0; row <= matrix.GetUpperBound(0); row++)
    {
        zeroRow = false;
        for (int col = 0; col <= matrix.GetUpperBound(1); col++)
        {
            if (matrix[row, col] == 0)
            {

                zeroRow = true;
                zeroCols |= (byte)(Math.Pow(2, col));

                // reset this column in previous rows
                for (int innerRow = 0; innerRow < row; innerRow++)
                {
                    matrix[innerRow, col] = 0;
                }

                // reset the previous columns in this row
                for (int innerCol = 0; innerCol < col; innerCol++)
                {
                    matrix[row, innerCol] = 0;
                }
            }
            else if ((int)(zeroCols & ((byte)Math.Pow(2, col))) > 0)
            {
                matrix[row, col] = 0;
            }

            // Force the row to zero
            if (zeroRow) { matrix[row, col] = 0; }
        }
    }
}
— ওয়ালারি স্ট্রাচ
সূত্র
0

আপনি এটিকে এক পাসে বাছাই করতে পারেন - যদি আপনি ম্যাট্রিক্সে এলোমেলোভাবে অ্যাক্সেস ক্রমে গণনা না করেন যা এটি প্রথম স্থানে একক-পাস করার সুবিধাগুলি সরিয়ে দেয় (ক্যাশে-কোহ্যারেন্স / মেমরি-ব্যান্ডউইথ)।

[সম্পাদনা করুন: সহজ, তবে ভুল সমাধান মুছে গেছে]

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

void fixmatrix2(int M[][], int rows, int cols) {
    bool clearZeroRow= false;
    bool clearZeroCol= false;
    for(int j=0; j < cols; ++j) {
        if( ! M[0][j] ) {
            clearZeroRow= true;
        }
    }
    for(int i=1; i < rows; ++i) { // scan/accumulate pass
        if( ! M[i][0] ) {
            clearZeroCol= true;
        }
        for(int j=1; j < cols; ++j) {
            if( ! M[i][j] ) {
                M[0][j]= 0;
                M[i][0]= 0;
            }
        }
    }
    for(int i=1; i < rows; ++i) { // update pass
        if( M[i][0] ) {
            for(int j=0; j < cols; ++j) {
                if( ! M[j][0] ) {
                    M[i][j]= 0;
                }
            }
        } else {
            for(int j=0; j < cols; ++j) {
                M[i][j]= 0;
            }
        }
        if(clearZeroCol) {
            M[i][0]= 0;
        }
    }
    if(clearZeroRow) {
        for(int j=0; j < cols; ++j) {
            M[0][j]= 0;
        }
    }
}
— comingstorm
সূত্র
0

আমি যে সহজ সমাধানটি ভাবতে পারি তা নীচে আটকানো হয়েছে। যুক্তিটি হ'ল পুনরাবৃত্তির সময় কোন সারি এবং কলামটি শূন্য সেট করতে হবে তা রেকর্ড করা।

import java.util.HashSet;
import java.util.Set;

public class MatrixExamples {
    public static void zeroOut(int[][] myArray) {
        Set<Integer> rowsToZero = new HashSet<>();
        Set<Integer> columnsToZero = new HashSet<>();

        for (int i = 0; i < myArray.length; i++) { 
            for (int j = 0; j < myArray.length; j++) {
                if (myArray[i][j] == 0) {
                    rowsToZero.add(i);
                    columnsToZero.add(j);
                }
            }
        }

        for (int i : rowsToZero) {
            for (int j = 0; j < myArray.length; j++) {
                myArray[i][j] = 0;
            }
        }

        for (int i : columnsToZero) {
            for (int j = 0; j < myArray.length; j++) {
                myArray[j][i] = 0;
            }
        }

        for (int i = 0; i < myArray.length; i++) { // record which rows and                                             // columns will be zeroed
            for (int j = 0; j < myArray.length; j++) {
                System.out.print(myArray[i][j] + ",");
            if(j == myArray.length-1)
                System.out.println();
            }
        }

    }

    public static void main(String[] args) {
        int[][] a = { { 1, 0, 1, 1, 0 }, { 0, 1, 1, 1, 0 }, { 1, 1, 1, 1, 1 },
                { 1, 0, 1, 1, 1 }, { 1, 1, 1, 1, 1 } };
        zeroOut(a);
    }
}
— geekprogrammer
সূত্র
0

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

require "spec_helper"


class Matrix
    def initialize(input)
        @input  = input
        @zeros  = []
    end

    def solve
        @input.each_with_index do |row, i|          
            row.each_with_index do |element, j|                             
                @zeros << [i,j] if element == 0
            end
        end

        @zeros.each do |x,y|
            set_h_zero(x)
            set_v_zero(y)
        end

        @input
    end


    private 

    def set_h_zero(row)     
        @input[row].map!{0}     
    end

    def set_v_zero(col)
        @input.size.times do |r|
            @input[r][col] = 0
        end
    end
end


describe "Matrix" do
  it "Should set the row and column of Zero to Zeros" do
    input =  [[1, 3, 4, 9, 0], 
              [0, 3, 5, 0, 8], 
              [1, 9, 6, 1, 9], 
              [8, 3, 2, 0, 3]]

    expected = [[0, 0, 0, 0, 0],
                [0, 0, 0, 0, 0],
                [0, 9, 6, 0, 0],
                [0, 0, 0, 0, 0]]

    matrix = Matrix.new(input)

    expect(matrix.solve).to eq(expected)
  end
end
— একি একবাল
সূত্র
0

নীচের কোডটি আকারের এম, এন এর একটি ম্যাট্রিক্স তৈরি করে। প্রথমে ম্যাট্রিক্সের মাত্রা নির্ধারণ করুন। আমি ম্যাট্রিক্স [এম] [এন] এলোমেলোভাবে 0..10 এর মধ্যে সংখ্যার সাথে পূরণ করতে চেয়েছিলাম। তারপরে একই মাত্রার আরেকটি ম্যাট্রিক্স তৈরি করুন এবং এটি -1 (ফাইনাল ম্যাট্রিক্স) দিয়ে পূরণ করুন। তারপরে প্রাথমিক ম্যাট্রিক্সটি দিয়ে পুনরাবৃত্তি করুন আপনি 0 টি আঘাত পাবেন কিনা তা দেখার জন্য আপনি যখন অবস্থানটি (x, y) তে আঘাত করবেন তখন চূড়ান্ত ম্যাট্রিক্সে যান এবং 0s এবং 0s দিয়ে কলাম y পূরণ করুন। শেষে চূড়ান্ত ম্যাট্রিক্সের মাধ্যমে পড়ুন, মান -1 (মূল মান) হলে প্রাথমিক ম্যাট্রিক্সের একই স্থানে মানটিকে চূড়ান্ত করে অনুলিপি করুন।

public static void main(String[] args) {
    int m = 5;
    int n = 4;
    int[][] matrixInitial = initMatrix(m, n); // 5x4 matrix init randomly
    int[][] matrixFinal = matrixNull(matrixInitial, m, n); 
    for (int i = 0; i < m; i++) {
        System.out.println(Arrays.toString(matrixFinal[i]));
    }
}

public static int[][] matrixNull(int[][] matrixInitial, int m, int n) {
    int[][] matrixFinal = initFinal(m, n); // create a matrix with mxn and init it with all -1
    for (int i = 0; i < m; i++) { // iterate in initial matrix
        for (int j = 0; j < n; j++) {
            if(matrixInitial[i][j] == 0){ // if a value is 0 make rows and columns 0
                makeZeroX(matrixFinal, i, j, m, n); 
            }
        }
    }

    for (int i = 0; i < m; i++) { // if value is -1 (original) copy from initial
        for (int j = 0; j < n; j++) {
            if(matrixFinal[i][j] == -1) {
                matrixFinal[i][j] = matrixInitial[i][j];
            }
        }
    }
    return matrixFinal;
}

private static void makeZeroX(int[][] matrixFinal, int x, int y, int m, int n) {
        for (int j = 0; j < n; j++) { // make all row 0
            matrixFinal[x][j] = 0;
        }
        for(int i = 0; i < m; i++) { // make all column 0
            matrixFinal[i][y] = 0; 
        }
}

private static int[][] initMatrix(int m, int n) {

    int[][] matrix = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            Random rn = new Random();
            int random = rn.nextInt(10);
            matrix[i][j] = random;
        }
    }

    for (int i = 0; i < m; i++) {
        System.out.println(Arrays.toString(matrix[i]));
    }
    System.out.println("******");
    return matrix;
}

private static int[][] initFinal(int m, int n) {

    int[][] matrix = new int[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            matrix[i][j] = -1;
        }
    }
    return matrix;
}

// another approach
/**
 * @param matrixInitial
 * @param m
 * @param n
 * @return
 */
private static int[][] matrixNullNew(int[][] matrixInitial, int m, int n) {
    List<Integer> zeroRowList = new ArrayList<>(); // Store rows with 0
    List<Integer> zeroColumnList = new ArrayList<>(); // Store columns with 0
    for (int i = 0; i < m; i++) { // read through the matrix when you hit 0 add the column to zeroColumnList and add
                                  // the row to zeroRowList
        for (int j = 0; j < n; j++) {
            if (matrixInitial[i][j] == 0) {
                if (!zeroRowList.contains(i)) {
                    zeroRowList.add(i);
                }
                if (!zeroColumnList.contains(j)) {
                    zeroColumnList.add(j);
                }
            }
        }
    }

    for (int a = 0; a < m; a++) {
        if (zeroRowList.contains(a)) { // if the row has 0
            for (int b = 0; b < n; b++) {
                matrixInitial[a][b] = 0; // replace all row with zero
            }
        }
    }

    for (int b = 0; b < n; b++) {
        if (zeroColumnList.contains(b)) { // if the column has 0
            for (int a = 0; a < m; a++) {
                matrixInitial[a][b] = 0; // replace all column with zero
            }
        }
    }
    return matrixInitial;
}
— user3743369
সূত্র
আপনার পোস্ট করা কোডটির কোনও ব্যাখ্যা বা প্রসঙ্গ দেবেন না।
— হারুন
আশা করি এখন আরও ভাল হয়। সতর্ক করার জন্য ধন্যবাদ. আমি আরও ব্যাখ্যা করতে চাই, যদি এটি আপনার পক্ষে পরিষ্কার না হয়।
— user3743369
0

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

public class EntireRowSetToZero {
    static int arr[][] = new int[3][4];
    static {

    arr[0][0] = 1;
    arr[0][1] = 9;
    arr[0][2] = 2;
    arr[0][3] = 2;

    arr[1][0] = 1;
    arr[1][1] = 5;
    arr[1][2] = 88;
    arr[1][3] = 7;

    arr[2][0] = 0;
    arr[2][1] = 8;
    arr[2][2] = 4;
    arr[2][3] = 4;
}

public static void main(String[] args) {
    displayArr(EntireRowSetToZero.arr, 3, 4);
    setRowToZero(EntireRowSetToZero.arr);
    System.out.println("--------------");
    displayArr(EntireRowSetToZero.arr, 3, 4);


}

static int[][] setRowToZero(int[][] arr) {
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr[i].length; j++) {
            if(arr[i][j]==0){
                arr[i]=new int[arr[i].length];
            }
        }

    }
    return arr;
}

static void displayArr(int[][] arr, int n, int k) {

    for (int i = 0; i < n; i++) {

        for (int j = 0; j < k; j++) {
            System.out.print(arr[i][j] + " ");
        }
        System.out.println("");
    }

}

}

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