Portage et modification du solveur de doublets de python2 vers python3.

Portage de Doublet-Solver de python2 vers python3 sur le hub Git. Sert également d'introduction.

Un doublet est un puzzle qui remplace les mots un par un et les relie. Les deux mots donnés sont appelés , les mots du milieu sont appelés et les mots de doublet en doublet sont appelés . Tant que vous avez un mot, l'étape la plus courte pour remplacer une lettre par un mot qui est n différent est n fois.

Il semble que le premier mot, le dernier mot et le << nombre de liens requis >> soient spécifiés. Luis Carroll a été publié dans un magazine hebdomadaire pour femmes à Londres. Il est publié dans le livre "Logic in Wonderland".

La greffe fonctionne des trois manières suivantes. (1) Supprimez import urllib2 car il n'est pas nécessaire. ② Remplacez xrange () par range (). ③ Ajoutez () pour imprimer.

Dans le code ici ① Pour pouvoir prendre des arguments depuis la ligne de commande (2) Pour gérer même les arguments non définis dans le dictionnaire ③ Selon la méthode historique, sortie par au lieu du nombre d'étapes de conversion. ④ Traitez en minuscules Et quatre corrections ont été ajoutées.

Doublet-Solver peut être écrit si simplement en python, n'est-ce pas? surpris.

Il prend également en charge le japonais. Le dictionnaire anglais'dic.txt 'et le dictionnaire japonais'jd.txt' peuvent être trouvés à ici . Pour modifier le dictionnaire, modifiez le nom de fichier ouvert de #dictionary dans le code.

CODE

doublet.py

#!/usr/bin/python3
import sys
from collections import defaultdict

def allwordsoflength(l, all):
  return set([x.lower().strip() for x in all if len(x.lower().strip()) == l])

def wildcard(s, idx):
    return s[:idx] + '?' + s[idx+1:]

def wildcarded(s):
    for idx in range(len(s)):
        yield wildcard(s, idx)

def buildindex(all):
  index = defaultdict(list)
  for w in all:
    for wild in wildcarded(w):
      index[wild.lower()].append(w)
  return index

def oneaway(word, index):
  ret = []
  for w in wildcarded(word):
    ret += index[w]
  return ret

def srch(start, end, all, maxdepth = 100):
  ftree = [(start, 0, [])]
  done = [start]
  alloflen = allwordsoflength(len(start), all)
  index = buildindex(alloflen)

  for e in ftree:
    if e[1] > maxdepth:
      return 'Reached Max Depth.' 

    children = oneaway(e[0], index)
    children = list(set(children) - set(done))

    if children == [] and e == ftree[-1]:
      return 'Search Exhausted.' 

    if end in children:
      return (e[1] , ' '.join(e[2] + [e[0], end]))

    for n in children:
      ftree.append((n, e[1] + 1, e[2] + [e[0]]))

    done = list(set(done) | set(children))


words = [ x for x in open("dic.txt") ] # dictionary
args = sys.argv
a = args[1].lower()
b = args[2].lower()
if len(a)!=len(b):
  print("Length of strings mismatch!")
  exit(1)
words.append(a)
words.append(b)
print (srch(a,b, words))

Exemple d'exécution

$ doublet.py alice maria
(6, 'alice aline cline caine maine marne marie maria')
$ doublet.py hate love
(2, 'hate have lave love')
$ doublet.py work rest
(3, 'work wort wert west rest')
$

$ dbltj.collation py sanji
(2, 'Collation Sanji Onji Oyaji')
$ dbltj.py pomme mikan
(3, 'Pomme pomme pomme mikaku mikaku mikan')
$ dbltj.py Hiruma Yakan
(3, 'Hiruma Hidama Hidan Hikan Yakan')
$ dbltj.py salutation bonjour
(6, 'Salutations Heisei Heiso Heiso Heiso Heyo Bonjour Bonjour')
$