Според вас вярно ли е този начин по който съм я решил ?
1. Създавам масив с подредени числа 1.. 16
2. Правя Array.Reverse на числата които трябва да се обърнат.
3 . Записвам в матрицата.
[C#] Домашно Multidimensional Arrays - 1 Задача
Отговори
1
Здравей,
Според мен си я решил за n=4. Добре ще е да го автоматизираш все пак и за различно n. Най-добре да се въвежда от потребителя. Алгоритъма ти е интересен, но имай предвид че Array.Reverse при по-дълги масиви и повече повторения ще работи бавно, но за тази задача вероятно ще е ок. Иначе можеш просто да пълниш матрицата директно, като сменяш първия и последния ред при четна и нечетна колона.
Поздрави,
Според мен си я решил за n=4. Добре ще е да го автоматизираш все пак и за различно n. Най-добре да се въвежда от потребителя. Алгоритъма ти е интересен, но имай предвид че Array.Reverse при по-дълги масиви и повече повторения ще работи бавно, но за тази задача вероятно ще е ок. Иначе можеш просто да пълниш матрицата директно, като сменяш първия и последния ред при четна и нечетна колона.
Поздрави,
0
Хитро решение. Харесва ми. Обаче, пробвай да го направиш, така че да работи и за други числа освен 4. Тогава, обаче трябва да помислиш за начина, по който казваш къде да се обръща масива, защото, ако имаш N = 10, ще трябва да напишеш 5 пъти Array.Reverse :)
0
Ами мисля, че така е по-дървено, защото ти си му задал къде да се обръща - при 4 и 12, обаче ако масива ти не е 4Х4, а е примерно 12Х12 размери, ще се обърне само при 4 и 12 и нататък нищо. Поправете ме ако греша, но аз това виждам :) Според мен можеш да го направиш по-динамичен да се върти на всеки n(дължината на масива) числа
Cheers!
Cheers!
0
0
Ето ви и едно интересно решение от мен:
Логиката му е следната:
1. Върти цикъл по колоните
2. Върти вложени два цикъла по редовете с логика if-else
3. Ако текущата колона е четно число - върти по ред++ (отгоре надолу)
4. Ако текущата колона е нечетно число - върти по ред-- (отдолу нагоре)
***0 се приема за четно число в случая и по колона 0 върти от горе надолу ред++
5. През цялото време увеличавам променливата digit++ на всяка стъпка от изпълнението на цикъла.
0
8
Здравейте колеги,
споделям решението на цялата задача с всички подточки.
Най-много ме изтормози подточка 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 цифри. При условие (>), без равното този проблем отпада.
0
Много странно защо при мен не се получава така...
Нали говорим за матрица 4х4? аз я пробвах току-що и си ми изкара перфектен отговор...
Аз нарочно искам при въртенето на ляво да стигна до = 1+offset.
При стойност на offset=0 - въртенето стига до колона 1, което е правилното решение, защото колона 0 е заета с цифрата 1, а колона 1 е празна и там трябва да бъде числото 13.
Може ли да поясниш как ти даде грешка?
2
Моето решение на вариант C:
http://pastebin.com/ShFZ7evq
Идеята ми е, че първо печатам числата преди основния диагонал, след това печатам основния диагонал и накрая печатам числата след основния диагонал.
Печатам числата само по редове. Има една последователност на нарастване на числата по редове и съм я включил като пример в решението.
Ако има въпроси относно решението, питайте :)
http://pastebin.com/ShFZ7evq
Идеята ми е, че първо печатам числата преди основния диагонал, след това печатам основния диагонал и накрая печатам числата след основния диагонал.
Печатам числата само по редове. Има една последователност на нарастване на числата по редове и съм я включил като пример в решението.
Ако има въпроси относно решението, питайте :)
0
От мен едно много смахнато решение на първата подзадача, което работи с всяко n. Попълвам по ред и колона, а не обратното. Намерих зависимост между поредните елементи на един ред: Индекса на колоната (cols), умножен по n (въведеното от потребителя число), събрани с индекса на реда (rows) + 1;
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
Логиката е същата с единствената разлика, че сменям посоките.
0
Аз лично D подточка я направих като сложих броячи за завъртанията (завъртанията са ((2*въведения n) - 1) + за отдалечаването от стените. Когато една права е готова, броячът за завъртанията се учвлеичава с единица и ако е четно число => печата по хоризонтала, ако е нечетно => по вертикала. Ето го и кодът ми: тук
