طراحی سایت و برنامه نویسی

آموزش طراحی سایت و برنامه نویسی

طراحی سایت و برنامه نویسی

آموزش طراحی سایت و برنامه نویسی

آشنایی با آپاچی اسپارک (Spark) و پایتون — راهنمای مقدماتی

آپاچی اسپارک یک فریمورک متن-باز است که از زمان معرفی‌اش در AMPLab در دانشگاه برکلی در سال 2009 موج بزرگی راه انداخته است، چون هسته مرکزی آن یک موتور پردازش توزیع‌یافته کلان‌داده است که می‌تواند به خوبی مقیاس‌بندی شود.

مقدمه‌ای بر آپاچی اسپارک

به بیان ساده با رشد داده‌ها، امر مدیریت داده‌های استریمینگ بزرگ و توانایی پردازش و اجرای عملیات دیگر مانند یادگیری ماشین، ضرورت یافته و آپاچی اسپارک نیز این کار را به خوبی انجام می‌دهد. برخی کارشناسان می‌گویند که آپاچی اسپارک در آینده‌ای نزدیک به یک پلتفرم آماده برای محاسبات استریم تبدل می‌شود.

اغلب افراد دچار این سوءتفاهم هستند که اسپارک جایگزینی برای هادوپ (Hadoop) است، اما باید بدانند که اسپارک تنها یک رقیب برای فریمورک map-reduce هادوپ محسوب می‌شود. بدین ترتیب با توجه به سریع‌تر بودن اسپارک یکی از کوتاه‌ترین مسیرهای یادگیری را برای توسعه‌دهندگان دارد و با در نظر گرفتن این نکته که از سوی شرکت‌های بزرگی در بازار استفاده می‌شود، یک مهارت ساده و مؤثر جهت ارتقا در رزومه هر توسعه‌دهنده‌ای به حساب می‌آید.

چنان که در ادامه خواهیم دید، پردازش توزیع‌یافته یکی از قابلیت‌های کلیدی اسپارک است، اما تنها قابلیت آن نیست.

آپاچی اسپارک

از آنجا که اسپارک بسیار محبوب است، می‌توان انتظار داشت که ارائه‌دهندگان مختلفی به عرضه سرویس‌های اسپارک به روش‌های مختلف بپردازند. برخی اوقات گزینه‌هایی که وجود دارند بسیار گسترده و سردرگم‌کننده هستند، بنابراین هیجان و شوق برای یادگیری یک چیز جدید در تلاش برای یافتن گزینه‌ای صحیح از دست می‌رود.

نکته قابل توجه

در این مقاله، ما به برسی مشخصه‌های اسپارک و شیوه استفاده از آن برای استریم کردن داده‌ها نمی‌پردازیم. به جای آن به ارائه فهرستی از گزینه‌های ممکن برای آغاز به کار با اسپارک می‌پردازیم. سپس انتخاب را بر عهده شما می‌گذاریم تا ماجراجویی خود را آغاز کنید.

پیشنهاد می‌کنیم پیش از تلاش برای امتحان کردن گزینه‌های معرفی شده، این مقاله را به طور کامل تا انتها بخوانید. ایده کار این است که گزینه‌های موجود را درک کنید و سپس گزینه‌ای را که به بهترین وجه نیازهای شما را برآورده می‌سازد انتخاب کنید و به کار با آن بپردازید.

1. نصب لوکال

نخستین گزینه‌ای که وجود دارد تنظیم لوکال اسپارک است. اگر طرفدار سرویس‌های آنلاین نیستید، می‌توانید از این گزینه استفاده کنید. در محیط لوکال شما کنترل کاملی روی همه چیز دارید، اما به خاطر داشته باشید که این مسیر زمان‌بر است.

اگر زمان برایتان مهم است و حوصله سر و کله زدن با نصب موارد مختلف را ندارید، بهتر است از دردسر دوری کنید و به گزینه‌های 2 و 3 این مقاله مراجعه نمایید.

آن چه برای نصب لوکال نیاز دارید یک نرم‌افزار Virtual Box، سیستم اوبونتو و زمان و صبر به مقدار کافی است.

Virtual Box (+) اپلیکیشنی است که امکان اجرای یک رایانه مجازی روی سیستم را به شما می‌دهد. این جایی است که ما اوبونتو، یک سیستم عامل مبتنی بر لینوکس و اسپارک را نصب خواهیم کرد. اگر هم اینک از سیستم اوبونتو استفاده می‌کنید می‌توانید این مرحله را رد کنید.
نرم‌افزار Virtual Box را از این لینک (+) دانلود کنید و میزبان را بسته به سیستم عامل خود ویندوز یا OS X انتخاب نمایید. زمانی که دانلود پایان یافت، روی فایل دابل کلیک کنید و با پیگیری دستورالعمل‌ها و تنظیمات پیش‌فرض آن را نصب کنید.

در ادامه به این لینک (+) بروید و اوبونتو را دانلود کنید. البته اوبونتو دسکتاپ ترجیح بیشتری دارد. پس از این مرحله، باید یک فایل دانلود شده iso. در اختیار داشته باشید.

بدین ترتیب می‌توانید به اپلیکیشن Virtual box بروید. این نرم‌افزار در ابتدا اساساً خالی است. می‌توانید با کلیک کردن روی دکمه New یک ماشین مجازی جدید به آن اضافه کنید. برای این ماشین یک نام تعیین کرده، گزینه Linux را انتخاب کنید و در ادامه Next را بزنید.

آپاچی اسپارک

پس از این مرحله، وارد یک سری از گزینه‌ها می‌شوید که می‌توانید برای ماشین تنظیم کنید. قبل از هر چیز اندازه حافظه قرار دارد که می‌توانید آن را روی مقدار پیش‌فرض رها کنید، اما بسته به مشخصات سیستم می‌توانید مقدار معقولی RAM به ماشین مجازی خود اختصاص دهید.

در وهله دوم نوبت به هارد دیسک می‌رسد. این گزینه را نیز می‌توانید روی مقدار پیشنهادشده 8 گیگابایت رها کنید و گزینه ایجاد یک ماشین مجازی جدید را کلیک کنید و VDI (یعنی ایمیج دیسک ویرچوال باکس) را در پنجره نوع فایل هارد دیسک انتخاب نمایید و next را بزنید.

در وهله سوم نوبت به فضای ذخیره‌سازی می‌رسد. شما می‌توانید اندازه با تخصیص دینامیک یا ثابت را انتخاب کنید. اندازه ثابت پیشنهاد می‌شود، چون سرعت ورودی/ خروجی بهتری دارد. 20 گیگابایت می‌تواند مقدار مناسبی باشد. در ادامه روی Create کلیک کنید.

آپاچی اسپارک

زمانی که روی Create کلیک کردید، ایجاد ماشین کمی طول می‌کشد. زمانی که ماشین مجازی آماده شد، می‌توانید به صفحه اصلی ویرچوال باکس بازگردید، چنان که می‌بینید ماشین جدیدی که تنظیم کردیم اینک ایجاد شده است.

آپاچی اسپارک

به صورت پیش‌فرض این ماشین خاموش است، اما می‌توانید آن را با دو بار کلیک کردن روشن کنید. در طی نخستین زمان روشن شدن از شما خواسته می‌شود که دیسک آغازین را انتخاب کید. این امر مهمی است و جایی است که به ایمیج Ubuntu.iso که قبلاً دانلود کرده‌اید اشاره می‌کنید. فایل Ubuntu.iso را انتخاب کرده و روی start کلیک کنید. بدین ترتیب اوبونتو روی ماشین مجازی نصب می‌شود. در این مسیر گزینه‌های نصب زیادی در اختیار شما قرار می‌گیرند و می‌توانید آن را سفارشی‌سازی کرده و یا مقادیر پیش‌فرض را حفظ کنید. در هر صورت مشکلی وجود ندارد و در انتها یک سیستم عامل آماده به کار در اختیار شما قرار می‌گیرد که البته از نوع مجازی است.

نخستین کاری که باید درون ماشین مجازی انجام دهید این است که مطمئن شود پایتون از قبل نصب شده است. به این منظور به اپلیکیشن ترمینال اوبونتو بروید و عبارت python3 را وارد کرده و اینتر کنید. بدین ترتیب یک خروجی مانند تصویر زیر باید مشاهده کنید:

آپاچی اسپارک

نسخه پایتون ممکن است متفاوت باشد، اما تا زمانی که بالاتر از 3 باشد مشکلی وجود ندارد.

سپس قصد داریم یک سری نرم‌افزارها را نصب کنیم که برای اجرای اسپارک روی ماشین مجازی ضروری هستند.

Jupyter Notebook

نصب ژوپیتر نت‌بوک یکی از ساده‌ترین روش‌ها برای تعامل با پایتون و نوشتن کد خوب محسوب می‌شود. به این منظور روی همان ترمینال یا یک پنجره جدید، دستور زیر را وارد کنید:

pip3 install jupyter

این دستور باید سیستم ژوپیتر نت‌بوک را نصب کند. زمانی که کار پایان یافت، می‌توانید با وارد کردن دستور زیر در ترمینال آن را تست کنید:

jupyter notebook

بدین ترتیب اینترفیس ژوپیتر نت‌بوک در یک مرورگر باز می‌شود. این امر نشان می‌دهد که نصب نت‌بوک کامل بوده است.

جاوا

اکنون نوبت به نصب جاوا رسیده است که برای اجرای اسپارک ضروری است. در یک پنجره ترمینال دیگر این دستورها را یکی پس از دیگری وارد کنید:

sudo apt-get update
sudo apt-get install default-jre

نخستین دستور مکانیسم apt-get ما را به‌روزرسانی خواهد کرد و پس از آن جاوا با استفاده از دستور دوم نصب می‌شود.

اسکالا

به طور مشابه اسکالا را نیز نصب می‌کنیم.

sudo apt-get install scala

برای تست کردن این نکته که آیا نصب موفق بوده است یا نه می‌توانید دستور زیر را وارد کنید که به نسخه اسکالای نصب شده اشاره می‌کند:

scala –version

نصب Py4j

اکنون نوبت به نصب یک کتابخانه پایتون رسیده است که جاوا و اسکالا را به پایتون وصل می‌کند:

pip3 install py4j

اسپارک و هادوپ

اکنون که به انتها رسیده‌ایم باید اسپارک و هادوپ را نصب کنیم. به این منظور به این لینک (+) بروید و نسخه اسپارک را مستقیماً دانلود کنید. مطمئن شوید که این گام را روی ماشین مجازی انجام می‌دهید تا مستقیماً روی آن دانلود شود.

یک ترمینال جدید باز کنید و مطمئن شوید که در همان مکانی قرار دارید که فایل‌ها دانلود شده بودند. می‌توانید به پوشه صحیح cd کرده و دستور زیر را اجرا کنید (توجه داشته باشید که نام فایل بسته به نسخه اسپارک مورد استفاده می‌تواند متفاوت باشد):

sudo tar -zxvf spark-2.1.0-bin-hadoop2.7.tgz

دستور فوق اساساً پکیج را از حالت فشرده خارج می‌کند و پوشه‌های مورد نیاز را می‌سازد. سپس باید به پایتون اعلام کنیم که کجا می‌تواند اسپارک را پیدا کند. دستورهای زیر را در ترمینال وارد کرده و پس از هر خط اینتر را بزنید. به مسیر SPARK_HOME دقت کنید، چون باید مکانی باشد که پوشه unzip شده در آن قرار دارد.

export SPARK_HOME=’home/ubuntu/spark-2.1.0-bin-hadoop2.7'
export PATH=@SPARK_HOME:$PATH
export PYTHONPATH=$SPARK_HOME/python:$PYTHONPATH
export PYSPARK_DRIVER_PYTHON=”jupyter”
export PYSPARK_DRIVER_PYTHON_OPTS=”notebook”
export PYSPARK_PYTHON=python3

اگر در تمام طول این مسیر با ما همراه بوده و دستورها را اجرا کرده باشید، اینک همه چیز آماده شده است. یک پنجره ترمینال باز کنید و به مسیر زیر cd کنید:

cd /spark-2.1.0-bin-hadoop2.7/python

زمانی که در دایرکتوری صحیح قرار گرفتید، ژوپیتر نت‌بوک را باز کنید:

jupyter notebook

اکنون باید مرورگر خود را ببینید که با سیستم ژوپیتر نت‌بوک باز شده است. یک نت‌بوک جدید پایتون ایجاد کنید و در یک سلول خالی دستور زیر را وارد کرده و Ctrl+Enter بزنید.

import pyspark

اسپارک

اینک ماشین مجازی ما به همراه اسپارک نصب شده آماده است و می‌توانیم کار خود را آغاز کنیم.

2. Databricks

Databricks پلتفرمی است که از سوی خالقان اصلی آپاچی اسپارک ساخته شده و روشی عالی برای بهره‌برداری از قدرت اسپارک در یک مرورگر محسوب می‌شود. Databricks زحمت نصب دشوار و استفاده از توان محاسباتی اسپارک در مرورگر را از دوش ما بر می‌دارد. اگر می‌خواهید به سرعت با اسپارک آشنا شود این بهترین راهی است که می‌توانید امتحان کنید. اگر نصب لوکال یک غذای خانگی باشد، Databricks را می‌توان یک بشقاب غذای لذیذ آماده تصور کرد. اینک تنها چیزی که نیاز دارید یک مرورگر و یک اتصال اینترنتی خوب است.

با این که Databricks به منظور استفاده از سوی شرکت‌هایی که به سمت کلان‌داده و محاسبات توزیع یافته حرکت می‌کنند طراحی شده است، اما یک نسخه کامیونیتی نیز دارد که برای منظور ما مناسب است.

برای شروع کار به این لینک (+) بروید و در نسخه کامیونیتی ثبت نام کنید. شما باید آدرس ایمیل خود را اعتبارسنجی کنید تا بتوانید برای نخستین بار وارد شوید. زمانی که این کار را انجام دادید امکان کار با محیط نت‌بوک پایتون که از قبل نصب شده را خواهید یافت.

Spark

هنگامی که لاگین کردید، روی Create a Blank Notebook کلیک کنید تا کار را آغاز کنید. در این هنگام یک ژوپیتر نت‌بوک عرضه می‌شود که می‌توان کد پایتون را در هر سلول آن وارد کرده و به صورت مستقل اجرا کرد.

Databricks برای اسپارک ساخته شده است و نیازی به نگرانی در مورد نصب موارد اضافی وجود ندارد. شما می‌توانید بی‌درنگ عبارت spark را در سلول نخست وارد کنید و با زدن کلیدهای Ctrl+Enter یا دکمه پخش کوچک در سمت راست سلول آن را اجرا کنید:

Spark

در نخستین دفعه اجرا از شما خواسته می‌شود که یک کلاستر را لانچ و اجرا کنید. این کار را انجام دهید و پس از آن می‌بینید که چیزی مانند تصویر فوق ظاهر می‌شود. اینک می‌توانید سلول‌های اضافی ایجاد کرده و به ارزیابی اسپارک ادامه دهید. شما اینک می‌توانید به بررسی مجموعه داده‌ها پرداخته و عملیات مختلف یادگیری ماشین را اجرا کنید.

نکته: ابزار Databricks به دلایل مختلف جالب است و مهم‌تر از همه این که مخزن داده عظیمی ارائه می‌کند که با استفاده از آن می‌توانید همه قدرتش را مورد آزمایش قرار دهید.

برای بررسی اجمالی آن چه که Databricks ارائه می‌کند، باید با استفاده از دستور magic به «file system» مربوط به Databricks بروید. در یک سلول جدید عبارت fs% را وارد کنید و سپس ls را وارد کرده و سلول را اجرا کنید. بدین ترتیب مسیرهای dbfs را به صورت فهرست‌بندی شده مشاهده می‌کنید:

Spark

سپس روی ls /databricks-datasets/ کلیک کنید تا همه مجموعه داده‌های موجود را ببینید. اگر به هر کدام از آن‌ها علاقه‌مند هستید می‌توانید به سادگی از آن‌ها در کد خود استفاده کنید. برای نمونه ما داده‌های ساده people/people.json/ را دوست داریم و می‌خواهیم از آن در کد خود استفاده کنیم. این کار به صورت زیر میسر است:

data = spark.read.json(“/databricks-datasets/samples/people/people/.json”)

به بررسی این پلتفرم بپردازید و مجموعه‌های داده مختلف را امتحان کنید، مسلماً ناامید نخواهید شد. شاید این ساده‌ترین روش استفاده از اسپارک باشد.

3. Google Colab

Google Colaboratory (+) یک محیط رایگان ژوپیتر نت‌بوک است که شباهت زیادی به Databricks دارد و به طور کامل روی کلود اجرا می‌شود، اما همه شهرت آن از این ناشی نمی‌شود که یک سیستم رایگان نت‌بوک است، بلکه بخش عمده آن ناشی از ارائه GPU رایگان است. بله درست شنیده‌اید، Colab امکان استفاده رایگان از GPU را فراهم می‌سازد. این یک پیشنهاد عالی برای افرادی است که می‌خواهند یادگیری ماشین را بیاموزند. البته این موضوع مجزایی است و با موضوع مقاله ما که معرفی اسپارک است ارتباط مستقیمی ندارد.

برای استفاده از Google Colab به یک مرورگر وب، یک اتصال اینترنتی خوب و یک حساب گوگل نیاز دارید. به این لینک (+) بروید و از طریق حساب گوگل وارد شوید تا صفحه‌ای برای ایجاد «New Python 3 Notebook» مشاهده کنید. در ادامه یک نت‌بوک بسازید.

این مرحله ما را وارد سرزمین آشنایی می‌کند که یک نت‌بوک پایتون یا یک سلول خالی است. Google Colab برخلاف Databricks آماده استفاده با اسپارک است و از این رو نیازی به همان تنظیمات اندک آغازین هم نداریم. اگر pyspark را در سلول خالی اجرا کنید با خطایی به صورت زیر مواجه خواهید شد.

اسپارک

در ادامه این خطا را اصلاح می‌کنیم. Google Colab هم شبیه به یک ماشین مجازی و هم یک نت‌بوک عمل می‌کند. دستور زیر را در یک سلول خالی وارد کرده و با زدن Ctrl+Enter جاوا را نصب می‌کنیم:

!apt install openjdk-8-jdk-headless -qq > /dev/null

با استفاده از علامت (!) در ابتدای دستور آن را در یک پوسته (Shell) اجرا می‌کنیم و نشان می‌دهیم که یک کد پایتون نیست. اینک اسپارک و هادوپ را دانلود می‌کنیم.

!wget -q http://www-eu.apache.org/dist/spark/spark-2.3.3/spark-2.3.3-bin-hadoop2.7.tgz

زمانی که دانلود پایان یافت، می‌توانید با اجرای ls -l! همانند یک پوسته لینوکسی در عمل ببینید که آیا فایل دانلود شده یا نه.

اسپارک

چنان که می‌بینید فایل با فرمت یک فایل zip دانلود شده، پس باید آن را از حالت فشرده خارج کنیم:

!tar xf spark-2.3.3-bin-hadoop2.7.tgz

اکنون قبل از شروع به کار با اسپارک باید چند کار دیگر نیز انجام دهیم که تنظیم متغیرهای جاوا و اسپارک به صورت زیر است:

import os
os.environ[“JAVA_HOME”] = “/usr/lib/jvm/java-8-openjdk-amd64”
os.environ[“SPARK_HOME”] = “/content/spark-2.3.3-bin-hadoop2.7”

این همه کاری است که برای راه‌اندازی نیاز داریم. اکنون به بررسی کد نمونه زیر می‌پردازیم:

اسپارک

کد فوق با ایجاد یک SparkSession جدید اقدام به مقداردهی اسپارک می‌کند و سپس یک فریم داده جدید اسپارک به صورت on fly با استفاده از list comprehension پایتون می‌سازد و در نهایت فریم داده نمایش می‌یابد. آن را در یک سلول جدید امتحان کنید.

سخن پایانی

بدین ترتیب به پایان این مقاله رسیده‌ایم و امیدواریم راهنمای اطلاعات تنظیم اسپارک مورد توجه شما قرار گرفته باشد. ما نهایت تلاش خود را کرده‌ایم که کل فرایند برای خواننده روشن باشد و از این رو امیدواریم بتوانید بدون نگرانی در مورد حجم بالای اطلاعات، اسپارک را نصب و راه‌اندازی کنید و صرفاً روی شروع کار متمرکز شوید.

منبع: فرادرس

مشاوره شنبه 29 تیر 1398 ساعت 14:11

0 نظر

یافتن دور همیلتونی با الگوریتم پس گرد — به زبان ساده

«مسیر همیلتونی» (Hamiltonian Path) در یک گراف غیر جهت‌دار، مسیری است که در آن هر «راس» (Vertex) دقیقا یک‌بار مشاهده می‌شود. یک «دور همیلتونی» یا «مدار همیلتونی» (Hamiltonian Cycle | Hamiltonian Circuit)، یک مسیر همیلتونی است که در آن از آخرین راس به اولین راس یک «یال» (Edge) وجود دارد. در ادامه، روشی جهت بررسی اینکه آیا در یک گراف داده شده، دور همیلتونی وجود دارد یا خیر بررسی می‌شود. همچنین، در صورت وجود دور، مسیر آن را چاپ می‌کند. در واقع، با استفاده از یک روش ساده و یک روش «پس‌گرد» (Backtracking)، بررسی می‌شود که آیا در یک گراف دور همیلتونی وجود دارد یا خیر و در صورت وجود، مسیر در خروجی چاپ می‌شود. ورودی و خروجی تابع لازم برای این کار به صورت زیر هستند.

یافتن دور همیلتونی در گراف

برای یافتن دور همیلتونی در گراف، به طور کلی به صورت زیر عمل می‌شود.

ورودی:

یک آرایه دوبُعدی [graph[V][V که در آن V تعداد راس‌ها در گراف و [graph[V][V «ماتریس همسایگی» (Adjacency Matrix) گراف است. مقدار [graph[i][j در صورت وجود یک یال مستقیم از راس i به راس j برابر با یک و در غیر این صورت، [graph[i][j برابر با صفر است.

خروجی:

یک آرایه [path[V باید حاوی یک مسیر همیلتونی باشد. [path[i باید راس i در مسیر همیلتونی را نمایش دهد. همچنین، کد باید مقدار false را در صورت عدم وجود دور همیلتونی در گراف، بازگرداند.

برای مثال، دور همیلتونی در گراف زیر به صورت {۰ ،۳ ،۴ ،۲ ،۱ ، ۰} است.

(0)--(1)--(2)
|    / \   |
|    / \   | 
|    / \   |
(3)-------(4)

گراف زیر حاوی هیچ دور همیلتونی نیست.

(0)--(1)--(2)
|    / \   |
|    / \   | 
|    / \   |
(3)       (4)

الگوریتم ساده (Naive Algorithm)

الگوریتم ساده‌ای که در زیر ارائه شده، همه پیکربندی‌های ممکن برای راس‌ها را ارائه می‌کند و پیکربندی که محدودیت های داده شده را ارضا می‌کند، باز می‌گرداند. به تعداد !n، پیکربندی ممکن وجود دارد.

1
2
3
4
5
6
7
8
9
10
11
while there are untried conflagrations
{
   generate the next configuration
   if ( there are edges between two consecutive vertices of this
      configuration and there is an edge from the last vertex to 
      the first ).
   {
      print this configuration;
      break;
   }
}

یافتن دور همیلتونی با الگوریتم پس‌گرد (Backtracking Algorithm)

این الگوریتم یک آرایه مسیر خالی می‌سازد و راس ۰ را به آن اضافه می‌کند. در ادامه، دیگر راس‌ها را با آغاز از راس ۱ به آرایه اضافه می‌کند؛ اما پیش از اضافه کردن یک راس، بررسی می‌کند که آیا با راس پیشین اضافه شده مجاور است یا خیر و همچنین، بررسی می‌کند که راس، پیش از این به آرایه اضافه نشده باشد. اگر چنین راسی پیدا شود، یال به عنوان بخشی از راهکار اضافه می‌شود. اگر راس پیدا نشود، مقدار false بازگردانده می‌شود.

پیاده‌سازی الگوریتم پس‌گرد برای مساله یافتن دور همیلتونی در گراف

در ادامه، پیاده‌سازی الگوریتم پس‌گرد برای مساله یافتن دور همیلتونی در گراف در زبان‌های برنامه‌نویسی گوناگون ارائه شده است.

++C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* C++ program for solution of Hamiltonian  
Cycle problem using backtracking */
#include <bits/stdc++.h> 
using namespace std; 
  
// Number of vertices in the graph  
#define V 5  
  
void printSolution(int path[]);  
  
/* A utility function to check if  
the vertex v can be added at index 'pos'  
in the Hamiltonian Cycle constructed  
so far (stored in 'path[]') */
bool isSafe(int v, bool graph[V][V],  
            int path[], int pos)  
{  
    /* Check if this vertex is an adjacent  
    vertex of the previously added vertex. */
    if (graph [path[pos - 1]][ v ] == 0)  
        return false;  
  
    /* Check if the vertex has already been included.  
    This step can be optimized by creating 
    an array of size V */
    for (int i = 0; i < pos; i++)  
        if (path[i] == v)  
            return false;  
  
    return true;  
}  
  
/* A recursive utility function  
to solve hamiltonian cycle problem */
bool hamCycleUtil(bool graph[V][V],  
                  int path[], int pos)  
{  
    /* base case: If all vertices are  
    included in Hamiltonian Cycle */
    if (pos == V)  
    {  
        // And if there is an edge from the  
        // last included vertex to the first vertex  
        if (graph[path[pos - 1]][path[0]] == 1)  
            return true;  
        else
            return false;  
    }  
  
    // Try different vertices as a next candidate  
    // in Hamiltonian Cycle. We don't try for 0 as  
    // we included 0 as starting point in in hamCycle()  
    for (int v = 1; v < V; v++)  
    {  
        /* Check if this vertex can be added  
        // to Hamiltonian Cycle */
        if (isSafe(v, graph, path, pos))  
        {  
            path[pos] = v;  
  
            /* recur to construct rest of the path */
            if (hamCycleUtil (graph, path, pos + 1) == true)  
                return true;  
  
            /* If adding vertex v doesn't lead to a solution,  
            then remove it */
            path[pos] = -1;  
        }  
    }  
  
    /* If no vertex can be added to  
    Hamiltonian Cycle constructed so far,  
    then return false */
    return false;  
}  
  
/* This function solves the Hamiltonian Cycle problem  
using Backtracking. It mainly uses hamCycleUtil() to  
solve the problem. It returns false if there is no  
Hamiltonian Cycle possible, otherwise return true  
and prints the path. Please note that there may be  
more than one solutions, this function prints one  
of the feasible solutions. */
bool hamCycle(bool graph[V][V])  
{  
    int *path = new int[V];  
    for (int i = 0; i < V; i++)  
        path[i] = -1;  
  
    /* Let us put vertex 0 as the first vertex in the path. 
    If there is a Hamiltonian Cycle, then the path can be  
    started from any point of the cycle as the graph is undirected */
    path[0] = 0;  
    if (hamCycleUtil(graph, path, 1) == false )  
    {  
        cout << "\nSolution does not exist";  
        return false;  
    }  
  
    printSolution(path);  
    return true;  
}  
  
/* A utility function to print solution */
void printSolution(int path[])  
{  
    cout << "Solution Exists:"
            " Following is one Hamiltonian Cycle \n";  
    for (int i = 0; i < V; i++)  
        cout << path[i] << " ";  
  
    // Let us print the first vertex again 
    // to show the complete cycle  
    cout << path[0] << " ";  
    cout << endl; 
}  
  
// Driver Code  
int main()  
{  
    /* Let us create the following graph  
        (0)--(1)--(2)  
        | / \ |  
        | / \ |  
        | / \ |  
        (3)-------(4) */
    bool graph1[V][V] = {{0, 1, 0, 1, 0},  
                        {1, 0, 1, 1, 1},  
                        {0, 1, 0, 0, 1},  
                        {1, 1, 0, 0, 1},  
                        {0, 1, 1, 1, 0}};  
      
    // Print the solution  
    hamCycle(graph1);  
      
    /* Let us create the following graph  
    (0)--(1)--(2)  
    | / \ |  
    | / \ |  
    | / \ |  
    (3) (4) */
    bool graph2[V][V] = {{0, 1, 0, 1, 0},  
                         {1, 0, 1, 1, 1},  
                         {0, 1, 0, 0, 1},  
                         {1, 1, 0, 0, 0},  
                         {0, 1, 1, 0, 0}};  
  
    // Print the solution  
    hamCycle(graph2);  
  
    return 0;  
}  
  
// This is code is contributed by rathbhupendra 

C

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/* C program for solution of Hamiltonian Cycle problem 
   using backtracking */
#include<stdio.h> 
  
// Number of vertices in the graph 
#define V 5 
  
void printSolution(int path[]); 
  
/* A utility function to check if the vertex v can be added at 
   index 'pos' in the Hamiltonian Cycle constructed so far (stored 
   in 'path[]') */
bool isSafe(int v, bool graph[V][V], int path[], int pos) 
{ 
    /* Check if this vertex is an adjacent vertex of the previously 
       added vertex. */
    if (graph [ path[pos-1] ][ v ] == 0) 
        return false; 
  
    /* Check if the vertex has already been included. 
      This step can be optimized by creating an array of size V */
    for (int i = 0; i < pos; i++) 
        if (path[i] == v) 
            return false; 
  
    return true; 
} 
  
/* A recursive utility function to solve hamiltonian cycle problem */
bool hamCycleUtil(bool graph[V][V], int path[], int pos) 
{ 
    /* base case: If all vertices are included in Hamiltonian Cycle */
    if (pos == V) 
    { 
        // And if there is an edge from the last included vertex to the 
        // first vertex 
        if ( graph[ path[pos-1] ][ path[0] ] == 1 ) 
           return true; 
        else
          return false; 
    } 
  
    // Try different vertices as a next candidate in Hamiltonian Cycle. 
    // We don't try for 0 as we included 0 as starting point in in hamCycle() 
    for (int v = 1; v < V; v++) 
    { 
        /* Check if this vertex can be added to Hamiltonian Cycle */
        if (isSafe(v, graph, path, pos)) 
        { 
            path[pos] = v; 
  
            /* recur to construct rest of the path */
            if (hamCycleUtil (graph, path, pos+1) == true) 
                return true; 
  
            /* If adding vertex v doesn't lead to a solution, 
               then remove it */
            path[pos] = -1; 
        } 
    } 
  
    /* If no vertex can be added to Hamiltonian Cycle constructed so far, 
       then return false */
    return false; 
} 
  
/* This function solves the Hamiltonian Cycle problem using Backtracking. 
  It mainly uses hamCycleUtil() to solve the problem. It returns false 
  if there is no Hamiltonian Cycle possible, otherwise return true and 
  prints the path. Please note that there may be more than one solutions, 
  this function prints one of the feasible solutions. */
bool hamCycle(bool graph[V][V]) 
{ 
    int *path = new int[V]; 
    for (int i = 0; i < V; i++) 
        path[i] = -1; 
  
    /* Let us put vertex 0 as the first vertex in the path. If there is 
       a Hamiltonian Cycle, then the path can be started from any point 
       of the cycle as the graph is undirected */
    path[0] = 0; 
    if ( hamCycleUtil(graph, path, 1) == false ) 
    { 
        printf("\nSolution does not exist"); 
        return false; 
    } 
  
    printSolution(path); 
    return true; 
} 
  
/* A utility function to print solution */
void printSolution(int path[]) 
{ 
    printf ("Solution Exists:"
            " Following is one Hamiltonian Cycle \n"); 
    for (int i = 0; i < V; i++) 
        printf(" %d ", path[i]); 
  
    // Let us print the first vertex again to show the complete cycle 
    printf(" %d ", path[0]); 
    printf("\n"); 
} 
  
// driver program to test above function 
int main() 
{ 
   /* Let us create the following graph 
      (0)--(1)--(2) 
       |   / \   | 
       |  /   \  | 
       | /     \ | 
      (3)-------(4)    */
   bool graph1[V][V] = {{0, 1, 0, 1, 0}, 
                      {1, 0, 1, 1, 1}, 
                      {0, 1, 0, 0, 1}, 
                      {1, 1, 0, 0, 1}, 
                      {0, 1, 1, 1, 0}, 
                     }; 
  
    // Print the solution 
    hamCycle(graph1); 
  
   /* Let us create the following graph 
      (0)--(1)--(2) 
       |   / \   | 
       |  /   \  | 
       | /     \ | 
      (3)       (4)    */
    bool graph2[V][V] = {{0, 1, 0, 1, 0}, 
                      {1, 0, 1, 1, 1}, 
                      {0, 1, 0, 0, 1}, 
                      {1, 1, 0, 0, 0}, 
                      {0, 1, 1, 0, 0}, 
                     }; 
  
    // Print the solution 
    hamCycle(graph2); 
  
    return 0; 
}

پایتون

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
# Python program for solution of 
# hamiltonian cycle problem 
  
class Graph(): 
    def __init__(self, vertices): 
        self.graph = [[0 for column in range(vertices)]\ 
                            for row in range(vertices)] 
        self.V = vertices 
  
    ''' Check if this vertex is an adjacent vertex  
        of the previously added vertex and is not  
        included in the path earlier '''
    def isSafe(self, v, pos, path): 
        # Check if current vertex and last vertex  
        # in path are adjacent 
        if self.graph[ path[pos-1] ][v] == 0: 
            return False
  
        # Check if current vertex not already in path 
        for vertex in path: 
            if vertex == v: 
                return False
  
        return True
  
    # A recursive utility function to solve  
    # hamiltonian cycle problem 
    def hamCycleUtil(self, path, pos): 
  
        # base case: if all vertices are  
        # included in the path 
        if pos == self.V: 
            # Last vertex must be adjacent to the  
            # first vertex in path to make a cyle 
            if self.graph[ path[pos-1] ][ path[0] ] == 1: 
                return True
            else: 
                return False
  
        # Try different vertices as a next candidate  
        # in Hamiltonian Cycle. We don't try for 0 as  
        # we included 0 as starting point in in hamCycle() 
        for v in range(1,self.V): 
  
            if self.isSafe(v, pos, path) == True: 
  
                path[pos] = v 
  
                if self.hamCycleUtil(path, pos+1) == True: 
                    return True
  
                # Remove current vertex if it doesn't  
                # lead to a solution 
                path[pos] = -1
  
        return False
  
    def hamCycle(self): 
        path = [-1] * self.V 
  
        ''' Let us put vertex 0 as the first vertex  
            in the path. If there is a Hamiltonian Cycle,  
            then the path can be started from any point 
            of the cycle as the graph is undirected '''
        path[0] = 0
  
        if self.hamCycleUtil(path,1) == False: 
            print "Solution does not exist\n"
            return False
  
        self.printSolution(path) 
        return True
  
    def printSolution(self, path): 
        print "Solution Exists: Following is one Hamiltonian Cycle"
        for vertex in path: 
            print vertex, 
        print path[0], "\n"
  
# Driver Code 
  
''' Let us create the following graph 
      (0)--(1)--(2) 
       |   / \   | 
       |  /   \  | 
       | /     \ | 
      (3)-------(4)    '''
g1 = Graph(5) 
g1.graph = [ [0, 1, 0, 1, 0], [1, 0, 1, 1, 1],  
             [0, 1, 0, 0, 1,],[1, 1, 0, 0, 1],  
             [0, 1, 1, 1, 0], ] 
  
# Print the solution 
g1.hamCycle(); 
  
''' Let us create the following graph 
      (0)--(1)--(2) 
       |   / \   | 
       |  /   \  | 
       | /     \ | 
      (3)       (4)    '''
g2 = Graph(5) 
g2.graph = [ [0, 1, 0, 1, 0], [1, 0, 1, 1, 1],  
           [0, 1, 0, 0, 1,], [1, 1, 0, 0, 0],  
           [0, 1, 1, 0, 0], ] 
  
# Print the solution 
g2.hamCycle(); 
  
# This code is contributed by Divyanshu Mehta 

جاوا

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/* Java program for solution of Hamiltonian Cycle problem 
   using backtracking */
class HamiltonianCycle 
{ 
    final int V = 5; 
    int path[]; 
  
    /* A utility function to check if the vertex v can be 
       added at index 'pos'in the Hamiltonian Cycle 
       constructed so far (stored in 'path[]') */
    boolean isSafe(int v, int graph[][], int path[], int pos) 
    { 
        /* Check if this vertex is an adjacent vertex of 
           the previously added vertex. */
        if (graph[path[pos - 1]][v] == 0) 
            return false; 
  
        /* Check if the vertex has already been included. 
           This step can be optimized by creating an array 
           of size V */
        for (int i = 0; i < pos; i++) 
            if (path[i] == v) 
                return false; 
  
        return true; 
    } 
  
    /* A recursive utility function to solve hamiltonian 
       cycle problem */
    boolean hamCycleUtil(int graph[][], int path[], int pos) 
    { 
        /* base case: If all vertices are included in 
           Hamiltonian Cycle */
        if (pos == V) 
        { 
            // And if there is an edge from the last included 
            // vertex to the first vertex 
            if (graph[path[pos - 1]][path[0]] == 1) 
                return true; 
            else
                return false; 
        } 
  
        // Try different vertices as a next candidate in 
        // Hamiltonian Cycle. We don't try for 0 as we 
        // included 0 as starting point in in hamCycle() 
        for (int v = 1; v < V; v++) 
        { 
            /* Check if this vertex can be added to Hamiltonian 
               Cycle */
            if (isSafe(v, graph, path, pos)) 
            { 
                path[pos] = v; 
  
                /* recur to construct rest of the path */
                if (hamCycleUtil(graph, path, pos + 1) == true) 
                    return true; 
  
                /* If adding vertex v doesn't lead to a solution, 
                   then remove it */
                path[pos] = -1; 
            } 
        } 
  
        /* If no vertex can be added to Hamiltonian Cycle 
           constructed so far, then return false */
        return false; 
    } 
  
    /* This function solves the Hamiltonian Cycle problem using 
       Backtracking. It mainly uses hamCycleUtil() to solve the 
       problem. It returns false if there is no Hamiltonian Cycle 
       possible, otherwise return true and prints the path. 
       Please note that there may be more than one solutions, 
       this function prints one of the feasible solutions. */
    int hamCycle(int graph[][]) 
    { 
        path = new int[V]; 
        for (int i = 0; i < V; i++) 
            path[i] = -1; 
  
        /* Let us put vertex 0 as the first vertex in the path. 
           If there is a Hamiltonian Cycle, then the path can be 
           started from any point of the cycle as the graph is 
           undirected */
        path[0] = 0; 
        if (hamCycleUtil(graph, path, 1) == false) 
        { 
            System.out.println("\nSolution does not exist"); 
            return 0; 
        } 
  
        printSolution(path); 
        return 1; 
    } 
  
    /* A utility function to print solution */
    void printSolution(int path[]) 
    { 
        System.out.println("Solution Exists: Following" + 
                           " is one Hamiltonian Cycle"); 
        for (int i = 0; i < V; i++) 
            System.out.print(" " + path[i] + " "); 
  
        // Let us print the first vertex again to show the 
        // complete cycle 
        System.out.println(" " + path[0] + " "); 
    } 
  
    // driver program to test above function 
    public static void main(String args[]) 
    { 
        HamiltonianCycle hamiltonian = 
                                new HamiltonianCycle(); 
        /* Let us create the following graph 
           (0)--(1)--(2) 
            |   / \   | 
            |  /   \  | 
            | /     \ | 
           (3)-------(4)    */
        int graph1[][] = {{0, 1, 0, 1, 0}, 
            {1, 0, 1, 1, 1}, 
            {0, 1, 0, 0, 1}, 
            {1, 1, 0, 0, 1}, 
            {0, 1, 1, 1, 0}, 
        }; 
  
        // Print the solution 
        hamiltonian.hamCycle(graph1); 
  
        /* Let us create the following graph 
           (0)--(1)--(2) 
            |   / \   | 
            |  /   \  | 
            | /     \ | 
           (3)       (4)    */
        int graph2[][] = {{0, 1, 0, 1, 0}, 
            {1, 0, 1, 1, 1}, 
            {0, 1, 0, 0, 1}, 
            {1, 1, 0, 0, 0}, 
            {0, 1, 1, 0, 0}, 
        }; 
  
        // Print the solution 
        hamiltonian.hamCycle(graph2); 
    } 
} 
// This code is contributed by Abhishek Shankhadhar

سی شارپ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
// C# program for solution of Hamiltonian  
// Cycle problem using backtracking 
using System; 
  
public class HamiltonianCycle 
{ 
    readonly int V = 5; 
    int []path; 
  
    /* A utility function to check  
    if the vertex v can be added at  
    index 'pos'in the Hamiltonian Cycle 
    constructed so far (stored in 'path[]') */
    bool isSafe(int v, int [,]graph, 
                int []path, int pos) 
    { 
        /* Check if this vertex is  
        an adjacent vertex of the 
        previously added vertex. */
        if (graph[path[pos - 1], v] == 0) 
            return false; 
  
        /* Check if the vertex has already  
        been included. This step can be 
        optimized by creating an array 
        of size V */
        for (int i = 0; i < pos; i++) 
            if (path[i] == v) 
                return false; 
  
        return true; 
    } 
  
    /* A recursive utility function 
    to solve hamiltonian cycle problem */
    bool hamCycleUtil(int [,]graph, int []path, int pos) 
    { 
        /* base case: If all vertices  
        are included in Hamiltonian Cycle */
        if (pos == V) 
        { 
            // And if there is an edge from the last included 
            // vertex to the first vertex 
            if (graph[path[pos - 1],path[0]] == 1) 
                return true; 
            else
                return false; 
        } 
  
        // Try different vertices as a next candidate in 
        // Hamiltonian Cycle. We don't try for 0 as we 
        // included 0 as starting point in in hamCycle() 
        for (int v = 1; v < V; v++) 
        { 
            /* Check if this vertex can be  
            added to Hamiltonian Cycle */
            if (isSafe(v, graph, path, pos)) 
            { 
                path[pos] = v; 
  
                /* recur to construct rest of the path */
                if (hamCycleUtil(graph, path, pos + 1) == true) 
                    return true; 
  
                /* If adding vertex v doesn't  
                lead to a solution, then remove it */
                path[pos] = -1; 
            } 
        } 
  
        /* If no vertex can be added to Hamiltonian Cycle 
        constructed so far, then return false */
        return false; 
    } 
  
    /* This function solves the Hamiltonian  
    Cycle problem using Backtracking. It  
    mainly uses hamCycleUtil() to solve the 
    problem. It returns false if there 
    is no Hamiltonian Cycle possible,  
    otherwise return true and prints the path. 
    Please note that there may be more than  
    one solutions, this function prints one  
    of the feasible solutions. */
    int hamCycle(int [,]graph) 
    { 
        path = new int[V]; 
        for (int i = 0; i < V; i++) 
            path[i] = -1; 
  
        /* Let us put vertex 0 as the first 
        vertex in the path. If there is a  
        Hamiltonian Cycle, then the path can be 
        started from any point of the cycle  
        as the graph is undirected */
        path[0] = 0; 
        if (hamCycleUtil(graph, path, 1) == false) 
        { 
            Console.WriteLine("\nSolution does not exist"); 
            return 0; 
        } 
  
        printSolution(path); 
        return 1; 
    } 
  
    /* A utility function to print solution */
    void printSolution(int []path) 
    { 
        Console.WriteLine("Solution Exists: Following" + 
                        " is one Hamiltonian Cycle"); 
        for (int i = 0; i < V; i++) 
            Console.Write(" " + path[i] + " "); 
  
        // Let us print the first vertex again 
        //  to show the complete cycle 
        Console.WriteLine(" " + path[0] + " "); 
    } 
  
    // Driver code 
    public static void Main(String []args) 
    { 
        HamiltonianCycle hamiltonian = 
                                new HamiltonianCycle(); 
        /* Let us create the following graph 
        (0)--(1)--(2) 
            | / \ | 
            | / \ | 
            | /     \ | 
        (3)-------(4) */
        int [,]graph1= {{0, 1, 0, 1, 0}, 
            {1, 0, 1, 1, 1}, 
            {0, 1, 0, 0, 1}, 
            {1, 1, 0, 0, 1}, 
            {0, 1, 1, 1, 0}, 
        }; 
  
        // Print the solution 
        hamiltonian.hamCycle(graph1); 
  
        /* Let us create the following graph 
        (0)--(1)--(2) 
            | / \ | 
            | / \ | 
            | /     \ | 
        (3)     (4) */
        int [,]graph2 = {{0, 1, 0, 1, 0}, 
            {1, 0, 1, 1, 1}, 
            {0, 1, 0, 0, 1}, 
            {1, 1, 0, 0, 0}, 
            {0, 1, 1, 0, 0}, 
        }; 
  
        // Print the solution 
        hamiltonian.hamCycle(graph2); 
    } 
} 
  
// This code contributed by Rajput-Ji

خروجی:

Solution Exists: Following is one Hamiltonian Cycle
 0  1  2  4  3  0

Solution does not exist

توجه به این نکته لازم است که قطعه کد بالا، همیشه دورهایی که از صفر شروع می‌شوند را چاپ می‌کند. نقطه شروع نباید اهمیتی داشته باشد، زیرا یک دور می‌تواند از هر راسی آغاز شود. افرادی که قصد تغییر دادن نقطه شروع را دارند، باید دو تغییر در کد بالا اعمال کنند. تغییر «;path[0] = 0» به «;path[0] = s» که در آن، s نقطه شروع جدید است. همچنین، باید حلقه «(++for (int v = 1; v < V; v» در ()hamCycleUtil، به «(++for (int v = 0; v < V; v» تغییر پید

منبع: فرادرس

مشاوره جمعه 28 تیر 1398 ساعت 15:53

0 نظر

توسعه یک اپلیکیشن MacOS ساده — از صفر تا صد

مشاوره جمعه 28 تیر 1398 ساعت 15:52

0 نظر

ساخت ارائه با گوگل اسلایدز (Google Slides) — راهنمای گام به گام

بسیاری از افراد بر این باورند که گوگل اسلایدز (Google Slides) نسخه‌ای از پاورپوینت برای آنهایی است که نمی‌خواهند این نرم‌افزار را بخرند. البته این دیدگاه کمی خصمانه محسوب می‌شود، چون قابلیت‌های سرویس اسلایدز گوگل دست کمی از پاورپوینت ندارند. Google Slides برنامه‌ای عالی است که ایجاد همه چیز از ارائه‌های کاری تا تدوین یک کتاب آشپزی را ممکن می‌سازد. تنها لازمه این کار نیز داشتن یک حساب کاربری گوگل است.

با این وجود، این انتقاد نشان می‌دهد که چه قدر افراد با امکانات سرویس گوگل اسلایدز ناآشنا هستند. در این مقاله برای از بین بردن این دیدگاه اشتباه با روش ایجاد یک ارائه ساده از صفر تا صد آشنا خواهیم شد.

گام 1: تنظیم اولیه سند

Google Slides

نخستین کاری که باید انجام دهیم، باز کردن اپلیکیشن گوگل اسلایدز (Google Slides) است. بدین منظور باید ابتدا یک حساب کاربری گوگل داشته باشید. اگر این حساب کاربری را ندارید، ساخت آن بسیار ساده و کافی است به این آدرس (+) مراجعه کنید. سپس باید به گوگل درایو رفته و به منوی New > Google Slides > From a template مراجعه کنید.

در این زمان می‌توانید در صورت تمایل از یک قالب خالی ارائه استفاده کنید، ما در این راهنما قصد داریم برخی طراحی‌های از پیش موجود را کمی دستکاری کنیم. این کار در چند مرحله انجام می‌یابد و فرایند طراحی را تسریع می‌کند.

Google Slides

زمانی که روی From a template کلیک کنید، به گالری قالب‌ها می‌روید. گوگل این قالب‌ها را همانند ابزار Canva گروه‌بندی کرده است. یکی از رایج‌ترین کاربردهای یک اسلایدشو، طراحی یک ارائه‌ی کاری است، بنابراین در این راهنما از General Presentation یا همان قالب‌های مناسب ارائه‌های عمومی استفاده می‌کنیم.

Google Slides

زمانی که قالب خود را باز کنید، صفحه‌ای را می‌بینید که بسیار شبیه به آنچه در تصویر آمده است. در راستای بخش فوقانی یک نوار ناوبری وجود دارد. در سمت چپ فضای کاری صفحه‌های قالب دیده می‌شوند که به ترتیب چیده شده‌اند. در مرکز فضای کاری نسخه بزرگ‌تری از صفحه‌ای که فعال است را مشاهده می‌کنید. در سمت راست فضای کاری منوی بازشدنی دیگری به نام Themes (قالب‌ها) دیده می‌شود.

گام 2: نوار ناوبری گوگل اسلایدز را بشناسید

گوگل اسلایدز (Google Slides) پیچیده است، اما یکی از مهم‌ترین چیزهایی که باید بشناسید نوار ناوبری است که در بخش فوقانی فضای کاری قرار دارد و باید با محتوای هر یک از این منوهای بازشدنی آشنا شوید.

در منوی File گزینه‌های ابتدایی کنترل ارائه‌های اسلاید گوگل را مشاهده می‌کنید. این موارد شامل اشتراک‌گذاری، ایمپورت کردن اسلایدها، دانلود کردن اسلایدها، تنظیمات مقدماتی اولیه، تنظیمات پرینت و زبان است. در منوی Edit ابزارهای ساده‌ای جهت کنترل هر یک از صفحه‌ها مشاهده می‌کنید. این موارد شامل گزینه‌هایی برای بازگردانی تغییرها، اجرای مجدد یک تغییر، برش، کپی کردن و چسباندن است.

در منوی View روش‌های مختلف مشاهده ارائه را می‌بینید. همچنین گزینه‌ای برای رفتن به بخش Animations مشاهده می‌شود. بدین ترتیب می‌توانید انیمیشن‌هایی را در ارائه خود بگنجانید.

در منوی Insert گزینه‌های مختلفی برای محتوایی که در ارائه جای داده می‌شوند وجود دارند. در منوی Format نیز ابزارهایی را می‌بینید که از گزینه‌های تنظیم متن، سبک‌های مختلف فونت و چیدمان تا لیست‌های گلوله‌ای و شماره‌گذاری را شامل می‌شود.

منوی Slide امکان ایجاد تغییرات بزرگ در ارائه را فراهم می‌سازد. منوی Arrange امکان سازمان‌دهی عناصر روی هر صفحه را فراهم می‌کند. منوی Tools امکان اصلاح غلط‌های املایی، بررسی واژه‌ها در دیکشنری و افزودن گزینه‌های دسترس‌پذیری به ارائه را فراهم کرده است.

منوی Add-on میانبری برای قابلیت‌های ویژه است که می‌توان به اسلایدهای گوگل اضافه کرد.

در نهایت با کلیک روی منوی Help می‌توان موارد آموزشی بیشتر را دریافت کرد و یا به‌روزرسانی‌ها را مورد جستجو قرار داد.

گام 3: تغییر دادن قالب (Theme)

Google Slides

زمانی که بررسی منوها را به پایان بردید و ایده‌ای کلی از کار هر کدام به دست آوردید، ممکن است بخواهید Theme-های مختلفی که برای اسلایدهای گوگل وجود دارند را مورد بررسی قرار دهید. همان طور که قبلاً اشاره کردیم گوگل اسلایدز (Google Slides) ارائه‌ها را بر مبنای هدفی که دارند گروه‌بندی می‌کند. درون هر گروه تم‌های دیداری را که می‌توان روی اسلاید شو اعمال کرد را مشاهده می‌کنید.

تم‌ها می‌توانند شامل فونت‌ها، رنگ‌ها و استایل‌های خاص باشند. زمانی که روی یکی از آن‌ها کلیک می‌کنید، می‌توانید به روشی سریع و آسان از این که همه چیز هماهنگ به نظر می‌رسند مطمئن شوید. برای تغییر دادن تم، کافی است روی گزینه‌های موجود در سمت راست فضای کاری اسکرول کنید. در ادامه می‌توانید بسته به نیازهای خود روی هر کدام از آن‌ها کلیک کنید.

گام 4: تغییر فونت

Google Slides

پس از انتخاب تم می‌توانید شروع به وارد کردن اطلاعات خود در اسلاید شو بکنید. برای تغییر دادن متن Placeholder کافی است روی هر کادر کلیک کرده و شروع به نوشتن بکنید. همچنین می‌توانید فونت و رنگ فونت را نیز تغییر دهید.

Google Slides

برای تغییر دادن رنگ، باید مطمئن شوید که آن چه قرار است تغییر یابد انتخاب شده است. سپس روی گزینه رنگ فونت که در شکل فوق با کادر قرمز مشخص شده است کلیک کنید.

زمانی که روی آن کلیک کنید یک منوی بازشدنی مشاهده خواهید کرد که گزینه‌های زیادی دارد. در این منو می‌توانید رنگ‌هایی که در این پالت رنگ برای شما چیده شده‌اند را ببینید. همچنین می‌توانید با کلیک روی گزینه Custom رنگ جدیدی بسازید.

Google Slides

اگر می‌خواهید استایل فونت خود را عوض کنید، باید ابتدا مطمئن شوید که متن انتخاب شده است. سپس روی منوی بازشدنی فونت کلیک کرده و استایل مورد نظر خود را انتخاب کنید.

نکته: باید اطمینان حاصل کنید که فونت انتخاب شده موجب سهولت در خوانایی متن می‌شود، چون اغلب ارائه‌ها از فاصله‌ای نسبتاً دور دیده می‌شوند.

گام 5: تغییر دادن پس‌زمینه

Google Slides

هنگامی که این ارائه را کنار هم قرار می‌دهید، ممکن است متوجه شوید که پس‌زمینه خسته‌کننده است یا روشی که نمایش می‌یابد را نپسندید.

برای تغییر دادن پس‌زمینه روی صفحه اسلاید راست-کلیک کنید. در این زمان باید مطمئن شوید که متن روی صفحه انتخاب نشده است. سپس گزینه Change Background را انتخاب کنید. زمانی که کادر محاوره‌ای باز می‌شود، می‌توانید رنگ پس‌زمینه خود را عوض کنید، یک تصویر روی آن قرار دهید یا پس‌زمینه را به حالت پیش‌فرض قبلی ریست کنید.

در بخش Color می‌توانید یک رنگ ثابت یا گرادیان رنگی برای پس‌زمینه انتخاب کنید. همچنین می‌توانید رنگ‌ها و گرادیان‌های سفارشی انتخاب کنید.

Google Slides

زمانی که پس‌زمینه نهایی شد، قادر هستید یکی از گزینه‌های Done یا Add to theme را انتخاب کنید؛ اگر این پس‌زمینه را به تم خود اضافه کنید، هر صفحه‌ای در ارائه که پس‌زمینه منطبق دارد، این تغییرها را در خود بازتاب می‌دهد. پس از اعمال شدن تغییرها روی Done کلیک کنید.

گام 6: تعویض تصویر

Google Slides

در برخی موارد یک تصویر placeholder (جانمایی) در قالب وجود دارد و می‌خواهیم آن را عوض کنیم. روی چنین تصویری که می‌خواهیم عوض شود، کلیک می‌کنیم تا یک کادر انتخاب آبی‌رنگ پیرامون آن ظاهر شود. سپس روی گزینه Replace Image که در تصویر فوق به رنگ قرمز دیده می‌شود کلیک می‌کنیم. در ادامه می‌توانید گزینه آپلود یک تصویر از رایانه، جستجوی وب برای یک تصویر یا درج یک تصویر از طریق URL را انتخاب کنید.

نکته مهم: مطمئن شوید که دسترسی استفاده از عکس‌هایی که می‌خواهید درج کنید را دارید. اگر در یافتن تصاویر دچار مشکل هستید، می‌توانید از برخی وب‌سایت‌های اشتراک رایگان عکس مانند unsplash (+) استفاده کنید.

گام 7: حذف اسلاید

Google Slides

زمانی که مشغول کار روی این اسلایدها هستید، ممکن است متوجه شوید که یک یا دو صفحه در قالب وجود دارد که مورد نیاز شما نیست. برای این که از شر این صفحه‌ها رها شوید باید به سمت چپ فضای کاری بروید و روی صفحه‌ای که می‌خواهید حذف کنید راست-کلیک کرده در ادامه روی Delete کلیک کنید.

گام 8: جابجایی یک اسلاید

Google Slides

برخی اوقات، اسلایدی را می‌بینیم که از طرح‌بندی آن واقعاً خوشمان می‌آید، اما در مکان نامناسبی از ارائه قرار دارد. برای نمونه، برای انتقال یک اسلاید به انتها روی صفحه‌ای که می‌خواهید جابجا کنید کلیک کرده و سپس گزینه Move slide to end را انتخاب کنید. کار به همین سادگی است.

گام 9: افزودن گذار

Google Slides

زمانی که کار تنظیم کردن ارائه را به پایان بردید، می‌توانید در مورد روش ارائه کردن این اسلاید شو نیز فکر کنید. برای نمونه می‌خواهید ارائه شما چگونه به پیش برود؟ آیا می‌خواهید بین هر یک از صفحه‌ها انیمیشن کوچکی باشد؟

برای افزودن یک «گذار» (transition) بین اسلایدها، روی صفحه‌ای که می‌خواهید تنظیم کنید راست کلیک کرده و گزینه Change Transition را انتخاب کنید.

Google Slides

در زمان انجام این کار، نوار ابزار سمت راست فضای کاری، گزینه‌های جدیدی را که می‌توانید استفاده کنید نمایش می‌دهد. گزینه‌ای که می‌خواهید را از منوی بازشدنی انتخاب کنید. همچنین می‌توانید این گذار را روی کل ارائه یا صرفاً روی یک اسلاید منفرد اعمال کنید.

سخن پایانی

سرویس گوگل اسلایدز، اپلیکیشن آنلاین ارزشمندی است و با این که در این راهنما همه امکانات آن را بررسی نکردیم، اما تلاش کردیم موارد مقدماتی را به طرز مناسبی پوشش دهیم. شما با بهره‌گیری از این اپلیکیشن دیگر هرگز نگران نخواهید بود که ارائه‌تان غیرحرفه‌ای به نظر بیاید و مهم نیست که به برنامه‌های ساخت اسلاید شو دیگر دسترسی داشته باشید یا خیر.

منبع: فرادرس

مشاوره جمعه 28 تیر 1398 ساعت 15:50

0 نظر

ایجاد نوار ناوبری واکنش گرا با HTML ،CSS و جی کوئری – از صفر تا صد

وار ناوبری یکی از مؤلفه‌های اصلی هر وب‌سایتی محسوب می‌شود و شاید مهم‌ترین مؤلفه باشد. در واقع نوار ناوبری نخستین جایی است که کاربر هنگام ورود به وب‌سایت مشاهده می‌کند و برای رفتن به بخش‌های مختلف باید از آن استفاده کند.

در این مقاله همه مراحل مورد نیاز برای ساخت یک نوار ناوبری ساده را بررسی می‌کنیم و با روش واکنش‌گرا ساختن آن آشنا می‌شویم. ما قصد داریم یک نوار ناوبری برای یک صفحه پورتفولیو بسازیم که 4 بخشبه صورت About Me ،Projects ،CV و Contacts دارد. البته شما می‌توانید آن را بسته به میل خود تغییر دهید.

در نهایت چیزی مانند تصویر زیر خواهیم داشت:

نوار ناوبری

ابتدا کد HTML

تگ مورد استفاده برای ایجاد نوار ناوبری <nav> است و از این رو کار خود را از همین اینجا آغاز می‌کنیم. کافی است تگ nav را باز کرده و ببندیم و فضایی بین دو تگ باقی بگذاریم تا تگ‌های دیگری در آن تعریف شوند.

1
2
3
<nav>
  
</nav>

اکنون که همه چیز آماده است، می‌توانیم لیست لینک‌های خود را اضافه کنیم. برای ایجاد یک لیست می‌توانیم از تگ <ul> استفاده کنیم که اختصاری برای unordered list است. این تگ کانتینری برای list items با تگ <li> خواهد بود. تگ ul نیز درون تگ nav قرار می‌گیرد.

1
2
3
4
5
<nav>
  <ul>
  
  </ul>
</nav>

سپس می‌توانیم شروع به افزودن آیتم‌های لیست خود بکنیم که شامل لینک‌هایی به بخش‌های اصلی وب‌سایت ما خواهد بود. (4 بخش که قبلاً معرفی کردیم):

1
2
3
4
5
6
7
8
9
10
11
12
<nav>
  <ul>
    <!-- list item one -->
    <li> </li>
    <!-- list item two -->
    <li> </li>
    <!-- list item three -->
    <li> </li>
    <!-- list item four -->
    <li> </li>
  </ul>
</nav>

برای هر لیست آیتم باید نام بخش متناظر را اضافه کنیم، اما همچنین باید اطمینان حاصل کنیم که وقتی کاربری روی آن کلیک می‌کند، صفحه به سمت پایین اسکرول می‌کند تا به بخش مرتبط برسد. این کار از طریق تگ <a> یا تگ anchor میسر خواهد بود. شما می‌توانید هر تگ دیگری را نیز درون آیتم لیست درج کنید و سپس نام بخش را درون تگ anchor بنویسید.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<nav>
  <ul>
    <li> 
      <!-- link one -->
      <a> About Me </a>
    </li>
    <li>
      <!-- link two -->
       <a> Projects </a>
    </li>
    <li>
      <!-- link three -->
      <a> CV </a>
    </li>
    <li>
      <!-- link four -->
      <a> Contacts </a>
    </li>
  </ul>
</nav>

در این مرحله صفحه ما چیزی مانند تصویر زیر است:

البته هنوز شباهت چندانی به یک نوار ناوبری ندارد، اما تقریباً همه کد HTML که برای اجرای آن نیاز داریم را نوشته‌ایم و در ادامه صرفاً باید آن را استایل‌دهی بکنیم.

اکنون برای این که این لینک‌های قابل کلیک باشند، باید یک خصوصیت href به تگ‌های anchor خود اضافه کنیم. این خصوصیت شامل id بخشی که لینک شده خواهد بود و دارای ساختار correspondingId# است.

تصور کنید که 4 بخش داریم که id متناظر آن‌ها به ترتیب aboutMe ،#projects ،#cv# و contacts# است و می‌خواهیم به این تگ‌های anchor با استفاده از خصوصیت href یک id انتساب دهیم.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<nav>
  <ul>
    <li> 
      <!-- link one -->
      <a href="#aboutMe"> About Me </a>
    </li>
    <li>
      <!-- link two -->
       <a href="#projects"> Projects </a>
    </li>
    <li>
      <!-- link three -->
      <a href="#cv"> CV </a>
    </li>
    <li>
      <!-- link four -->
      <a href="#contacts"> Contacts </a>
    </li>
  </ul>
</nav>

نوار ناوبری ما اینک مانند تصویر زیر شده است:

زمان آن رسیده است که آن را کمی استایل‌دهی کنیم.

استایل‌دهی CSS

به احتمال بالا شما برای رها شدن از شر آن نقاط bullet لحظه‌شماری می‌کنید. اگر چنین است، جای نگرانی نیست، چون همین الان می‌خواهیم این کار را انجام دهیم. کافی است فایل css دارای 3 خط زیر را بنویسیم که معنی آن این است که همه آیتم‌ها لازم نیست استایل لیست داشته باشند.

1
2
3
li{
  list-style-type: none;
}

اکنون نوبت به رها شدن از آن زیرخط‌ها رسیده است. به این منظور 3 خط کد زیر را نیز به فایل CSS اضافه می‌کنیم:

1
2
3
a{
  text-decoration: none;
}

تصور کنید می‌خواهیم یک نوار ناوبری افقی بسازیم و می‌خواهیم کل عرض صفحه را بپوشاند. این کار را می‌توانیم با افزودن یک خصوصیت width: 100vw به تگ nav انجام دهیم. معنی 100 در این خصوصیت آن است که 100% صفحه را می‌پوشاند و nw نیز به این معنی است که عرض صفحه نمایش (viewport) را می‌پوشاند.

1
2
3
nav{
  width: 100vw;
}

در این مرحله، احتمالاً متوجه هیچ تفاوتی نخواهید شد، اما اگر یک مشخصه رنگ پس‌زمینه به تگ nav بدهید و رنگ آن را مانند زیر به مقداری به جز رنگ فعلی تنظیم کنید همه چیز مشخص می‌شود:

1
2
3
4
nav{
  width: 100vw;
  background-color: #D6EFFF;
}

بدین ترتیب تصویری مانند زیر می‌بینید:

دلیل این که چرا این فضای سفید کوچک در طرفین نوار ناوبری ظاهر می‌شوند این است که عناصری مانند body، یا ul دارای مقادیر پیش‌فرضی برای حاشیه هستند. این مقدار را با تعیین margin:0 به هر دوی این عناصر می‌توان حذف کرد. به علاوه اگر از تورفتگی لیست نیز خوشتان نمی‌آید، می‌توانید مقدار pdding:0 را نیز برای ul تنظیم کنید:

1
2
3
4
5
6
7
8
ul{
  margin: 0;
  padding: 0;
}
 
body{
  margin: 0;
}

نوار ناوبری ما هم اینک کل عرض صفحه را می‌پوشاند:

زمان آن رسیده است که لینک‌ها را در یک ردیف قرار دهیم و این کار را می‌توان به روش‌های متفاوتی انجام داد. دو مورد از آن‌ها را در ادامه ملاحظه می‌کنید:

افزودن مشخصه ;display: inline به li
افزودن مشخصه display: flex به ul

ما از گزینه دوم استفاده می‌کنیم زیرا در حالتی که بخواهیم نوار ناوبری خود را واکنش‌گرا بکنیم، انعطاف‌پذیری بیشتری در اختیار ما قرار می‌دهد.

1
2
3
4
5
6
7
ul{
  margin: 0;
  padding: 0;
  
  /*this option by default dispose the elements in a row (flex-direction: row)*/
  display: flex;
}

اکنون باید بین این آیتم‌های لیست فاصله‌بندی کنیم و این کار از طریق تعیین margin برای هر یک میسر است. پیشنهاد می‌کنیم از مضربی از عرض viewport مانند آنچه در مورد عرض نوار ناوبری اجرا کردیم استفاده کنید. ما از margin به مقدار 2vw برای سمت راست و چپ استفاده می‌کنیم:

1
2
3
4
5
6
li{
  list-style-type: none;  
  
  /*when I specify 2 values to margin, the first one is for the top and bottom side, the second for the left and right side*/
  margin: 0 2vw;
}

همچنین می‌توانید اندازه فونت را به صورت مضربی از viewport تنظیم کنید. در این مورد ترجیح می‌دهیم از مضربی از ارتفاع ویوپورت استفاده کنیم که متناسب با عرض آن است و با vh نمایش پیدا می‌کند.

1
2
3
4
5
6
li{
  list-style-type: none;  
  margin: 0 2vw;
  /* our font-size will be 3% of the height of the viewport */
  font-size: 3vh;
}

اکنون اگر بخواهیم فاصله‌ای در بخش بالا و پایین نوار ناوبری خود نیز ایجاد کنیم می‌توانیم یک padding به عناصر <a> خود اضافه کنیم. همچنین می‌توانید آن رنگ آبی پیش‌فرض را حذف کنید. برای نمونه ما رنگ سیاه را ترجیح می‌دهیم.

1
2
3
4
5
6
7
8
9
10
a{
  text-decoration: none;
  
  /*below I changed the color*/
  color: black;
  /*I added some padding*/
  padding: 2vw;
  /*also changed the font family but that's totally irrelevant*/
  font-family: monospace;
}

اکنون اگر کدی بنویسیم که هر بار روی نام بخشی می‌رویم تا حدودی هایلایت شود، جالب خواهد بود. این کار را با استفاده از سلکتور hover می‌توان اجرا کرد که ساختار آن به صورت زیر است:

element:hover{ /*property that will change when I move the mouse on the element here*/}.

کد مربوطه به صورت زیر است:

1
2
3
a:hover{
  background-color: #C6E9FF;
}

منوی واکنش‌گرا

اگر از یک رایانه یا تبلت برای دیدن این صفحه استفاده می‌کنید، طرح‌بندی صفحه بی‌نقص خواهد بود، اما اگر روی گوشی آن را ببینید به صورت زیر درمی‌آید:

یکی از راه‌حل‌های اجتناب از این قرارگیری جدولی این است که یک نوار ناوبری عمودی بسازیم که پنهان است و تنها زمانی که روی یک دکمه کلیک می‌کنید ظاهر می‌شود.

قبل از هر چیز باید نوار ناوبری را عمودی کنیم. به این منظور باید از این واقعیت کمک بگیریم که در لیست نامرتب خود از مشخصه display: flex استفاده کرده‌ایم. بدین ترتیب کافی است یک مشخصه تعریف کرده و مقدار آن را column قرار دهیم. برای اطمینان از این که این کار تنها روی صفحه‌های کوچک صورت می‌گیرد می‌توانیم از مفهومی به نام media query استفاده کنیم.

همچنین باید مطمئن شویم که عنصر <a> کل عرض صفحه را می‌پوشاند به طوری که وقتی ماوس را روی آن می‌بریم می‌توانیم تغییر رنگ برای کل عرض صفحه ببینیم. به این منظور باید به عناصر a مشخصه‌ای به صورت display: block بدهیم.

بدین ترتیب هیچ فاصله‌ای در بخش فوقانی و تحتانی آن باقی نمی‌ماند (مقدار margin: 0 به li بدهید).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*change the layout of the navigation bar for all the screens 
that have a width less or equal than 500px*/
 
@media only screen and (max-width: 500px) {
  /*shows elements in a column*/
  ul{
    flex-direction: column;
  }
  
  /* deletes margin on top or bottom of the a tag*/
  li{
    margin: 0;
  }
 /* makes sure that the a tag will take the entire screen*/
  a{
    display: block;
  }
}

در این مرحله ما تقریباً کار خود را به پایان برده‌ایم. کافی است دکمه‌ای طراحی کنیم که با کلیک کردن روی آن این منوی ناوبری باز و بسته شود. این دکمه را هر جایی می‌توان گذاشت، اما ما در این مثال آن را در تگ <ul> عنصر نخست قرار می‌دهیم تا در ابتدای لیست‌های آیتم نمایش یابد و مطمئن می‌شویم که همان alignment لیست آیتم را دارد.

1
2
3
4
5
6
7
8
9
10
<nav>
  <ul>
      <!-- button here -->
      <button> 
                                
                                        مشاوره
                                    
                                    جمعه 28 تیر 1398 ساعت 15:50
                                
                                            0 نظر
                                            
                                140 

                                                1
                                            
                                                ...
                                            
                                                6
                                            
                                                7
                                            
                                                صفحه 8
                                            
                                                9
                                            
                                                10
                                            
                                                ...
                                            
                                                28

طراحی سایت و برنامه نویسی

ابر برجسب

جدیدترین یادداشت‌ها

بایگانی

جستجو

آشنایی با آپاچی اسپارک (Spark) و پایتون — راهنمای مقدماتی

مقدمه‌ای بر آپاچی اسپارک

نکته قابل توجه

1. نصب لوکال

جاوا

اسکالا

نصب Py4j

اسپارک و هادوپ

2. Databricks

3. Google Colab

سخن پایانی

یافتن دور همیلتونی با الگوریتم پس گرد — به زبان ساده

یافتن دور همیلتونی در گراف

ورودی:

خروجی:

الگوریتم ساده (Naive Algorithm)

یافتن دور همیلتونی با الگوریتم پس‌گرد (Backtracking Algorithm)

پیاده‌سازی الگوریتم پس‌گرد برای مساله یافتن دور همیلتونی در گراف

++C

C

پایتون

جاوا

سی شارپ

توسعه یک اپلیکیشن MacOS ساده — از صفر تا صد

ساخت ارائه با گوگل اسلایدز (Google Slides) — راهنمای گام به گام

گام 1: تنظیم اولیه سند

گام 2: نوار ناوبری گوگل اسلایدز را بشناسید

گام 3: تغییر دادن قالب (Theme)

گام 4: تغییر فونت

گام 5: تغییر دادن پس‌زمینه

گام 6: تعویض تصویر

گام 7: حذف اسلاید

گام 8: جابجایی یک اسلاید

گام 9: افزودن گذار

سخن پایانی

ایجاد نوار ناوبری واکنش گرا با HTML ،CSS و جی کوئری – از صفر تا صد

ابتدا کد HTML

استایل‌دهی CSS

منوی واکنش‌گرا