Слова для игры в виселицу: Подскажете интересные слова для игры "виселица" (см)?

Детская игра «Виселица» — правила. Развлечения и игры для детей без компьютера!

Картинка игры: 

Игра, которая поможет скоротать время двоим. Игроку нужно угадывать буквы в загаданном другим игроком слове.

Правила игры «Виселица»

Один участник (водящий) загадывает слово и рисует на листе такое количество подчёркиваний, сколько букв в слове (кстати, желающие могут использовать дорожный набор для игры в Виселицу). Другой участник начинает называть буквы, чтобы отгадать слово. Если буква есть в слове, то водящий обязан вписать её на своё место в слово (если таких букв несколько — то вписываются все), а если нет — то он рисует один элемент виселицы с человечком (стойка, перекладина, распорка, верёвка, голова, туловище, 2 руки, 2 ноги — всего 10 элементов-попыток).

Если отгадывающий не успел угадать слово раньше, чем виселица нарисована полностью, то он считается «повешенным» и должен угадывать следующее слово. Если слово отгадано — то игроки меняются местами.

Подсказки:

• Для угадывающего: начинайте угадывать буквы с наиболее часто встречающихся: о е а и н т с р в л к м д п у я ы ь г з б ч й х ж ш ю ц щ э ф ъ ё.
• Кроме того, начав с гласных (о е а…), лучше переключиться на согласные, потому что именно по ним слово угадывается легче.
• Подсказка для водящего: поначалу кажется, что нужно загадывать длинные слова, чтобы буквы в них отгадывались дольше. Однако, чем длиннее слово, тем больше в нём часто встречающихся букв. Поэтому лучше загадывать короткие слова с редко встречающимися буквами, чтобы было сложно угадать их за десять отведённых попыток.

Понравилось? Оцени: 

Сохраните для себя, поделитесь с друзьями:

без компьютера, в слова, детские развлечения, настольные, в дороге, дома, на уроках, сидячие, спокойные, для детей 5-10 лет, для подростков, для школьников, и для взрослых — тоже!,

Наш рейтинг игры «Виселица»: 3.8 из 5, оценок — 332

Правила игр — Игры с бумагой и карандашом (часть 4)

«Рисунки»

В «Рисунки» лучше всего играть двумя командами по меньшей мере с тремя игроками в каждой. Также необходим ведущий, не входящий ни в одну из команд.

Ведущий составляет список из шести названий книг, пословиц или иных тем (загадки могут относиться к определенной теме). Ведущий шепчет на ухо одному игроку из каждой команды первую загадку из списка. Этот игрок возвращается к своей команде (желательно, чтобы команды находились в разных комнатах) и должен набросать рисунок, иллюстрирующий сказанное ведущим. Он может пририсовывать детали или делать новые рисунки до тех пор, пока кто-нибудь из команды не даст правильный ответ (однако вслух никаких намеков давать нельзя!).

Как только один игрок дал правильное название, он может отправляться к ведущему за следующим названием из списка. Победителем становится команда, первой угадавшая все названия из списка ведущего.

«Виселица»

«Виселица» — это популярная игра для двух и более человек. Один игрок придумывает слово примерно из пяти или шести букв. Он рисует столько черточек, сколько букв в данном слове. Затем остальные игроки начинают угадывать буквы слова, называя по одной за раз.

Если буква угадана правильно, первый игрок вписывает ее над соответствующим штрихом — если она появляется в слове несколько раз, то одновременно вписываются все. Однако, если догадка оказалась неправильной, первый игрок начинает рисовать виселицу — по одной черточке на каждую неверно названную букву.

Остальные участники должны попытаться отгадать слово до того, как первому игроку удастся дорисовать виселицу. Если один из игроков угадал слово (в ходе игры это становится все легче), следующее слово загадывает он. Если первый игрок дорисовал виселицу до того, как слово угадано, следующее слово загадывает он же.

Чтобы усложнить игру, можно брать более длинные слова в качестве варианта: игрок может загадать группу слов, составляющую пословицу, или название книги, либо фильма — и должен дать остальным игрокам подсказку относительно того, к какой теме они относятся.

«Крестики-нолики»

Эта любимая игра не одного поколения рассчитана на двух игроков и иногда заканчивается за считанные секунды!

Надо начертить две вертикальные линии, пересеченные двумя горизонтальными, что дает девять полей. Игроки решают, кто из них будет рисовать нолики (кружки), а кто — крестики.

Игроки по очереди заполняют свободные поля до тех пор, пока одному из них не удастся выстроить три своих значка подряд в одну линию (по горизонтали, вертикали или диагонали). После этого он перечеркивает линией свой победный ряд, и игра заканчивается.

Если никому из игроков не удалось составить ряд, игра заканчивается вничью.

Так как игрок, делающий первый ход, имеет преимущество, то после каждой партии игроки меняются ходами.

«Трехмерные крестики-нолики»

Так как основан на стандартной игре, трехмерный вариант представляет собой более продолжительную и более интригующую версию. «Трехмерные крестики-нолики» можно купить в магазине, но с равным успехом в них можно играть, пользуясь бумагой и карандашом.

Куб можно изобразить схематически в виде 64 квадратов, как показано на рисунке. В практических целях каждый уровень куба чертится отдельно.
Правила игры аналогичны обычным «Крестикам-ноликам», но победителем становится игрок, первым выстроивший в ряд четыре своих значка (см. рисунки).

Первая версия «Виселицы»— Ruby Rush

Узнаем много новых инструментов (методы массивов include?, join и split), научимся проектировать сложные программы, разбивая их на методы, а методы выделять в отдельный файл и подключать его с помощью команды require.

Эту программу будем использовать далее для освоения других тем. Поэтому отнеситесь к уроку особенно внимательно и ответственно.

План урока

1. Описание игры, проектируем виселицу
2. Подключение файлов в программах, инструкция require
3. Настройка программы, улучшения и украшения

Описание игры «Виселица»

Игра заключается в том, что один человек загадывает слово, а другой человек отгадывает его по буквам: отгадал — буква открывается (как в «Поле чудес»), не отгадал — засчитывается ошибка и рисуется «Виселица»: 7 ошибок и готово! 🙂

Если кто не понял, это была постановка задачи, которую мы уже давным-давно привыкли делать перед тем, как начинать что либо писать. Как и все программы в этом курсе, наша игра будет работать только в консоли (командной строке).

Ещё немного подготовительных работ: опишем цикл работы программы в виде блок-схемы:

Такие блок-схемы удобно рисовать для мало-мальски сложных программ, разбивая действия программы на логически-независимые блоки.

Забегая вперёд скажем, что мы будем писать для каждого блока на этой схеме отдельный метод. Такое разбиение программы на блоки и обдумывание, из каких методов будет состоять программа называется «Проектирование программы», мы сейчас описали только самый простейший пример.

Очень важно приучить себя к этому этапу проектирования еще на несложных примерах — это значительно облегчит жизнь в будущем.

Проектирование программы на примере виселицы

Итак, давайте рассмотрим действия на блок-схеме:

1. Загадать слово

Для того, чтобы загадать слово, программа будет считывать то слово, которое ввели при вызове программы из консоли

ruby viselitsa.rb Слово

Это Слово будет сохраняться в переменную для дальнейшей игры.

О том, что слово загадано, программа сообщает пользователю, выводя соответствующую информацию на экран: «Типа слово загадано, и всё такое». Сделаем еще, чтобы программа как-то визуально подсказывала, сколько в загаданном слове букв. Для этого просто будем выводить что-то на экран подчёркивание вместо каждой буквы.

_ _ _ _ _

2. Спросить букву

После того, как слово загадано, программа должна начать процесс общения с игроком: у игрока есть только одно действие — предложить букву для проверки.

Программа будет спрашивать у игрока букву с помощью консольного ввода и команды gets. Как это делается, мы также разбирали в предыдущих уроках.

3. Проверить букву

«Ход» пользователя, то есть, названную букву мы также будем хранить. Но сначала мы проверим, есть ли буква в загаданном слове. О том, как проверить, есть ли буква в слове мы расскажем в этом уроке дальше.

А для хранения букв (отгаданных, которые назвали и которые есть в загаданном слове, и для промахов — букв, которые были предложены, но которых в загаданном слове не оказалось) мы заведём два массива

4. Нарисовать часть виселицы

Если игрок не угадал букву, то ему нужно об этом сообщить.

Во-первых, мы будем писать об этом обычным текстом, во-вторых, с помощью псевдографики мы будем рисовать виселицу, которая будет дорисовываться по мере увеличения количества ошибок.

Виселицу и обычный текст мы будем выводить в консоль ставшей для нас уже дежурной командой puts. Мы использовали её в каждом уроке, я уверен, вы помните, о чём идёт речь.

После рисования виселицы нужно либо вернуться на пункт 2 (спросить букву), если число ошибок меньше семи, либо, если ошибок 7 или больше — закончить игру, написав пользователю о том, что он проиграл.

Решать, куда двинуться после хода пользователя мы будем с помощью конструкции if-else, освежите в памяти, как она работает.

5. Открыть букву

Если игрок назвал букву, которая в слове есть, то необходимо эту букву открыть. Например, если он назвал букву «о», то загаданное ранее слово «слово» будет выглядеть вот так:

_ _ о _ о

Посмотрите, оно как будто немного удивилось, что его почти отгадали. Выводить слово мы будем командой puts.

Если после отгадывания очередной буквы в слове ещё остались прочерки, то нужно вернуть игрока на пункт 2 (спросить букву), а если игрок отгадал всё слово, то ему нужно также об этом сообщить.

Выяснять, что произойдёт дальше мы также будем с помощью конструкции if-esle.

6. Вывести результат

Если пользователь назвал последнюю букву в слове — он выиграл, если он совершил седьмую ошибку — проиграл. Мы сообщим ему об этом в конце игры с помощью всё той же команды puts.

Таким образом, мы примерно представили, как будем выполнять каждый этап нашей задачи на написание консольной игрушки «Виселица».

Конечно, этот проект довольно простой и в реальной жизни программисты делают всё куда бюрократичнее и писанины иногда больше, но мы сейчас лишь приблизительно описали процесс, что бы вы привыкали к важной культурной особенности написания хороших программ: перед написанием кода необходимо сесть и хотя бы немного подумать, как и что у вас будет устроено.

Теперь давайте ненадолго оставим наш план в стороне и займёмся ещё одной важной темой.

Подключение файлов

Если вы увидели программу, состоящую из одного файла, то это либо какая-то тривиальная команда-скрипт, написанная программистом на скорую руку, либо автор программы новичок или сознательно не хочет делать всё по-человечески.

По мере увеличения объёма вашей программы, становится сложно ориентироваться в её тексте, вы начинаете забывать, что вы написали сверху, что снизу, что за чем следует и на какой строчке у вас какой метод.

Представьте, что у вас длинный-длинный рулон бумаги (не туалетной, к счастью), на котором написаны мелким шрифтом какие-то записи, связанные каким-то образом друг с другом. Сориентироваться в этом ворохе не сможет даже автор подобного шедевра.

С другой стороны, если каждый кусочек текста аккуратно написан на отдельном листе бумаге и эти листочки логично сгруппированы по папкам, то ориентироваться в этой картотеке становится делом понимания принципов её устройства.

Различные стратегии организации файлов в проекте — предмет дискуссий суровых программистов. Это принято называть частью так называемой «Архитектуры» приложения.

Конечно, в базовом блоке мы и заикаться об этом не будем, вам это сейчас ни к чему. Главное сейчас уяснить, что делить код вашей программы на отдельные файлы — очень просто и стоит завести себе эту полезную привычку.

Как обычно, в нашей свежесозданной папке c:\rubytut\lesson10 мы создадим два файла methods.rb и viselitsa.rb.

В первом будут лежать описания наших методов, а во втором — основная логика нашей программы, вызовы методов.

Понятно, что второй файл является более главным, значит, именно в нём мы будем подключать файл methods.rb.

Делается это с помощью команды require:

require "./methods.rb"

После команды require необходимо указать путь к подключаемому файлу.

Вот эти два символа ./ перед названием файла указывают на то, что подключаемый файл лежит в той папке откуда запускается программа. Это значит, что программу в консоли надо будет запускать из папки с этими файлами. Пока просто учтите этот важный нюанс, в других уроках мы еще вернемся к нему.

Если бы мы положили methods.rb в под-папку included, то необходимо было бы написать в файле viselitsa.rb вот так:

require "./included/methods.rb"

Что означает: «посмотри в той же папке, откуда запущена программа, папку included, а в ней посмотри файл methods.rb».

Не бойтесь, если Ruby не найдёт файл, который вы указали после команды require, он выдаст ошибку и вы сможете проверить путь.

Как же работает require?

Очень просто, она говорит Ruby «а теперь скопируй содержимое указанного файла в то место, где написана инструкция require». То есть получается один общий файл, склеенный из содержимого всех файлов, на которые написана инструкция require.

То есть если мы в файле methods.rb напишем

puts "Подключаем методы"

А в файле viselitsa.rb напишем

require "./methods.rb"

И запустим последний файл

ruby viselitsa.rb

То мы увидим в консоли надпись, ничего сложного и неожиданного.

Подключаем методы

Основная часть программы «Виселица»

Люди придумали молоток как что-то тяжёлое, чем удобно стучать по тем местам и предметам, по которым нужно стучать.

То есть сначала люди поняли, какая стоит задача, а потом под эту задачу придумали инструмент, метод её решения.

Также и мы, сейчас напишем основную часть нашей программы, считая как будто все методы у нас уже написаны.

Во-первых, мы придумаем метод get_letters, который будет откуда-то брать слово загаданное и возвращать его в виде массива его букв (нам так будет удобнее). Так, чтобы мы могли сохранить его в переменную letters.

letters = get_letters

Мы также создадим отдельные переменные для количества ошибок, угаданных букв и названных букв, которых в слове не оказалось. Первая переменная будет хранить просто число и мы запишем в неё ноль, а две других будут массивами и мы пока запишем в них по пустому массиву, которые потом будем наполнять.

errors = 0
good_letters = []
bad_letters = []

Потом напишем «цикл отгадывания», который будет крутиться, пока число ошибок не станет равным 7 или слово не будет отгадано. В этом цикле нам нужно общаться с пользователем, показывая ему, что происходит, а также спрашивая у него новые буквы.

while errors < 7 do
  # тут будем отгадывать слово
end

Второй метод, который мы придумаем, называется print_status, он будет выводить на экран текущее состояние игры, со всеми отгаданными и неотгаданными буквами, количеством ошибок и так далее. Этому методу потребуются все наши переменные (letters, good_letters, bad_letters и errors), поэтому мы передадим ему их в качестве 4-х параметров.

print_status(letters, good_letters, bad_letters, errors)

В-третьих, мы придумаем метод get_user_input, который будет спрашивать у пользователя букву. Ему никакие параметры не нужны, но он возвращает указанную букву, которую мы сохраняем в локальную переменную user_input, которая доступна только внутри цикла.

puts "\nВведите следующую букву"
user_input = get_user_input

И, наконец, нам нужен ещё один метод: check_result, который будет проверять, есть ли загаданная буква в слове. Ему, понятное дело, нужны все те же переменные, т.к. он будет не только проверять, есть ли буква из user_input среди букв в переменной letters, но и добавлять её в один из массивов good_letters или bad_letters в зависимости от того, угадал пользователь или нет.

result = check_result(user_input, letters, good_letters, bad_letters)

Ещё мы решили прощать игрока, если он называет одну и ту же букву во второй раз. Чтобы это понять, нам также нужно знать, какие он загадывал буквы — для этого у нас уже есть массивы good_letters и bad_letters, которые мы передаём в наш ненаписанный пока метод check_result.

Чтобы в основной программе понять, попал пользователь или нет, нужно, чтобы метод check_result как-то об этом сообщал. Наверное вы уже догадались, что он будет что-то возвращать.

Давайте договоримся, что он будет возвращать такие значения

• 0 — пользователь отгадал букву или такая буква уже была
• 1 — пользователь отгадал букву и всё слово
• -1 — пользователь ошибся и такой буквы нет

Осталось проверить результат: если check_result возвращает 0, нужно просто вернуться в начало цикла, то есть мы ничего не делаем.

Если check_result вернул -1, то нужно увеличить счётчик ошибок на 1 (командой +=, освежите в памяти) и пойти дальше.

Если же check_result вернул 1, то нужно срочно выходить из цикла (как мы уже знаем, это можно сделать командой break) и поздравлять игрока с победой.

Теперь, когда наша программа уже написана, можно приступать к написанию методов. Обратите внимание, мы про каждый их них знаем все три вещи:

1. Название
2. Параметры
3. Возвращаемое значение

Метод get_letters — загадываем слово

Перед написанием метода, как обычно, заполняем небольшую «анкету метода».

1. Название: get_letters
2. Параметры: —
3. Возвращаемое значение: массив загаданных букв загаданного слова

Внутренняя реализация для основной программы совершенно не важна. Если мы захотим поменять метод ввода слова (а мы захотим это сделать в следующих уроках), код основной программы нам менять не придётся. В этом вся прелесть методов.

def get_letters
  # реализация метода
end

Сейчас мы реализуем этот метод так: он будет брать слово из параметров запуска программы, о том, как это сделать, читайте в 8-м уроке, если забыли.

slovo = ARGV[0]

Также, прямо в этом методе мы проверим, что слово вообще указали. Делаем это также, как мы это делали в 8-м уроке.

В этом случае, понятное дело, дальше мы работать не можем, поэтому выходим и пишем пользователю об этом с помощью команды abort, о которой мы узнали в 5-м уроке.

if (slovo == nil || slovo == "")
  abort "Для игры введите загаданное слово в качестве аргумента при запуске программы"
end

И наконец, нам нужно разбить слово на буквы и вернуть командой return. Для этого воспользуемся методом split, который есть у любой строки в Ruby.

Метод строки split

Любую строку в Ruby (да и не только в Ruby) очень легко можно разбить на части и записать их в массив. Например, если у нас есть строка, в которой через запятую записаны какие-то слова:

"ночь,улица,фонарь,аптека"

То с помощью метода split мы можем переделать эту строку в массив с отдельными словами.

Этому методу всего лишь нужно указать, что слова разделены запятой. Мы знаем, что у методов есть параметры и именно они при вызове указываются в скобочках. Поэтому в качестве параметра методу split мы передаём строку, содержащую разделитель, в нашем случае, запятую. Смотрите.

a = "Ночь,улица,фонарь,аптека".split(",")
b = ["ночь","улица","фонарь","аптека"]

Переменные a и b после этого будут указывать на абсолютно одинаковые объекты. А команда

puts "Ночь,улица,фонарь,аптека".split(",")[2]

Выведет в консоль слово «фонарь», потому что если нам нужен третий элемент массива, нам нужно после него в квадратных скобках указать цифру 2.

Если же методу split в качестве параметра передать пустую строку (то есть, просто две кавычки ""), то он разобьёт слово по буквам (типа разделитель — пустота между буквами, не пробелы, а именно пустота):

puts "фонарь".split("")[0]

Выведет в консоль букву «ф».

Вообще, в Ruby со строками можно много чего делать, подробнее смотрите по ссылке.

Наконец, когда мы знаем, как работает метод split, можем вернуться к написанию нашего метода get_letters и завершить его.

Как мы уже помним, в системе Windows все данные в консоли передаются в программы в собственной кодировке, поэтому нам нужно будет конвертировать указанное слово в кодировку UTF-8 с помощью знакомой нам конструкции.

slovo.encode("UTF-8")

Вот так метод должен выглядеть в конце концов:

def get_letters
  slovo = ARGV[0]

  if (slovo == nil || slovo == "")
    abort "Для игры введите загаданное слово в качестве аргумента при запуске программы"
  end

  return slovo.encode("UTF-8").split("")
end

Метод get_user_input — спрашиваем букву

1. Название: get_user_input
2. Параметры: —
3. Возвращаемое значение: буква, которую ввёл пользователь

Мы хорошо знаем как пользоваться командой STDIN.gets, но есть один нюанс: если пользователь просто случайно нажал Enter, не введя буквы, мы простим ему эту оплошность и спросим букву ещё раз, даже не переходя к проверке.

Ну и, как обычно для Windows нужно поменять кодировку введённой буквы в UTF-8 с помощью метода encode, а также, обрезать символ переноса строки \n, который также будет передан при нажатии клавиши Enter вместе с введённой буквой.

Наконец, выйдя из цикла мы вернём букву с помощью команды return.

def get_user_input
  letter = ""

  while letter == "" do
    letter = STDIN.gets.encode("UTF-8").chomp
  end

  return letter
end

Метод check_result — проверяем букву игрока

1. Название: check_result
2. Параметры: user_input — введённая пользователем буква, letters — массив букв загаданного слова, good_letters — массив отгаданных букв, bad_letters — массив букв, которые пользователь вводил, но которых нет в слове
3. Возвращаемое значение: 1, если буква, которую ввёл игрок есть в слове и игрок отгадал всё слово, -1, если буквы, которую ввёл игрок, нет в загаданном слове, 0 во всех других случаях

Это самый сложный метод (это видно по его анкете, кстати). Для начала проверим, не повторяется ли пользователь, посмотрим, нет ли его буквы в одном из массивов good_letters или bad_letters. Мы делаем это с помощью метода include?.

Метод массива include?

Этот метод есть у любого массива в Ruby. Он возвращает true, если переданный в качестве параметра элемент есть в массиве, и false, если такого элемента в массиве нет.

puts ["orange","banana"].include?("apple")

Выведет в консоль false, а такая строчка:

puts ["улица","фонарь","аптека"].include?("аптека")

Выведет в консоль true. Всё довольно прозрачно, не так ли?

Итак, наш метод check_result с помощью встроенного в Ruby метода include? определяет, не вводил ли пользователь уже эту букву ранее.

Мы используем также конструкцию if и передаём в качестве проверочного условия два выражения, соединённые оператором ИЛИ, который записывается в коде программы как две палочки ||:

if good_letters.include?(user_input) || bad_letters.include?(user_input)
  return 0
end

Мы обещали (сами себе), что метод будет возвращать 0 если пользователь вводит букву, которую уже вводил. Так и поступим.

Теперь пора проверить, есть ли введённая буква в загаданном слове. Мы снова пользуется методом include? — именно поэтому мы и решили хранить наше загаданное слово в виде массива букв, а не в виде строчки (к слову, у строк в Ruby тоже есть метод include? — информация для любознательных).

Если введённая буква есть в загаданном слове, мы добавляем эту букву к отгаданным, в массив good_letters, с помощью клювиков:

if letters.include? user_input
  good_letters << user_input
end

Теперь нам надо проверить, не отгадал ли игрок всё слово. Проверка на то, что пользователь отгадал всё слово требует от читателя небольшого логического рассуждения.

Из каких букв РАЗНЫХ состоит, например слово «книга»: к, н, и, г, а — всё просто, 5 разных букв, столько же, сколько и в слове. Но, например, слово «перец» состоит из меньшего количества разных букв: п, е, р, ц. Если бы кто-то загадал слово «перец» в «Виселице», а отгадывающий назвал бы букву «е», пришлось открыть бы сразу две буквы (все смотрели передачу «Поле чудес», там именно так и происходит).

Таким образом, чтобы отгадать слово «перец», нужно отгадать всего четыре разные буквы, а не пять.

Именно поэтому нам нужно проверить, что в good_letters букв столько, сколько РАЗНЫХ букв в загаданном слове.

Метод массива uniq

Для того, чтобы получить массив уникальных букв загаданного слова мы воспользуемся встроенным в Ruby методом массивов uniq. Этот метод просто выкидывает из массива повторяющиеся объекты. В частности, если передать ему массив букв, то из всех повторяющихся букв он оставит только одну.

puts ["a","p","p","l","e"].uniq.to_s

Выведет в консоль

["a", "p", "l", "e"]

С помощь этого метода мы и проверим, совпадает ли число отгаданных букв good_letters.size с числом уникальных букв загаданного слова letters.uniq.size (метод size просто возвращает число элементов в массиве, не будем останавливаться на нём подробно):

if good_letters.uniq.size == letters.uniq.size
  return 1
else
  return 0
end

Мы обещали сами себе, что метод будет возвращать 1 при отгадывании всего слова. Если же пользователь отгадал букву, но игра продолжается, то мы возвращаем 0, тоже как и обещали.

А если пользователь не отгадал букву, то мы добавляем её в неудачные попытки bad_letters и возвращаем -1, опять же, как и обещали. Поэтому в else-части того if-а, который проверял, есть ли введённая буква в загаданном слове, мы пишем:

bad_letters << user_input
return -1

В результате метод check_result будет выглядеть вот так:

def check_result(user_input, letters, good_letters, bad_letters)
  if good_letters.include?(user_input) || bad_letters.include?(user_input)
    return 0
  end

  if letters.include? user_input
    good_letters << user_input

    if good_letters.uniq.size == letters.uniq.size
      return 1
    else
      return 0
    end
  else
    bad_letters << user_input
    return -1
  end
end

Метод print_status — вывод текущего статуса игры

Наконец, мы дошли до последнего метода, который нам надо написать. Он используется в нескольких местах — для отображения промежуточного статуса игры и для вывода результата в конце игры (проигрыш или выигрыш).

1. Название: print_status
2. Параметры: user_input — введённая пользователем буква, letters — массив букв загаданного слова, good_letters — массив отгаданных букв, bad_letters — массив букв, которые пользователь вводил, но которых нет в слове
3. Возвращаемое значение: —

Когда поведение метода нетривиальное, полезно перед его реализацией записать в комментариях перед ним, что этот метод должен делать.

В этом методе нам необходимо:

1. Вывести загаданное слово, отметив в нём прочерками закрытые (ещё не отгаданные буквы), как в «Поле чудес», что-то типа

   _ о л о _ о
   

2. Показать игроку количество ошибок и уже названные буквы, которых нет в слове (те, что были названы и оказались в слове, уже указаны в первом пункте).

3. Если мы совершили семь ошибок, то метод должен написать игроку о том, что тот проиграл и наоборот, если слово отгадано, то этот метод должен поздравить игрока с победой.

Можно приступать к реализации.

Но при реализации первого же пункта мы сталкиваемся с проблемой: как в загаданном слове открыть только отгаданные буквы, а остальные вывести в виде прочерков?

Чтобы изолировать эту проблему и оставить на потом, мы заведём для этой задачи ещё один метод get_word_for_print и будем считать, что он уже написан.

Очевидно, этому методу нужны только два параметра — отгаданные буквы и загаданное слово.

puts "\nСлово: " + get_word_for_print(letters, good_letters)

Теперь нужно указать пользователю, сколько ошибок он допустил и какие буквы не попали в цель.

puts "Ошибки (#{errors}): #{bad_letters.join(", ")}"

Метод массива join?

Метод всех массивов в Ruby join — антагонист для метода split. Он делает прямо противоположное, берёт массив, берёт указанные в качестве параметра разделитель в виде строки, и склеивает элементы массива в строку, вставляя между ними этот самый разделитель.

puts ['аптека','улица','фонарь'].join("-")

выведет на экран

аптека-улица-фонарь

Ну и наконец, нужно вывести результат игры. Если игрок ошибся семь (или каким-то образом больше) раз, то нужно ему сообщить ему, что он проиграл.

Если пользователь ошибся меньше семи раз и отгадал слово — нужно ему сообщить, что он выиграл. Проверку копируем из метода check_result. Если слово ещё не отгадано, мы должны написать, сколько у игрока ещё осталось попыток. В конце концов, наш метод print_status будет выглядеть вот так:

def print_status(letters, good_letters, bad_letters, errors)
  puts "\nСлово: " + get_word_for_print(letters, good_letters)
  puts "Ошибки (#{errors}): #{bad_letters.join(", ")}"

  if errors >= 7
    puts "Вы проиграли :("
  else
    if letters.uniq.size == good_letters.uniq.size
      puts "Поздравляем, вы выиграли!"
    else
      puts "У вас осталось попыток: " + (7 - errors).to_s
    end
  end
end

Метод get_word_for_print — вывод загаданного слова как в «Поле чудес»

Пора отдать долги — написать то, что мы считали написанным. Метод, на самом деле, очень простой. Мы уже знаем всё, что нужно, чтобы его написать.

1. Название: get_word_for_print
2. Параметры: letters — массив букв загаданного слова, good_letters — массив отгаданных букв
3. Возвращаемое значение: строка с загаданным словом, в которой неотгаданные буквы заменены на прочерки

Чтобы «собрать» слово для вывода на экран, мы заведём переменную result и будем добавлять в неё слово по буквам с помощью цикла for-in.

Но если буква не отгадана, то есть, её нет в массиве good_letters (проверять мы будем это с помощью полюбившейся нам команды include?), то мы будем выводить вместо неё прочерк.

Между буквами для красоты и удобства добавим пробелы. Получится как-то так:

def get_word_for_print(letters, good_letters)
  result = ""

  for item in letters do
    if good_letters.include?(item)
      result += item + " "
    else
      result += "__ "
    end
  end

  return result
end

Метод cls — чистка экрана после загадывания слова

Мы написали нашу самую сложную программу за весь курс, с чем я вас и поздравляю.

Однако, если мы попробуем её запустить, то выясним, что отгадывающий может увидеть слово в строчке запуска. Это нам не подходит, поэтому мы напишем ещё один метод cls, который будет вызываться сразу после запуска программы.

Ruby, как и многие другие языки, умеет выполнять команды в консоли. То есть вести себя так, как будто бы программа вместо нас написала что-то в консоли.

Для этого в Ruby есть метод system. Например, после запуска такой программы мы окажемся в папке второго урока.

system "cd c:\rubytut\lesson2"

Мы пока немного знаем системных команд, поэтому не будем останавливаться на этом методе подробно. Скажем только, что вот такая строчка чистит экран в консоли Windows.

system "cls"

А вот такая — во всех остальных операционных системах:

system "clear"

Поэтому наш метод будет выглядеть вот так.

def cls
  system "clear" or system "cls"
end

И не забудьте вызвать этот метод сразу после запуска.

Запуск программы

Осталось перейти в нашу папку в консоли и запустить её:

cd c:\rubytut\lesson10
ruby viselitsa.rb страус

Обратите внимание, что после запуска программа аккуратно стирает всё из консоли, кроме основной информации — слова, количества ошибок и названных букв.

Поиграйтесь с этой замечательной программой, попросите кого-нибудь загадать вам слово и загадайте слово ему.

Обратите внимание, что наша программа пока отличает БОЛЬШИЕ буквы от маленьких. Строго говоря буква, например, «А» и «а» это две разные буквы для Ruby. Также наша первая версия виселицы различает буквы «е» и «ё».

Все эти проблемы мы исправляем в домашних заданиях к этому и следующим урокам.

Итак, дорогие друзья, мы написали сложнейшую для новичка программу.

Нам пришлось использовать много новых инструментов (методы include?, join и split массивов Ruby). Мы научились проектировать сложную программу, разбивать её на методы, а методы выделять в отдельный файл и подключать его с помощью команды require. Написанную в этом уроке программу мы будем использовать в дальнейшем.

‎App Store: Виселица — Угадай слова

Классическая игра на угадывание слов для всей семьи. Подходит для пожилых людей.

Наслаждайтесь игрой в «палача» на мобильном телефоне или планшете! Эта классическая игра-виселица подходит для людей всех возрастов, особенно для тех взрослых, которые хотят попрактиковать свои языковые навыки и улучшить словарный запас. Классическая игра в палача для вашего устройства.

«Палач», также известный как «повешенный» — это классическая игра, в которой нужно угадать слово, выбирая буквы, которые — как вы считаете — могут входить в него.

Игра в «палача» дает возможность выбирать гласные и согласные, чтобы попытаться угадать, какое же загадано слово. При каждой допущенной ошибке к изображению повешенного человечка будет добавляться новый элемент: сначала рисуется виселица, потом голова, тело и, наконец, руки и ноги. Угадайте слово, прежде чем рисунок виселицы будет завершен.

Выигрывает тот, кто сможет угадать загаданное слово до того, как фигура человечка будет нарисована полностью. В противном случае он будет повешен, а игра будет завершена.

Подсказка: используйте сначала гласные, так как есть больше шансов угадать секретную букву (а, е, и, о, у … и т. д.).

ФУНКЦИИ

— Для всех возрастов. Идеальный «палач» для взрослых и пожилых игроков
— Сотни слов и уровней
— Изучение лексики и слов на разных языках
— Простая и забавная игра
— Абсолютно бесплатно
— Привлекательный и яркий дизайн
— Возможность включать или выключать звук.

«Палач» доступен на разных языках для игроков по всему миру: испанский Ahorcado, английский Hangman, португальский Jogo da Forca, французский Le Pendu, итальянский l’impiccato и многие другие!

О TELLMEWOW

Tellmewow — это компания по разработке мобильных игр, специализирующаяся на легкой адаптации и удобстве и простоте использования, что делает их идеальным выбором для пожилых или молодых людей, которые просто хотят время от времени поиграть в несложные игры.

КОНТАКТ

Если у вас есть какие-либо предложения по улучшению игры или вы хотите быть в курсе новых игр, которые мы будем публиковать, подпишитесь на нас в социальных сетях.

@tellmewow

Часть №24: Практические задания по С++ | Задания по С++

  Обновл. 28 Дек 2020  | 

Здесь размещены задания по С++, которые вы можете выполнить. Каждое задание имеет свой уровень сложности. Готовых ответов не будет, поэтому welcome в комментарии.

Easy: Задание №1

Напишите программу, которая принимает следующий массив чисел:

a = [1, 6, 9, 18, 27, 36, 51, 68, 82, 101]

И создает новый массив, в котором есть только четные элементы вышеприведенного массива.

Medium: Задание №2

Есть 2 текстовых файла. В них нужно найти и удалить числа, которые дублируются. Первый файл .txt содержит список всех простых чисел от 0 до 1000, а второй файл .txt содержит список всех «счастливых чисел» от 0 до 1000. (Если вы забыли, то простые числа — это числа, которые имеют 2 делителя: единицу и самого себя, о «счастливых числах» вы можете почитать в Википедии).

Hard: Задание №3

Давайте напишем популярную игру, которая называется «Виселица». В игре вам нужно угадать слово, которое загадала программа, буква за буквой. Игрок угадывает одну букву за раз и может ошибиться только 6 раз (после этого он проигрывает).

Необходимый функционал вашей программы:

   создайте массив слов (например, поместите туда 40 слов) и рандомным образом выберите 1 слово для угадывания;

   программа должна выводить длину всего слова и отображать буквы, которые угадал игрок;

   после каждого неудачного угадывания программа должна сообщить игроку, сколько у него осталось попыток неверно указать букву, прежде чем он проиграет;

   если человек указал букву, которую ранее уже угадывал, и она не дублируется в слове, то не наказывайте его, а просто предоставьте возможность угадать букву еще раз.

Например, компьютер загадал слово INTERESTING:

Добро пожаловать в игру "Виселица"!
Слово - _ _ _ _ _ _ _ _ _ _ _
Угадайте букву: S
Верно - _ _ _ _ _ _ S _ _ _ _
Угадайте следующую букву: F
Неверно! Такой буквы нет, у вас осталось 5 попыток неверно указать букву!
...

import random

user_input = ""

turns = 5

print("Welcome to Advanced Hang Man!")

print("Use your brain to unscramble the word without seeing its order!")

words = ["hello","goolge","czar","gnat","relationship","victor","patric","gir","foo","cheese"]

# Picks a random word from the list and prints the length of it
random_word = (random.choice(words))

random_word_legnth = (len(random_word))

print("Hint! The length of the word is",random_word_legnth)

hold_random_word = [i for i in random_word]    

while turns != 0 and set(right_guess) != set(hold_random_word):

user_input  = input("Please type your guess one letter at a time:")

right_guess = []
wrong_guess = []

#Calculating every input
if len(user_input) == 1 and user_input.isalpha():
    for i in user_input:
        if i in hold_random_word:
            right_guess.append(i)
        else:
            wrong_guess.append(i)

    print("Correct guess", ''.join(right_guess))
    print("Wrong guess", ''.join(wrong_guess))

if len(user_input) == 1 and user_input.isalpha():
    for i in user_input:
        if i in hold_random_word and i not in right_guess:
            right_guess.append(i)
        elif i not in hold_random_word or i not in wrong_guess:
            wrong_guess.append(i)
        elif i in hold_random_word:
            # here user types something that is already typed and is a right_guess
            pass
        else:
            # Types something wrong, that was already typed
            pass

    print("Correct guess", ''.join(right_guess))
    print("Wrong guess", ''.join(wrong_guess))

import random

user_input = ""

turns = 5

print("Welcome to Advanced Hang Man!")

print("Use your brain to unscramble the word without seeing its order!")

words = ["hello","goolge","czar","gnat","relationship","victor","patric","gir","foo","cheese"]

random_word = (random.choice(words))

random_word_legnth = (len(random_word))

print("Hint! The length of the word is",random_word_legnth)

hold_random_word = [i for i in random_word]

# This condition can lead to issues in situations like this - abc and aabbcc [sorry couldn't quickly come up with a good actual example :)]
while turns != 0 and set(right_guess) != set(hold_random_word):

    user_input  = input("Please type your guess one letter at a time:").strip()

    right_guess = []
    wrong_guess = []

    #Calculating every input
    if len(user_input) == 1 and user_input.isalpha():
        # user_input is 1 letter so for i in user_input will execute only once
        # Use the if structure as defined above
        if user_input in hold_random_word:
            right_guess.append(i)
        else:
            # this is missing
            turns -= 1
            wrong_guess.append(i)
        print("Correct guess", ''.join(right_guess))
        print("Wrong guess", ''.join(wrong_guess))
    elif len(user_input) > 1:
        print("Please type only one letter at a time")
    elif not user_input.isalpha():
        print("Please enter only valid English letters")
    else:
        # handle this however you want :)
        pass

    import random
    wordcomp = []
    wordguess = []
#this is a word bank for all puzzles, they are randomly chosen
    word_bank = ['guess this phrase', 'Lagrange', 'foo', 'another phrase to guess']
    # This loop stores each letter in a list, and generates a blank list with correct spaces and blanks for user 
    rand_word = random.randrange(4) 
    for i in word_bank[rand_word]:
        wordcomp.append(i)
        if i == ' ':
            wordguess.append(' ')
        else:
            wordguess.append('__')
    print('I am thinking of a word,' , wordguess , ' it has ', len(wordguess), ' characters total, GOOD LUCK \n')
    wordlist = wordcomp    
    count = 0
    placeletter = 0
    wrongguess = []
    guesscount = 0
    while wordlist != wordguess:
        guess = input('please input a lower case letter within the english alphabet!') ##Check that input is one character, and lower case
        guesscount = guesscount + 1
        # This for loop scans through to see if the letter that was guessed is in the actual puzzle, and places in the correct spot!!
        for t in wordcomp:
            if t == guess:
                wordguess[placeletter] = guess
            placeletter = placeletter + 1
       # This check tells them they already guessed that letter... then makes fun of them
        if guess in wordguess:
            pass
        else:
            wrongguess.append(guess)
            while wrongguess.count(guess) > 1:
                wrongguess.remove(guess)
                print('you guessed the letter ' , guess , ' already, are you person that suffers short term memory loss...')
        print('The word I am thinking of: ' , wordguess)
        print('The letters you have already guess are: ', wrongguess)
        placeletter = 0
    # This tells them they finished the puzzle and the number of guesses it took, if its over 26, it calls them stupid for obvious reasons...
    if guesscount >= 26:
        print('you are an idiot if it took you more than 26 guesses..... now take a minute, sit silently, and think about why you are idiot if it took over 26 guesses... for hangman... where you guess the letters of the alphabet... YOU GET IT, stupid')
    elif guesscount < 26:
        print('Congrats you solved the puzzle, w00t!!')