The word ladder game

From Wikipedia, the free encyclopedia

Word ladder (also known as Doublets,^[1] word-links, change-the-word puzzles, paragrams, laddergrams,^[2] or word golf) is a word game invented by Lewis Carroll. A word ladder puzzle begins with two words, and to solve the puzzle one must find a chain of other words to link the two, in which two adjacent words (that is, words in successive steps) differ by one letter.^[3]

History[edit]

Lewis Carroll says that he invented the game on Christmas day in 1877.^[3] Carroll devised the word game for Julia and Ethel Arnold.^[4] The first mention of the game in Carroll’s diary was on March 12, 1878, which he originally called «Word-links», and described as a two-player game.^[3] Carroll published a series of word ladder puzzles and solutions, which he then called «Doublets», in the magazine Vanity Fair, beginning with the March 29, 1879 issue.^[3] Later that year it was made into a book, published by Macmillan and Co.^[5]

J. E. Surrick and L. M. Conant published a book Laddergrams of such puzzles in 1927.^[1]

Vladimir Nabokov alluded to the game using the name «word golf» in the novel Pale Fire, in which the narrator says ‘some of my records are: hate—love in three, lass—male in four, and live—dead in five (with «lend» in the middle).’^[1]

The game was revived in Australia in the 1990s by The Canberra Times as «Stepword».^[6]

Word ladders are often featured in the New York Times crossword puzzle.^[7][8][9]

Rules[edit]

The player is given a start word and an end word. In order to win the game, the player must change the start word into the end word progressively, creating an existing word at each step. Each step consists of a single letter substitution.^[3] For example, the following are the seven shortest solutions to the word ladder puzzle between words «cold» and «warm», using words from Collins Scrabble Words.

COLD	→	CORD	→	CORM	→	WORM	→	WARM
COLD	→	CORD	→	CARD	→	WARD	→	WARM
COLD	→	CORD	→	WORD	→	WARD	→	WARM
COLD	→	CORD	→	WORD	→	WORM	→	WARM
COLD	→	WOLD	→	WORD	→	WORM	→	WARM
COLD	→	WOLD	→	WORD	→	WARD	→	WARM
COLD	→	WOLD	→	WALD	→	WARD	→	WARM

As each step changes only one letter, the number of steps must be at least the Hamming distance between the two words – four in the above example.^[10] Lewis Carroll’s example has an extra fifth step as the third letter changes twice.

Often word ladder puzzles are created where the end word has some kind of relationship with the start word (synonymous, antonymous, semantic…). This was also the way the game was originally devised by Lewis Carroll when it first appeared in Vanity Fair.

Some variations also allow the player to add or remove letters, and to rearrange the same letters into a different order (an anagram).

Five-letter word ladders[edit]

Donald Knuth used a computer to study word ladders of five-letter words. He felt that three and four were too easy and six was too hard.^[3] Knuth used a collection of 5,757 common English five-letter words, excluding proper nouns. He wrote a program which showed the steps connecting any two words, or noted that no connection was possible.^[3] He found that many word pairs were connected, but that 671 words were not connected to any other word, i.e ‘had no neighbours’, as he put it. He called these words «aloof», and noted amusingly that «aloof» is itself such a word.^[3]

See also[edit]

• Paronym

Notes[edit]

External links[edit]

• The longest word ladder puzzle ever Computer analysis to find long word ladders
• Doublets, a word puzzle, by Lewis Carroll
• An on-line word-ladder solver for Afrikaans, English, Esperanto, German and Spanish (requires login)
• An on-line word-ladder solver for English
• Lewis Carroll Resources On-line facility giving Carroll’s original puzzles with hints and solutions and tool to help solve and compile puzzles

Word Ladder (также известный как Doublets, словесные ссылки, головоломки со сменой слов, параграммы, лестничные диаграммы или слово гольф ) словесная игра, изобретенная Льюисом Кэрроллом. Головоломка со словесной лестницей начинается с двух слов, и для решения головоломки нужно найти цепочку других слов, чтобы связать эти два слова, в которой два соседних слова (то есть слова в последовательных шагах) отличаются на одну букву.

Содержание

• 1 История
• 2 Правила
• 3 Пятибуквенные цепочки слов
• 4 См. Также
• 5 Примечания
• 6 Внешние ссылки

История

Льюис Кэрролл говорит, что он изобрел игру на Рождество в 1877 году. Кэрролл разработал словесную игру для Джулии и Этель Арнольд. Первое упоминание об игре в дневнике Кэрролла было 12 марта 1878 года, которое он первоначально назвал «Word-links» и описал как игру для двух игроков. Кэрролл опубликовал в журнале Vanity Fair, начиная с выпуска от 29 марта 1879 года, серию головоломок и решений со словесной лестницей, которые он затем назвал «Дублетами». Позже в том же году он был преобразован в книгу, опубликованную Macmillan and Co.

J. Э. Суррик и Л.М. Конант опубликовали книгу Ладдерграммы таких головоломок в 1927 году.

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

Игра была возрождена в Австралии в 1990-х годах издательством The Canberra Times как «Stepword».

Словарные лестницы часто используются в кроссвордах New York Times.

Правила

Игроку дается начальное и конечное слово. Чтобы выиграть игру, игрок должен постепенно менять начальное слово на конечное, создавая существующее слово на каждом шаге. Каждый шаг состоит из замены одной буквы. Например, ниже приведены семь кратчайших решений головоломки со словом «лестница» между словами «холодный» и «теплый» с использованием слов из Collins Scrabble Words.

COLD → CO R D → C A RD → W ARD → WAR M

COLD → CO R D → COR M→ WORM → W ARM

COLD → CO R D → W ORD → W A RD → WAR M

COLD → CO R D → W ORD → WOR M → W ARM

COLD → W OLD → W A LD → WA R D → WAR M

COLD → W СТАРЫЙ → WO R D → W A RD → WAR M

ХОЛОДНЫЙ → W СТАРЫЙ → WO R D → WOR M → W ARM

Часто головоломки со словесной лестницей создаются, где конечное слово имеет какую-то связь с начальным словом (синоним, антоним, смысловой…). Именно так игра была первоначально разработана Льюисом Кэрроллом, когда она впервые появилась в Vanity Fair.

Некоторые варианты также позволяют игроку добавлять или удалять буквы и переставлять те же буквы в другом порядке (анаграмма ).

Пятибуквенные лестницы слов

Дональд Кнут использовал компьютер для изучения словарных лестниц пятибуквенных слов. Он считал, что лестницы из трехбуквенных слов были слишком легкими (хотя Льюис Кэрролл обнаружил, что для превращения APE в MAN требуется шесть ступеней), и что лестницы из шести букв были менее интересны, поскольку относительно небольшое количество пар шестибуквенных слов могло быть связано со словесной лестницей. Кнут использовал фиксированный набор из 5 757 наиболее распространенных английских пятибуквенных слов, за исключением существительных. Он точно определил, когда между двумя словами из сборника возникла словная лестница, через другие слова из сборника. Кнут обнаружил, что большинство слов связаны друг с другом, и он также обнаружил, что 671 слово из сборника не образуют словесную лестницу с другими словами. Он назвал эти слова «отчужденный», потому что «отчужденный» сам по себе является примером такого слова.

См. Также

• Пароним

Примечания

1. ^ Огард, Тони Оксфорд. Руководство по играм в слова Оксфордского университета Press, 2-е изд. 2003 с.216 ISBN 0-19-866264-5
2. ^«Лестничные диаграммы». Лестничные диаграммы. Проверено 5 марта 2016 г.
3. ^ Дина Хаунспергер, Стивен Кеннеди (31 июля 2006 г.). Край вселенной: празднование десяти лет математических горизонтов. Математическая ассоциация Америки. п. 22. ISBN 0-88385-555-0 .
4. ^Коэн, Мортон Н. (09.04.2015). Льюис Кэрролл: Биография. Пан Макмиллан. ISBN 978-1-4472-8614-1 .
5. ^Чарльз Латвидж Доджсон (1879). Дублеты, словесная головоломка Льюиса Кэрролла. Макмиллан и Ко.
6. ^«Холодная жара». Канберра Таймс. 65(20, 392). Австралийская столичная территория, Австралия. 10 февраля 1991 г. с. 3. Получено 18 сентября 2017 г. — через Национальную библиотеку Австралии.
7. ^Амлен, Деб (21.02.2017). «Достаточно». Нью-Йорк Таймс. ISSN 0362-4331. Проверено 22 августа 2020 г.
8. ^Амлен, Деб (13 июня 2018 г.). «Путь к записи». Нью-Йорк Таймс. ISSN 0362-4331. Проверено 22 августа 2020 г.
9. ^Гаффни, Томас (19 июня 2013 г.). «Поднимитесь по лестнице». Блог игры слов. Проверено 22 августа 2020 г.

Внешние ссылки

• Самая длинная словесная головоломка в истории Компьютерный анализ для поиска длинных словесных лестниц
• Дублеты, словесная головоломка, Льюис Кэрролл
• Он-лайн слово-лестница для африкаанс, английского, эсперанто, немецкого и испанского (требуется вход в систему)
• Он-лайн слово-лестница для английского языка
• Ресурсы Льюиса Кэрролла Он-лайн средство, дающее оригинальные головоломки Кэрролла с подсказками решения и инструменты для решения и составления головоломок

A word ladder puzzle has two words in the ladder, one at the bottom and one at the top. You must form a sequence of words (a word ladder). On every step of the ladder you must place a new word that only differs one letter than the previous word.

It is easy to create your onw printable word ladder puzzle with this generator. Word ladder puzzles are fun to do, but difficult to make without the help of a program or website. Luckily you can create easily your own word ladder puzzle or load a puzzle from the list. The rules of the game are very simple. The game starts with two words, a begin- and an end word. The students need to change the begin word into the end word by changing one letter of the word at every step. This can be rather difficult. You can help your students to reveil one or more letters of the words in the word ladder. Click in the preview to show or hide letters in the puzzle.

How to use the word ladder generator

First select the word length. Then type the first word on the ladder or click on the ‘pick a word’ button to select a word from the dictionary. After this you can type or select the next word. It will be easier to use the ‘pick a word’ button, because you will get all possible words you can use. The webpage will check if the word you typed or choose is valid. If the word on the ladder is not valid, then the background will be red.

When you don’t have the time to make your own puzzle, you can choose one of the many puzzles in the list.

Change a word into another by changing only only one character at a time. All intermediate words should be contained in a dictionary.

This problem is pretty simple if we can choose a proper data structure. Let’s begin with a simple example. Say, we have a dictionary of words, the word to navigate from. and the word we need to navigate into.

Dictionary: {“DOG”, “COT”, “COG”, “FOG”, “DOT”}, source: “FOG”, and destination: “COT”

We can navigate from “FOG” by changing ‘F’ into [‘A’ – ‘Z’] except ‘F’. So, there will be 25 different transformed words. But we are only allowed to use only those exist in the dictionary. In this case we have 2 words : {“COG”, “DOG”}

If one of the transformed word matches with the target then our search was successful. If not then we can apply the same navigation procedure on this valid transformed word. If none of the valid transformed word lead us to the solution then we need to back track and follow the same procedure for the next character position. If the procedure didn’t find the target word then we fail the search.

For example: ‘COG’ can to transformed into ‘COT’ by changing character in 3rd position (‘G’ to ‘T’).  So, the path was: ‘FOG’ –> ‘COG’ –> ‘COT’.

Now, which data structure and algorithm should we use? It sounds like a breadth first search , right? Exactly! We can use a queue to perform BFS. Below is a O(n) solution for this problem using LinkedList as for queue operation.

public static boolean isNavigable(final String src, final String dst, final Set<String> dictionary) {
    if (src.length() != dst.length()) {
        return false;
    }
    if (src.equals(dst)) {
        return true;
    }

    dictionary.remove(src);

    final LinkedList<String> q = new LinkedList<String>();
    q.add(src);

    while (!q.isEmpty()) {
        final String intermediate = q.remove();

        for (int i = 0; i < intermediate.length(); i++) {
        	char[] candidateChars = intermediate.toCharArray();
            for (char j = 'A'; j < 'Z'; j++) {
                candidateChars[i] = j;

                final String candidate = new String(candidateChars);

                if (candidate.equals(dst)) {
                    System.out.print("-->" + candidate);
                    return true;
                } else if (dictionary.contains(candidate)) {
                    dictionary.remove(candidate);
                    q.add(candidate);
                    System.out.print("-->" + candidate);
                }
            }
        }
    }

    return false;
}

How to find all possible shortest transformations?

For example, Dictionary = [“hot”, “dot”, “dog”, “lot”, “log”, “lob”, “cob”];

Then, to navigate from src = “hit” to dest = “cog”, we can have 3 possible paths as follows –

                    hit
                     |
                    hot
                 /       
              dot         lot
               |        /     
              dog      log    lob
               |        |      |
              cog      cog    cob
                               |
                              cog

But the shortest paths are [hit–>hot–>dot–>dog–>cog, hit–>hot–>lot–>log–>cog] of total 4 transformations. How to extend our previous solution to achieve this?

Note that, while we are traversing in BFS we can maintain the total numbers of transformations. We can use this as the length of a path from the source word. If current transformation (i.e. a candidate word that presents in dictionary) was previously generated by some other intermediate word then we have two choice – either take this path if it leads to a shorter path to solution then the previous path or don’t take current path and discard this transformation. We can easily do this using Dijkstra’s shortest path invariant where we only update a neighbor path len when pathLen[mine]+1 <= pathLen[neighbor]. Also, we each time we select a transformed candidate word to visit , we will update its parent to the the intermediate word it is transformed from so that later we can reconstruct the path.

Below is an implementation of the above approach using O(n) space and O(n) time.

public static List<List<String>> wordLadderAll(Set<String> dictionary, String src, String dst){
	if(src == null || dst == null || dictionary == null || src.isEmpty() || dst.isEmpty() || dictionary.isEmpty()){
		return Collections.EMPTY_LIST;
	}
	//Queue to traverse in BFS
	Queue<String> queue = new ArrayDeque<String>();
	//path from a node to its parent along the BFS traversal
	Map<String, String> parent = new HashMap<String, String>();
	//level of a word appeared in the DAG
	Map<String, Integer> pathLen = new HashMap<String, Integer>();
	//min length path so far
	int minLen = Integer.MAX_VALUE;
	//resulting shortest paths
	List<List<String>> paths =  new ArrayList<>();
	//resulting shortest path last nodes
	Set<String> shortestPathLeaves = new HashSet<String>();
	
	//add source to queue to start traversing
	queue.add(src);
	pathLen.put(src, 0);
	while(!queue.isEmpty()){
		String intermediate = queue.poll();
		//we already have a shortest path, so discard this longer path
		if(pathLen.get(intermediate) >= minLen){
			continue;
		}
		
		//BFS to each possible 1 edit distance neighbors in dictionary
		for(int i = 0; i<intermediate.length(); i++){
			char[] candidateChars = intermediate.toCharArray();
			//all possible words with current character variations
			for(char c = 'a'; c < 'z'; c++){
				candidateChars[i] = c;
				String candidate = new String(candidateChars);
				
				if(!pathLen.containsKey(candidate)){
					pathLen.put(candidate, Integer.MAX_VALUE);
				}
				//Dijktra's shortest path formullae
				if(pathLen.get(intermediate)+1 > pathLen.get(candidate)){
					continue;
				}
				
				//if we reach a solution, add it to solution
				if(candidate.equals(dst)){
					shortestPathLeaves.add(intermediate);
					minLen = Math.min(minLen, pathLen.get(intermediate)+1);
				}
				//otherwise if this intermediate word is present in dictionary then 
				//add it as children and update the path len
				else if(dictionary.contains(candidate)){
					parent.put(candidate, intermediate);
					pathLen.put(candidate, pathLen.get(intermediate)+1);
					queue.add(candidate);
				}
			}
		}
	}
	
	//Add all paths to result set
	for(String path : shortestPathLeaves){
		paths.add(getPath(parent, path, src, dst));
	}
	
	return paths;
}

private static List<String> getPath(Map<String, String> parentMap, String leaf, String src, String dst){
	List<String> path = new ArrayList<String>();
	
	String node = leaf;
	path.add(dst);
	path.add(0, leaf);
	while(parentMap.get(node) != null && parentMap.get(node) != src){
		node = parentMap.get(node);
		path.add(0, node);
	}
	path.add(0, src);
	
	return path;
}