পাইথনে দ্বিমাত্রিক অ্যারে ঘোরানো

Question

একটি প্রোগ্রামে আমি লিখছি একটি দ্বি-মাত্রিক অ্যারেটি ঘোরানোর প্রয়োজনীয়তা উপস্থিত হয়েছিল। অনুকূল সমাধানের সন্ধান করতে আমি এই চিত্তাকর্ষক ওয়ান-লাইনারটি পেয়েছি যা কাজটি করে:

rotated = zip(*original[::-1])

আমি এখন এটি আমার প্রোগ্রামে ব্যবহার করছি এবং এটি অনুমিত হিসাবে কাজ করে। যদিও আমার সমস্যাটি হ'ল আমি জানি না এটি কীভাবে কাজ করে।

যদি কেউ ব্যাখ্যা করতে পারে যে জড়িত বিভিন্ন ফাংশনগুলি কীভাবে পছন্দসই ফলাফল অর্জন করে।

Comments

প্রকৃতপক্ষে. আমি এই এসও প্রশ্নে এটি খুঁজে পেয়েছি ।

— পলপদীপ

Answer 1

নিম্নলিখিত দ্বি-মাত্রিক তালিকা বিবেচনা করুন:

original = [[1, 2],
            [3, 4]]

এটিকে ধাপে ধাপে ভেঙে ফেলতে দেয়:

>>> original[::-1]   # elements of original are reversed
[[3, 4], [1, 2]]

এই তালিকাটি আর্গুমেন্ট আনপ্যাকিংzip() ব্যবহার করে পাস করা হয়েছে , সুতরাং কলটি এর সমতুল্য হয়ে যায়:zip

zip([3, 4],
    [1, 2])
#    ^  ^----column 2
#    |-------column 1
# returns [(3, 1), (4, 2)], which is a original rotated clockwise

আশা করি মন্তব্যগুলি এটিকে পরিষ্কার করে দেবে যে এটি কী zipকরে, এটি প্রতিটি ইনপুট থেকে উপাদানগুলি সূচির ভিত্তিতে পুনরাবৃত্তীয় করে বা অন্য কথায় এটি কলামগুলিকে গোষ্ঠীভূত করবে।

Comments

একটি কাছাকাছি। তবে আমি আপনাকে ঝরঝরে ASCII আর্টের কারণে বেছে নিয়েছি;)

— পলডিপাইন্ড

আর নক্ষত্র ??

— জন কেটেজিক

@ জোহঙ্কটেকিক - এটিই "যুক্তি আনপ্যাকিংয়ের" উত্তরের অংশ, বিশদটির জন্য লিঙ্কটি ক্লিক করুন

— জেআর

সুস্পষ্টতার জন্য, আপনাকে চিহ্নিত করতে হবে যে এটি ম্যাট্রিক্সকে ঘড়ির কাঁটার দিকে ঘোরায় এবং মূল থেকে তালিকাগুলি টুপলে রূপান্তরিত হয়।

— এভারেট

পুরো চেনাশোনায় যেতে (তালিকার তালিকাগুলি ফিরে পান এবং টিউপসগুলি না পেয়ে) আমি এটি করেছি:rotated = [list(r) for r in zip(*original[::-1])]

— ম্যাট

Answer 2

এটি একটি চালাক বিট।

প্রথমত, একটি মন্তব্যে উল্লিখিত হিসাবে, পাইথন 3 এ zip()একজন পুনরুক্তি প্রদানকারী ফেরত দেয়, সুতরাং আপনাকে list()আসল তালিকাটি ফিরে পেতে পুরো জিনিসটি ঘিরে ফেলতে হবে, সুতরাং ২০২০ সালের মধ্যে এটি আসলে:

list(zip(*original[::-1]))

এখানে ভাঙ্গন:

• [::-1]- বিপরীত ক্রমে মূল তালিকার অগভীর অনুলিপি তৈরি করে। reversed()তালিকাকে প্রকৃতপক্ষে অনুলিপি না করে (আরও মেমরি দক্ষ) তুলনায় বিপরীত পুনরায় উত্পাদনকারী ব্যবহার করতে পারে।
• *- মূল তালিকার প্রতিটি সাবলিস্টকে পৃথক যুক্তিযুক্ত করে তোলে zip()(অর্থাত্ তালিকাকে আনপ্যাক করে)
• zip()- প্রতিটি তর্ক থেকে একটি আইটেম নেয় এবং সেগুলি থেকে একটি তালিকা তৈরি করে (ভাল, একটি টিপল), এবং সমস্ত সাবলিস্টগুলি শেষ না হওয়া পর্যন্ত পুনরাবৃত্তি করে। এই স্থানান্তর আসলে ঘটে।
• list()আউটপুটকে zip()তালিকায় রূপান্তর করে ।

সুতরাং ধরে নিলাম আপনার কাছে এটি রয়েছে:

[ [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9] ]

আপনি প্রথমে এটি পাবেন (অগভীর, বিপরীত অনুলিপিটি):

[ [7, 8, 9],
  [4, 5, 6],
  [1, 2, 3] ]

পরবর্তী প্রতিটি সাবলিস্টকে এখানে যুক্তি হিসাবে পাস করা হয় zip:

zip([7, 8, 9], [4, 5, 6], [1, 2, 3])

zip() এর প্রতিটি আর্গুমেন্টের শুরু থেকে বারবার একটি আইটেম গ্রাস করে এবং এর থেকে আরও একটি আইটেম তৈরি করে, যতক্ষণ না কোনও আইটেম না থাকে, ফলস্বরূপ (এটি একটি তালিকায় রূপান্তরিত হওয়ার পরে):

[(7, 4, 1), 
 (8, 5, 2), 
 (9, 6, 3)]

এবং বব আপনার মামা।

একে অন্য দিকে ঘোরানো সম্পর্কে একটি মন্তব্যে @ আইকেমিগুয়েলের প্রশ্নের উত্তর দেওয়ার জন্য, এটি বেশ সোজা: আপনার কেবলমাত্র ক্রম zipএবং ফলাফল উভয়ই বিপরীত করতে হবে । প্রথমটিকে অপসারণের মাধ্যমে প্রথমটি অর্জন করা যায় [::-1]এবং দ্বিতীয়টি reversed()পুরো জিনিসটির চারপাশে ছুঁড়ে ফেলে অর্জন করা যায় । যেহেতু reversed()আয় তালিকা ধরে কোনো ইটারেটরে, আমরা করা প্রয়োজন হবে list()প্রায় যে এটা রূপান্তর করবে। list()পুনরাবৃত্তিকে একটি আসল তালিকায় রূপান্তর করতে বেশ কয়েকটি অতিরিক্ত কল সহ । তাই:

rotated = list(reversed(list(zip(*original))))

আমরা "মার্টিয়ান স্মাইলি" স্লাইস না করে কিছুটা সহজ করতে reversed()পারি ... তারপরে আমাদের বাইরের দরকার নেই list():

rotated = list(zip(*original))[::-1]

অবশ্যই, আপনি কেবল তালিকাটি ঘড়ির কাঁটার দিকে তিনবার ঘোরান। :-)

Comments

ঘড়ির কাঁটা পাল্টানো কি সম্ভব?

— মিগুয়েল আইকে

@ মিগুয়েলআইকি হ্যাঁ, জিপ করুন (* ম্যাট্রিক্স) [:: - 1]

— আরওয়াইএস

^ নোট করুন যে আপনাকে zipপাইথন ৩.x এর তালিকার ফলাফল দিতে হবে!

— আরওয়াইএস

Answer 3

এর তিনটি অংশ রয়েছে:

1. আসল [:: - 1] আসল অ্যারেটিকে বিপরীত করে। এই চিহ্নটি পাইথন তালিকার স্লাইসিং। এটি আপনাকে [সূচনা: সমাপ্তি: পদক্ষেপ] দ্বারা বর্ণিত মূল তালিকার একটি "সাবলিস্ট" দেয়, শুরুটি প্রথম উপাদানটি হয়, উপ-তালিকায় ব্যবহৃত হয় শেষ উপাদানটি শেষ। পদক্ষেপ বলে প্রতিটি পদক্ষেপের উপাদানটি প্রথম থেকে শেষ পর্যন্ত বলে। নির্ধারিত শুরু এবং শেষের অর্থ স্লাইসটি সম্পূর্ণ তালিকা হবে এবং নেতিবাচক পদক্ষেপের অর্থ আপনি বিপরীতে উপাদানগুলি পাবেন। সুতরাং, উদাহরণস্বরূপ, যদি মূল [x, y, z] হয় তবে ফলাফলটি [z, y, x] হবে
2. * যখন কোনও ফাংশন কলের আর্গুমেন্ট তালিকায় একটি তালিকা / টুপল এর পূর্বে লিস্ট / টুপলকে "সম্প্রসারিত" করা হয় যার ফলে প্রতিটি উপাদান নিজেই তালিকাগুলির / তালিকার চেয়ে ফাংশনটির জন্য একটি পৃথক যুক্তি হয়ে যায়। সুতরাং যদি, বলুন, আরগস = [1,2,3], তবে জিপ (আরোগুলি) জিপ ([1,2,3]) এর সমান, তবে জিপ (* আরগগুলি) জিপ (1, 2,3)।
3. জিপ হল এমন একটি ফাংশন যা এন আর্গুমেন্টগুলির প্রত্যেকটি দৈর্ঘ্য মিটার এবং দৈর্ঘ্য মিটার একটি তালিকা তৈরি করে, উপাদানগুলির দৈর্ঘ্য এন হয় এবং মূল তালিকার প্রতিটিটির সংশ্লিষ্ট উপাদান থাকে। উদাহরণস্বরূপ, জিপ ([1,2], [ক, খ], [এক্স, ওয়াই]) হ'ল [[১, ক, এক্স], [২, খ, y]]। আরও দেখুন পাইথন ডকুমেন্টেশন।

Comments

আপনি যেহেতু একমাত্র সম্ভবত প্রথম পদক্ষেপটি ব্যাখ্যা করছেন।

— পলপদীপ

Answer 4

শুধু একটি পর্যবেক্ষণ। ইনপুটটি তালিকার একটি তালিকা, তবে খুব সুন্দর সমাধান থেকে আউটপুট: ঘোরানো = জিপ (* আসল [:: - 1]) টিপলগুলির একটি তালিকা প্রদান করে।

এটি একটি সমস্যা হতে পারে বা নাও পারে।

এটি সহজেই সংশোধন করা হয়েছে:

original = [[1, 2, 3],
            [4, 5, 6],
            [7, 8, 9]
            ]


def rotated(array_2d):
    list_of_tuples = zip(*array_2d[::-1])
    return [list(elem) for elem in list_of_tuples]
    # return map(list, list_of_tuples)

print(list(rotated(original)))

# [[7, 4, 1], [8, 5, 2], [9, 6, 3]]

তালিকার কমপ বা মানচিত্র উভয়ই অভ্যন্তরের টিপলগুলিকে তালিকাগুলিতে রূপান্তরিত করবে।

Answer 5

def ruota_orario(matrix):
   ruota=list(zip(*reversed(matrix)))
   return[list(elemento) for elemento in ruota]
def ruota_antiorario(matrix):
   ruota=list(zip(*reversed(matrix)))
   return[list(elemento)[::-1] for elemento in ruota][::-1]

Comments

আপনার সমাধানটি ব্যাখ্যা করুন যাতে অন্যরা এটি আরও ভাল করে বুঝতে পারে।

— হ্যালোস্পেকম্যান

অবশ্যই, প্রথম ফাংশন (রুটা_অ্যান্টিওরিও) ঘড়ির কাঁটার বিপরীতে এবং দ্বিতীয় ফাংশন (রুটা_রিরিও) ঘড়ির কাঁটার দিকে

— ঘুরিয়ে দেয়

Answer 6

আমি নিজেই এই সমস্যাটি পেয়েছি এবং আমি এই বিষয়ে দুর্দান্ত উইকিপিডিয়া পৃষ্ঠাটি পেয়েছি ("সাধারণ ঘূর্ণন" অনুচ্ছেদে:
https://en.wikedia.org/wiki/Rotation_matrix#Ambiguities

তারপরে আমি কী চলছে তা সম্পর্কে একটি সুস্পষ্ট বোধগম্যতার জন্য নীচের কোডটি, সুপার ভারবোজ লিখেছিলাম।

আমি আশা করি যে আপনি পোস্ট করেছেন এমন খুব সুন্দর এবং চতুর ওয়ান-লাইনারে আরও খনন করা আপনার পক্ষে কার্যকর হবে।

এটির দ্রুত পরীক্ষার জন্য আপনি এখানে এটি অনুলিপি / পেস্ট করতে পারেন:
http://www.codeskulptor.org/

triangle = [[0,0],[5,0],[5,2]]
coordinates_a = triangle[0]
coordinates_b = triangle[1]
coordinates_c = triangle[2]

def rotate90ccw(coordinates):
    print "Start coordinates:"
    print coordinates
    old_x = coordinates[0]
    old_y = coordinates[1]
# Here we apply the matrix coming from Wikipedia
# for 90 ccw it looks like:
# 0,-1
# 1,0
# What does this mean?
#
# Basically this is how the calculation of the new_x and new_y is happening:
# new_x = (0)(old_x)+(-1)(old_y)
# new_y = (1)(old_x)+(0)(old_y)
#
# If you check the lonely numbers between parenthesis the Wikipedia matrix's numbers
# finally start making sense.
# All the rest is standard formula, the same behaviour will apply to other rotations, just
# remember to use the other rotation matrix values available on Wiki for 180ccw and 170ccw
    new_x = -old_y
    new_y = old_x
    print "End coordinates:"
    print [new_x, new_y]

def rotate180ccw(coordinates):
    print "Start coordinates:"
    print coordinates
    old_x = coordinates[0]
    old_y = coordinates[1] 
    new_x = -old_x
    new_y = -old_y
    print "End coordinates:"
    print [new_x, new_y]

def rotate270ccw(coordinates):
    print "Start coordinates:"
    print coordinates
    old_x = coordinates[0]
    old_y = coordinates[1]  
    new_x = -old_x
    new_y = -old_y
    print "End coordinates:"
    print [new_x, new_y]

print "Let's rotate point A 90 degrees ccw:"
rotate90ccw(coordinates_a)
print "Let's rotate point B 90 degrees ccw:"
rotate90ccw(coordinates_b)
print "Let's rotate point C 90 degrees ccw:"
rotate90ccw(coordinates_c)
print "=== === === === === === === === === "
print "Let's rotate point A 180 degrees ccw:"
rotate180ccw(coordinates_a)
print "Let's rotate point B 180 degrees ccw:"
rotate180ccw(coordinates_b)
print "Let's rotate point C 180 degrees ccw:"
rotate180ccw(coordinates_c)
print "=== === === === === === === === === "
print "Let's rotate point A 270 degrees ccw:"
rotate270ccw(coordinates_a)
print "Let's rotate point B 270 degrees ccw:"
rotate270ccw(coordinates_b)
print "Let's rotate point C 270 degrees ccw:"
rotate270ccw(coordinates_c)
print "=== === === === === === === === === "

Answer 7

কাউন্টার ক্লকওয়াইজ ঘোরানো (মান পিণ্ড থেকে সারি পিভোট) তালিকা এবং অধ্যক্ষ হিসাবে

rows = [
  ['A', 'B', 'C', 'D'],
  [1,2,3,4],
  [1,2,3],
  [1,2],
  [1],
]

pivot = []

for row in rows:
  for column, cell in enumerate(row):
    if len(pivot) == column: pivot.append([])
    pivot[column].append(cell)

print(rows)
print(pivot)
print(dict([(row[0], row[1:]) for row in pivot]))

উত্পাদন:

[['A', 'B', 'C', 'D'], [1, 2, 3, 4], [1, 2, 3], [1, 2], [1]]
[['A', 1, 1, 1, 1], ['B', 2, 2, 2], ['C', 3, 3], ['D', 4]]
{'A': [1, 1, 1, 1], 'B': [2, 2, 2], 'C': [3, 3], 'D': [4]}

Comments

এটি প্রশ্নের সাথে সম্পর্কিত নয়, যা কীভাবে zip(*original[::-1])কাজ করে তার ব্যাখ্যা জিজ্ঞাসা করে।

— কেয়া