فرز قائمة متعددة الأعمدة الرأسية

Question

هل لديها خوارزمية جيدة لإعادة الفرز مجموعة من القيم (بالفعل قبل فرز) بحيث يمكن عرضها في عدة (ن) أعمدة أن تقرأ عموديا ؟ هذا من شأنه أن يكون تنفيذها .صافي ولكن أفضل شيء المحمولة وليس بعض السحر وظيفة.

وخير مثال على ذلك هو ASP.Net CheckBoxList السيطرة على تقديم جدول مع اتجاه مجموعة العمودي.

هنا مثال من المدخلات والمخرجات:

الإدخال:

الأعمدة = 4
Array = {"أ", "ب", "ج", "د", "ه", "F", "G"}

الإخراج:

ACEG
BDF

وذلك بفضل!

تحديث (مزيد من المعلومات):

أعتقد أنني يجب أن تعطي معلومات أكثر قليلا على ما أحاول القيام به...في الغالب هذه المشكلة جاءت من الذهاب من استخدام CheckBoxList هذا الربط التلقائي (حيث يمكنك تحديد أعمدة الاتجاه إلى الإخراج ومن إخراج جدول العناصر في الترتيب الصحيح) باستخدام مسج/اياكس لإنشاء مربع الشبكة.لذا أحاول تكرار ذلك تخطيط باستخدام css مع شعبة كتل مع تحديد الاعراض (داخل حاوية div معروفة العرض) بحيث التفاف بعد ن البنود (أو الأعمدة.) وهذا يمكن أيضا أن تكون المقدمة في جدول (مثل كيف ASP.Net يفعل ذلك.)

كل شيء يعمل بشكل ممتاز ما عدا أمر الأفقي و عندما تحصل على عدد كبير من العناصر في قائمة سهولة قراءة الأعمدة الرأسية.

إذا كان الصفيف لا يملك ما يكفي من العناصر في ذلك حتى الشبكة ثم يجب إخراج بقعة فارغة في الصحيح صف/عمود الشبكة.

و إذا كان صفيف لا تملك ما يكفي من المواد لجعل حتى صف واحد فقط ثم إخراج العناصر في الترتيب الأصلي في صف واحد.

بعض الإدخال/الإخراج قد يكون:

الأعمدة = 3
Array = {"أ", "ب", "ج", "د"}

ACD
ب

الأعمدة = 5
Array = {"أ", "ب", "ج", "د", "ه", "F", "G", "H"}

ACEGH
BDF

الأعمدة = 5
Array = {"أ", "ب", "ج", "د"}

ABCD

Answer 1

حسنا, أنا آسف على بياني الأولي ، ولكن عندما تريد أن تعمل كما هو موضح لك في التعليق على أول الجواب ، تحتاج في الواقع إعادة فرز البيانات...حسنا إلى حد ما.بل ربما يكون ذلك دون مساعد مصفوفة ، ومع ذلك الرمز الناتج المحتمل جدا معقدة طالما المصفوفة سيتم فقط استخدام بضع بايت من الذاكرة, لماذا لا تستخدم هذا الصغير مساعد بناء?

ما البرمجية أدناه لا يتم إنشاء مصفوفة.يمكننا كتابة مصفوفة من أعلى إلى أسفل ومن اليسار إلى اليمين (ووقف ملء أي شيء ولكن الصف الأول عندما نهرب من عناصر لملء جميع أعمدة الصف الأول).ثم نقرأ في ترتيب مختلف ، اليسار إلى اليمين ومن أعلى إلى أسفل.أساسا ما نقوم به هنا هو نقل مصفوفة, من خلال كتابة ذلك في أمر واحد ، لكن القراءة في أمر آخر.نقل مصفوفة جدا الابتدائية عملية حسابية (الكثير من البرمجة 3D يعمل باستخدام مصفوفة الحسابات و نقل هو في الواقع عملية بسيطة).الخدعة هو كيف يمكننا في البداية ملء المصفوفة.للتأكد من أننا يمكن أن تملأ العمود الأول في أي حال ، بشكل مستقل من عدد من الأعمدة المطلوب و حجم المصفوفة ، يجب أن تتوقف على ملء المصفوفة في النظام الطبيعي إذا ما نفذ عناصر الاحتياط جميع العناصر على الصف الأول.هذا وسوف تنتج الناتج كنت قد اقترحت في تعليقك.

كل شيء هو أكثر تعقيدا من أن تكون صادقة ، ولكن النظرية وراء ذلك يجب أن يكون عاقل و يعمل جميلة :-D

int Columns;
char * Array[] = {"A", "B", "C", "D", "E", "F", "G"};

int main (
    int argc,
    char ** argv
) {
    // Lets thest this with all Column sizes from 1 to 7
    for (Columns = 1; Columns <= 7; Columns++) {

        printf("Output when Columns is set to %d\n", Columns);

        // This is hacky C for quickly get the number of entries
        // in a static array, where size is known at compile time
        int arraySize = sizeof(Array) / sizeof(Array[0]);

        // How many rows we will have
        int rows = arraySize / Columns;

        // Below code is the same as (arraySize % Columns != 0), but
        // it's almost always faster
        if (Columns * rows != arraySize) {
            // We might have lost one row by implicit rounding
            // performed for integer division
            rows++;
        }

        // Now we create a matrix large enough for rows * Columns
        // references. Note that this array could be larger than arraySize!
        char ** matrix = malloc(sizeof(char *) * rows * Columns);

        // Something you only need in C, C# and Java do this automatically:
        // Set all elements in the matrix to NULL(null) references
        memset(matrix, 0, sizeof(char *) * rows * Columns );

        // We fill up the matrix from top to bottom and then from
        // left to right; the order how we fill it up is very important
        int matrixX;
        int matrixY;
        int index = 0;
        for (matrixX = 0; matrixX < Columns; matrixX++) {
            for (matrixY = 0; matrixY < rows; matrixY++) {
                // In case we just have enough elements left to only
                // fill up the first row of the matrix and we are not
                // in this first row, do nothing.
                if (arraySize + matrixX + 1 - (index + Columns) == 0 &&
                        matrixY != 0) {
                    continue;
                }

                // We just copy the next element normally
                matrix[matrixY + matrixX * rows] = Array[index];
                index++;
                //arraySize--;
            }
        }

        // Print the matrix exactly like you'd expect a matrix to be
        // printed to screen, that is from left to right and top to bottom;
        // Note: That is not the order how we have written it,
        // watch the order of the for-loops!
        for (matrixY = 0; matrixY < rows; matrixY++) {
            for (matrixX = 0; matrixX < Columns; matrixX++) {
                // Skip over unset references
                if (matrix[matrixY + matrixX * rows] == NULL)
                    continue;

                printf("%s", matrix[matrixY + matrixX * rows]);
            }
            // Next row in output
            printf("\n");
        }
        printf("\n");

        // Free up unused memory
        free(matrix);
    }   
    return 0;
}

الناتج هو

Output when Columns is set to 1
A
B
C
D
E
F
G

Output when Columns is set to 2
AE
BF
CG
D

Output when Columns is set to 3
ADG
BE
CF

Output when Columns is set to 4
ACEG
BDF

Output when Columns is set to 5
ACEFG
BD

Output when Columns is set to 6
ACDEFG
B

Output when Columns is set to 7
ABCDEFG

هذه التعليمات البرمجية C يجب أن يكون من السهل إلى منفذ PHP, C#, Java, الخ ، لا يوجد كبير من السحر المعنية ، لذلك الى حد كبير عالمية المحمولة عبر منصة.

---

شيء واحد مهم وأود أن أضيف:

هذا الرمز سوف تحطم إذا قمت بتعيين الأعمدة الصفر (القسمة على صفر لا التحقق من ذلك), ولكن ما معنى أن 0 الأعمدة ؟ وسوف الحادث أيضا إذا كان لديك أكثر من الأعمدة من العناصر في الصفيف لا تحقق هذا أيضا.يمكنك بسهولة التحقق من وجود أي مباشرة بعد أن حصلت على arraySize:

if (Columns <= 0) {
   // Having no column make no sense, we need at least one!
   Columns = 1;
} else if (Columns > arraySize) {
   // We can't have more columns than elements in the array!
   Columns = arraySize;
}

كذلك يجب عليك أيضا التحقق من arraySize 0, في هذه الحالة يمكنك القفز مباشرة من وظيفة ، كما في هذه الحالة ليس هناك شيء على الاطلاق للقيام لوظيفة :) إضافة هذه الشيكات أن جعل رمز الصخور الصلبة.

وجود NULL العناصر في مجموعة العمل ، BTW, في هذه الحالة لا توجد ثقوب في الناتج.NULL عناصر هي مجرد تخطي مثل لا تكون موجودة.E. g.يتيح استخدام

char * Array[] = {"A", "B", "C", "D", "E", NULL, "F", "G", "H", "I"};

سوف يكون الإخراج

ADFI
BEG
CH

للأعمدة == 4.إذا كنت أريد الثقوب, تحتاج إلى إنشاء حفرة عنصر.

char hole = 0;
char * Array[] = {"A", "B", &hole, "C", "D", "E", &hole, "F", "G", "H", "I"};

وتعديل اللوحة رمز قليلا

    for (matrixY = 0; matrixY < rows; matrixY++) {
        for (matrixX = 0; matrixX < Columns; matrixX++) {
            // Skip over unset references
            if (matrix[matrixY + matrixX * rows] == NULL)
                continue;

            if (matrix[matrixY + matrixX * rows] == &hole) {
                printf(" ");
            } else {
                printf("%s", matrix[matrixY + matrixX * rows]);
            }
        }
        // Next row in output
        printf("\n");
    }
    printf("\n");

إخراج العينات:

Output when Columns is set to 2
A 
BF
 G
CH
DI
E

Output when Columns is set to 3
ADG
BEH
  I
CF

Output when Columns is set to 4
AC H
BDFI
 EG

Answer 2

تحديث صغير:

الخوارزمية أنا أستخدم هنا هو تعديل واحد كنت تستخدم لوحة الصور.انا اتظاهر مجموعة مقالات أن تكون البيانات بكسل من الصورة ثم أنا اللوحة الصورة من اليسار إلى اليمين (1.LtoR) و من أعلى إلى أسفل (2.TtoB) ، ومع ذلك ، فإن الصورة يتم تخزين البيانات من أعلى إلى أسفل (1.TtoB) ثم من اليسار إلى اليمين (2.LtoR);تكمن في ترتيب مختلف.لأن الصورة لا يمكن أن يكون الثقوب, هذا هو السبب في أنه لن يعمل مع 5 أو 6 أعمدة.مع 4 أعمدة الإخراج هو

ACEG
BDF

كصورة هذا يبدو مثل هذا

OOOO
OOO.

مع O كونه بكسل من الصورة .كونها غير محددة بكسل (واحد في عداد المفقودين).تلك المفقودة قد تكون فقط في نهاية الصورة ، وليس في وسطها.وهذا يعني أنه يمكن أيضا أن تبدو مثل هذا

OOO
OO.
OO.
OO.

كل بكسل في عداد المفقودين دائما في النهاية ، إذا كنت تقرأ أولا من أعلى إلى أسفل ، ثم من اليسار إلى اليمين ، لأنه في هذه الحالة كل بكسل في عداد المفقودين متابعة مباشرة بعضها البعض في نهاية المطاف.إذا قرأت الرسم TtoB ثم LtoR ، يجب قراءة مثل هذا "بكسل, بكسل, بكسل, بكسل, ..., بكسل, المفقود, المفقود, مفقود ... مفقود" ربما لم تقرأ "بكسل, في عداد المفقودين, بكسل" أو "المفقودين, بكسل, في عداد المفقودين".كل بكسل معا و في كل الحالات هي أيضا.

مع 5 أعمدة ، كما يقترح تعليق, يجب أن تبدو مثل هذا

ACEFG
BD

ومع ذلك ، كما الصورة هذا من شأنه أن تبدو مثل هذا

OOOOO
OO...

و هذا غير مسموح به من قبل الخوارزمية.إذا قرأته TtoB ثم LtoR ، فإنه سيتم قراءة:"بكسل, بكسل, بكسل, بكسل, بكسل, في عداد المفقودين, بكسل, في عداد المفقودين, بكسل, في عداد المفقودين".وكما ذكر أعلاه, هذا غير مسموح به من قبل الخوارزمية.اذا هذا بسيط اللوحة بكسل النهج لن الطلاء العديد من الأعمدة كما طلب لو اللوحة أن العديد من الأعمدة يؤدي إلى ثقوب في الصورة.في هذه الحالة فإنه ببساطة سوف تملأ ثقوب ومع ذلك ، فإن هذا سوف يسبب أقل الأعمدة التي يمكن استخلاصها.

اسمحوا لي أن أعتقد حل دائما ترسم طلب عدد بكسل (في الرد منفصل).

---

ليس لديك إلى إعادة ترتيب البيانات في الذاكرة في كل شيء.فقط طباعة في الترتيب المطلوب.

بعض التعليمات البرمجية C (أنا أفعل ذلك للغاية مطول, حتى يفهم الجميع ما أنا القيام بذلك.طبعا هذا يمكن أن يكون أكثر إحكاما):

int Columns = 4;
char * Array[] = {"A", "B", "C", "D", "E", "F", "G"};

int main (
    int argc,
    char ** argv
) {
    // This is hacky C for quickly get the number of entries
    // in a static array, where size is known at compile time
    int arraySize = sizeof(Array) / sizeof(Array[0]);

    // How many rows are we going to paint?
    int rowsToPaint = (arraySize / Columns) + 1;

    int col;
    int row;

    for (row = 0; row < rowsToPaint; row++) {
        for (col = 0; col < Columns; col++) {
            int index = col * rowsToPaint + row;

            if (index >= arraySize) {
                // Out of bounds
                continue;
            }

            printf("%s", Array[index]);
        }
        printf("\n"); // next row
    }
    printf("\n");
    return 0;
}

ملاحظة:هذا يعمل بشكل جيد مع قيمة 8 (حيث كل شيء ورسمت في صف واحد) وقيم 4 أدناه (يعمل بشكل جيد مع 3 ، 2 ، 1) ، ولكن لا يمكن أن تعمل مع 5.هذا ليس خطأ من الخوارزمية ، هو خطأ من تقييد.

ACEFG
BD

القيد يقول الأعمدة قراءة أعلى إلى أسفل للحصول على تصحيح فرز البيانات.ولكن فوق "المجموعة المالية"يتم فرز وليس من أعلى إلى أسفل ومن اليسار إلى اليمين.وبالتالي هذه الخوارزمية لديه مشكلة.باستخدام الأعمدة = 3 سوف تعمل

ADG
BE
CF

باستخدام اثنين سوف تعمل بشكل جيد

AE
BF
CG
D

واحد سوف يضع كل شيء في عمود واحد.

Answer 3

هذا يبدو مثل الواجبات المنزلية على كل حال

array<String^>^  sArray = {"A", "B", "C", "D", "E", "F", "G"};
double Columns = 4;
double dRowCount = Convert::ToDouble(sArray->Length) / Columns;
int rowCount = (int) Math::Ceiling(dRowCount);
int i = 0;
int shift = 0;
int printed = 0;
while (printed < sArray->Length){
    while (i < sArray->Length){
        if (i % rowCount == shift){
            Console::Write(sArray[i]);
            printed++;
        }
        i++;
    }
    Console::Write("\n");
    i = 0;
    shift++;
}