[C#] Домашно Multidimensional Arrays - 1 Задача


0

Според вас вярно ли е този начин по който съм я решил ?

1. Създавам масив с подредени числа 1.. 16 

2. Правя Array.Reverse на числата които трябва да се обърнат.

3 . Записвам в матрицата. 

http://pastebin.com/bLHqizsw

 




Отговори



1
Здравей,
Според мен си я решил за n=4. Добре ще е да го автоматизираш все пак и за различно n. Най-добре да се въвежда от потребителя. Алгоритъма ти е интересен, но имай предвид че Array.Reverse при по-дълги масиви и повече повторения ще работи бавно, но за тази задача вероятно ще е ок. Иначе можеш просто да пълниш матрицата директно, като сменяш първия и последния ред при четна и нечетна колона.
Поздрави,

от stanev.plamen (1143 точки)


0
Хитро решение. Харесва ми. Обаче, пробвай да го направиш, така че да работи и за други числа освен 4. Тогава, обаче трябва да помислиш за начина, по който казваш къде да се обръща масива, защото, ако имаш N = 10, ще трябва да напишеш 5 пъти Array.Reverse :)

от gstoyanov (5 точки)


0
Ами мисля, че така е по-дървено, защото ти си му задал къде да се обръща - при 4 и 12, обаче ако масива ти не е 4Х4, а е примерно 12Х12 размери, ще се обърне само при 4 и 12 и нататък нищо. Поправете ме ако греша, но аз това виждам :) Според мен можеш да го направиш по-динамичен да се върти на всеки n(дължината на масива) числа
Cheers!

от CaptCortez (1242 точки)


0
така ще направя благодаря за отговорите :)



0

Ето ви и едно интересно решение от мен:

http://pastebin.com/S7cEfTaS

Логиката му е следната:

1. Върти цикъл по колоните

2. Върти вложени два цикъла по редовете с логика if-else

3. Ако текущата колона е четно число - върти по ред++ (отгоре надолу)

4. Ако текущата колона е нечетно число - върти по ред-- (отдолу нагоре)

***0 се приема за четно число в случая и по колона 0 върти от горе надолу ред++

5. През цялото време увеличавам променливата digit++ на всяка стъпка от изпълнението на цикъла.




0
Моето е подобно :) Друго не се сетих :( засега :)

от CaptCortez (1242 точки)


8

Здравейте колеги,

споделям решението на цялата задача с всички подточки.

http://pastebin.com/Q8zc8a9L

Най-много ме изтормози подточка C. Докато измисля логиката на обхождане ми се видя сметката направо :)

Вариант A:

Елементарно. Два вложени for цикъла, първия върти по колона, втори вътре в него върти по ред и всичко е готово!

Вариант B:

1. Върти цикъл по колоните

2. Върти вложени два цикъла по редовете с логика if-else

3. Ако текущата колона е четно число - върти по ред++ (отгоре надолу)

4. Ако текущата колона е нечетно число - върти по ред-- (отдолу нагоре)

***0 се приема за четно число в случая и по колона 0 върти от горе надолу ред++

5. През цялото време увеличавам променливата digit++ на всяка стъпка от изпълнението на цикъла.

Вариант C:

Тук е интересно :)

Имам две променливи StartRow и StartCol. Те ми служат за указание на старта на писането на диагоналите.

Почвам от StartRow=N-1 и StartCol=0 и на всяка стъпка давам Row--. По този начин повдигам диагонала нагоре всеки път.

Когато достигна StartRow=0 и StartCol=0 и съм написал диагонала до Row=N-1 и Col=N-1 сменям логиката.

Вече почвам да въртя StartCol++, докато StartRow си е =0 постоянно. Пиша диагоналите докато не достигна Col=N-1.

Цялата логика я въртя в един while цикъл с условие (digit < N*N) където digit е всъщност самото число, което пиша в текущата клетка от матрицата.

digit нараства всеки път когато запиша стойност в клетка.

Вариант D:

Не е много сложно. Има 4 посоки на обхождане с различна логика

1. Започваме с посока надолу

Въртим редовете до N-1-offset

2. Посока надясно

Въртим колоните от 1+offset до N-1-offset

3. Посока нагоре

Въртим редовете на обратно Row-- от N-2-offset до 0+offset

4. Посока наляво

Въртим колоните на обратно Col-- от N-2-offset до 1+offset

След завършване на обхождащият кръг даваме offset++

Тази променлива я използвам с цел указание на положението на обхождащият кръг. При offset=1 цикълът обхожда от 1-ви ред и 1-ва колона, при offset=2 - обхожда 2-ри ред и 2-ра колона и така докато не стигнем до центъра на матрицата.

 




0
Всичко супер, но мисля че намерих грешка при вариант D. Със цикъла, който движи на ляво при (>= условие) се поставя цифрата (13) на мястото на 1, което вече е положено, след което ми излиза матрица с 17 цифри. При условие (>), без равното този проблем отпада.

от Joro1881 (42 точки)

0
Много странно защо при мен не се получава така... Нали говорим за матрица 4х4? аз я пробвах току-що и си ми изкара перфектен отговор... Аз нарочно искам при въртенето на ляво да стигна до = 1+offset. При стойност на offset=0 - въртенето стига до колона 1, което е правилното решение, защото колона 0 е заета с цифрата 1, а колона 1 е празна и там трябва да бъде числото 13. Може ли да поясниш как ти даде грешка?




2
Моето решение на вариант C:
http://pastebin.com/ShFZ7evq
Идеята ми е, че първо печатам числата преди основния диагонал, след това печатам основния диагонал и накрая печатам числата след основния диагонал.
Печатам числата само по редове. Има една последователност на нарастване на числата по редове и съм я включил като пример в решението.
Ако има въпроси относно решението, питайте :)

от teleriknetwork (2734 точки)


0

http://pastebin.com/n9wDbgEH

От мен едно много смахнато решение на първата подзадача, което работи с всяко n. Попълвам по ред и колона, а не обратното. Намерих зависимост между поредните елементи на един ред: Индекса на колоната (cols), умножен по n (въведеното от потребителя число), събрани с индекса на реда (rows) + 1;


от batebobo (235 точки)


0

Цък

a) Външният цикъл върви по колоните, а вътрешния по редовете и запълва матрицата по колони отгоре надолу.

b) Същата идея като а), но има 2 вътрешни цикъла - единият за колоните, които се запълват отгоре надолу и другият за тези, които се запълват отдолу нагоре, като това се определя на базата на четни и нечетни колони.

c) Тази задача е разделена на две. Първата част запълва от началната позиция до средния диагонал. Идеята е, ако не се излиза от границите на матрицата да се увеличават row & col, ако е достигнат края се "качваме" един ред нагоре и се връщаме на нулевата колона ( row-- , col = 0 ), докато row>=0.  Втората част следва същата логика, но този път се връщаме на row=0 и увеличаваме стартовата позиция за колона с 1.

d) Тази задача е решена с рекурсия и предварително зададени посоки на движение. Започваме с цифрата 1 от matrix[0,0] и продължаваме по първата посока, като извикваме отново същия метод и така докато стигнем до края на матрицата в тази посока. След това с while цикъла се намира следващата възможна посока и тръгваме по нея. С помощта на булев масив се маркират вече обходените полета, а рекурсията свършва, когато counter достигне квадрата на размера на матрицата, тъй като това и последната цифра и последното поле, което трябва да се запълни.




1

D)

Използвах видеото за спирала в C# първа част Spiral

Логиката е същата с единствената разлика, че сменям посоките.

http://pastebin.com/B71mmUnH

 




0
Написах коментар преди да видя целия клип.Сега ми стана ясно.

от Petar Atanasov (0 точки)


0

Аз лично D подточка я направих като сложих броячи за завъртанията (завъртанията са ((2*въведения n) - 1) + за отдалечаването от стените. Когато една права е готова, броячът за завъртанията се учвлеичава с единица и ако е четно число => печата по хоризонтала, ако е нечетно => по вертикала. Ето го и кодът ми: тук


от kalbo_17 (2709 точки)