numerology

package
v1.0.2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 27, 2021 License: Apache-2.0, Apache-2.0 Imports: 27 Imported by: 0

Documentation

Overview

Package numerology provides methods to calculate various numerological numbers from both names and dates. It can calculate Expression/Destiny, Soul's Urge/Heart's Desire, Personality, Hidden Passion, Karmic Lesson, and Life Path numbers using both Pythagorean and Chaldean number systems. It allows of for various methods of calculation with custom Master Numbers and the option to reduce each word or only whole names. It also provides summaries of the steps of the calculation process that can be used to display how the calculations were derived.

The truly unique aspect of this package is also provides methods to search for either names or dates that satisfy various numerological criteria. This is useful if one is trying to find a name for a baby or a wedding date that has the desirable numerological properties. The way that it does this is using a precomputed table of names with corresponding numerological properties. This allows the table to be searched for specific names that satisfy given constraints. This method is surprisingly efficient. A database of 100,000 names with all the necessary pre-calculations is only 13.5 MB and searches take only hundredths of a second.

Index

Examples

Constants

View Source 
const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
)

Days of the week values for use in date searches. Values are similar to time.Weekday.

View Source 
const (
	CommonSort   = "common"
	UncommonSort = "uncommon"
	RandomSort   = "random"
)

Constants that represent the name sorting methods.

View Source 
const (
	Male   = Gender('M')
	Female = Gender('F')
	Both   = Gender('B')
)

Gender constants for use when searching for names of a particular gender.

Variables

View Source 
var AcceptableUnknownCharacters = regexp.MustCompile("[-\\s.']")

AcceptableUnknownCharacters is a regexp that matches characters that should be considered acceptable in names. This includes dashes (Hernandez-Johnson), periods (Jr.), and white space characters. This is used before Marshaling to JSON. Replace this variable if a different set of AcceptableUnknownCharacters is needed.

View Source 
var Chaldean = NumberSystem{
	Name: "Chaldean",
	NumberMapping: map[int32]int{
		'a': 1, 'i': 1, 'j': 1, 'q': 1, 'y': 1,
		'b': 2, 'k': 2, 'r': 2,
		'c': 3, 'g': 3, 'l': 3, 's': 3,
		'd': 4, 'm': 4, 't': 4,
		'e': 5, 'h': 5, 'n': 5, 'x': 5,
		'u': 6, 'v': 6, 'w': 6,
		'o': 7, 'z': 7,
		'f': 8, 'p': 8,
		'0': 0, '1': 1, '2': 2, '3': 3, '4': 4,
		'5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8},
}

The conversion table for the Chaldean number system.

View Source 
var DB *gorm.DB

DB holds the database connection used of name searches. Gorm is used which means that only SQLite, MySQL, and PostgreSQL are supported out-of-the-box. Variable is exposed in case someone wanted to hack on other database solutions for a project.

View Source 
var Pythagorean = NumberSystem{
	Name: "Pythagorean",
	NumberMapping: map[int32]int{
		'a': 1, 'j': 1, 's': 1,
		'b': 2, 'k': 2, 't': 2,
		'c': 3, 'l': 3, 'u': 3,
		'd': 4, 'm': 4, 'v': 4,
		'e': 5, 'n': 5, 'w': 5,
		'f': 6, 'o': 6, 'x': 6,
		'g': 7, 'p': 7, 'y': 7,
		'h': 8, 'q': 8, 'z': 8,
		'i': 9, 'r': 9,
		'0': 0, '1': 1, '2': 2,
		'3': 3, '4': 4, '5': 5,
		'6': 6, '7': 7, '8': 8,
		'9': 9,
		' ': 0, '.': 0, '-': 0,
	},
	ValidNumbers: []int{1, 2, 3, 4, 5, 6, 7, 8, 9},
}

The conversion table for the Pythagorean number system.

Functions

func CreateDatabase 

func CreateDatabase(dsn string, baseDir string) error

CreateDatabase function creates and populates the database table with the pre-populated numerological calculations. The argument dsn is the connection string for the database that will utilized. The argument baseDir is the directory where the CSV files are stored that contain the names that will populate the database. Each folder in the baseDir becomes a table in the database. This allows for multiple name sources.

The format for the CSV files is name, gender, popularity with no header. Gender is just a letter 'M' for male or 'F' female. Popularity is used to determine the sort order of the names. Each reoccurrence of the same name aggregates the popularity. 

john,M,10000
sara,F,9000
jack,M,8000

func NewDate 

func NewDate(year, month, day int) (newDate time.Time)

NewDate is a wrapper to easily create a time.Time variable without entering hour, min, sec, nsec, loc since they are not important for any date calculation. Note: Golang time.Time always has a timezone. UTC is used, and the hour used is midday (12:00). This should help avoid situations where time.Time gets converted to a new time zone accidentally so the date isn't inadvertently changed.

func ToAscii 

func ToAscii(s string) string

ToAscii transliterates a unicode string to ascii string and removes extraneous newline chars and whitespace. This conversion is not 100% due to complexities of language. See this article by Sean M. Burke for more information. https://interglacial.com/~sburke/tpj/as_html/tpj22.html

Types

type Breakdown 

type Breakdown struct {
	// Value contains the reduced numerological value of the name.
	Value int `json:"value"`

	// ReduceSteps contains the conversion at each step until the final number.
	ReduceSteps []int `json:"reduce_steps"`

	// LetterValues shows the numerological value of each letter in the name.
	LetterValues []letterValue `json:"letter_values"`
}

Breakdown contains information from the conversion of a name to its numerological equivalent.

type DateNumerology 

type DateNumerology struct {
	// Date is either the date to use to calculate numerological values or the date
	// used to start searches.
	Date time.Time

	// Pointers are used so that these options can be shared amongst a number of
	// DateNumerology objects.
	*DateOpts
	*DateSearchOpts
}

DateNumerology stores required information to calculate the numerological values of dates.

func Date 

func Date(date time.Time, masterNumbers []int) (result DateNumerology)

Date returns a DateNumerology object that can be used to calculate numerological values or search for dates with numerological significance.

func Dates 

func Dates(dates []time.Time, masterNumbers []int) (results []DateNumerology)

Dates returns a slice of DateNumerology objects that can be used to calculate numerological values or search for dates with numerological significance.

func (DateNumerology) Event 

func (d DateNumerology) Event() (event NumerologicalResult)

Event calculates the numerological number for a given date. Unlike LifePath calculations, Master Numbers are always reduced. This calculation is generally used for events like weddings or other special occasions.

Example 
date := NewDate(2021, 1, 5)
result := Date(date, []int{11, 22, 33}).Event()
fmt.Printf("%v - %v", date.Format("Monday, January 2, 2006"), result.Value)

Output:

Tuesday, January 5, 2021 - 2

func (DateNumerology) LifePath 

func (d DateNumerology) LifePath() (lifePath NumerologicalResult)

LifePath calculates the numerological number for a given date, but stops reducing at Master Numbers. This calculation is generally used with one's date of birth.

Example 
date := NewDate(2021, 1, 5)
result := Date(date, []int{11, 22, 33}).LifePath()
fmt.Printf("%v - %v", date.Format("Monday, January 2, 2006"), result.Value)

Output:

Tuesday, January 5, 2021 - 11

func (DateNumerology) Search 

func (d DateNumerology) Search(opts DateSearchOpts) (searchResults []DateNumerology, offset int64)

Search executes a forward looking search of dates to find ones that satisfy given numerological criteria. The argument opts contains the searching criteria. Offset in the output is the offset to be used to get the next batch of results using the same query. If offset is 0 then there are no more results.

Example 
opts := DateSearchOpts{
	Count:         5,
	Match:         []int{1},
	MonthsForward: 12,
	Dow:           []int{int(time.Monday), int(time.Friday), int(time.Saturday)},
	LifePath:      false,
}
date := NewDate(2021, 1, 1)
results, _ := Date(date, []int{11, 22, 33}).Search(opts)

table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"", "Date", "#"})
for i, result := range results {
	table.Append([]string{fmt.Sprintf("%v", i+1), result.Date.Format("Monday, January 2, 2006"), fmt.Sprintf("%v", result.Event().Value)})
}
table.Render()

Output:

+---+---------------------------+---+
|   |           DATE            | # |
+---+---------------------------+---+
| 1 | Monday, January 4, 2021   | 1 |
| 2 | Friday, January 22, 2021  | 1 |
| 3 | Friday, February 12, 2021 | 1 |
| 4 | Saturday, March 20, 2021  | 1 |
| 5 | Monday, March 29, 2021    | 1 |
+---+---------------------------+---+

type DateOpts 

type DateOpts struct {
	// MasterNumbers are two (or more) digit numbers that should not be reduced because they are
	// considered to have special numerological value. The most commonly considered master numbers
	// are repeating digits. ex 11, 22, 33, 44, 55
	MasterNumbers []int `json:"master_numbers"`
}

DateOpts contains the options that are required in order to get a numerological value from a date.

type DateSearchOpts 

type DateSearchOpts struct {
	// Count is the number of results to return.
	Count int `json:"count,omitempty"`

	// Offset is used to page through the search results. Its main use is with an web service.
	Offset int `json:"offset,omitempty"`

	// Match is a slice of ints that are the numerological values that we want to find.
	Match []int `json:"match,omitempty"`

	// MonthsForward is the number of months in which to search. Usually one is trying to find a date within
	// some reasonable time frame; like for a wedding or event.
	MonthsForward int `json:"months_forward,omitempty"`

	// Dow, or Days of the Week, limits the results to ones that fall on certain days.
	// 0=Sun 1=Mon 2=Tue 3=Wed 4=Thu 5=Fri 6=Sat
	Dow []int `json:"dow,omitempty"`

	// LifePath is generally used with ones date of birth. If false, then Master Numbers are ignored
	// for the calculation.
	LifePath bool `json:"life_path"`
}

DateSearchOpts contains the search options specific to searching for numerological dates.

type Gender 

type Gender rune

Gender is custom type that is needed so we can customize the Marshaling and Unmarshaling.

func (Gender) MarshalJSON 

func (g Gender) MarshalJSON() ([]byte, error)

MarshalJSON creates a json string of for Gender.

func (*Gender) UnmarshalJSON 

func (g *Gender) UnmarshalJSON(value []byte) error

UnmarshalJSON will come in as a string, but we want to convert it to a rune. Only accepted options are (M)ale, (F)emale, and (B)oth. If the option is not one of these then it defaults to (B)oth.

type HiddenPassionResults 

type HiddenPassionResults struct {
	// Numbers is a slice of int of all the numbers that have the highest or equally highest count.
	Numbers []int `json:"numbers"`

	// MaxCount is the count of the highest number(s).
	MaxCount int `json:"max_count"`
}

HiddenPassionResults packages the key information from the Numbers function.

type KarmicLessonResults 

type KarmicLessonResults struct {
	// Numbers is a slice of int of all the numbers that are not found in the Lookup.
	Numbers []int `json:"karmic_lessons"`
}

KarmicLessonResults packages the key information from the Numbers function.

type NameNumerology 

type NameNumerology struct {
	Name string
	*NameOpts
	*NameSearchOpts
	// contains filtered or unexported fields
}

NameNumerology is used as a struct to store the name and configuration information that is required to calculate the numerological values of names.

func Name 

func Name(name string, numberSystem NumberSystem, masterNumbers []int, reduceWords bool) (result NameNumerology)

Name calculates various numerological numbers from a given name. Argument numberSystem indicates what calculation method is used (Pythagorean or Chaldean). Argument reduceWords determines whether each part of a name is reduced independently before being merged in a final number.

func Names 

func Names(names []string, numberSystem NumberSystem, masterNumbers []int, reduceWords bool) (results []NameNumerology)

Names calculates various numerological numbers from a list of given names. Argument numberSystem indicates what calculation method is used (Pythagorean or Chaldean). Argument reduceWords determines whether each part of a name is reduced independently before being merged in a final number.

func (NameNumerology) Consonants 

func (n NameNumerology) Consonants() (result NumerologicalResult)

Consonants contains the numerological calculations done using just the consonant letters of the given name. Sometimes referred to as Personality number.

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Consonants().Debug())

Output:

K e v i n
2 · 4 · 5 = 11
N o r w o o d
5 · 9 5 · · 4 = 23 = 5
B a c o n
2 · 3 · 5 = 10 = 1
Reduce: 17 = 8

func (*NameNumerology) Counts 

func (n *NameNumerology) Counts() (counts map[int32]int)

Counts returns a map of each numerological value and how many times it appears in the name.

func (NameNumerology) Destiny 

func (n NameNumerology) Destiny() (destiny NumerologicalResult)

Destiny is an alias for Full().

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Destiny().Debug())

Output:

K e v i n
2 5 4 9 5 = 25 = 7
N o r w o o d
5 6 9 5 6 6 4 = 41 = 5
B a c o n
2 1 3 6 5 = 17 = 8
Reduce: 20 = 2

func (NameNumerology) Expression 

func (n NameNumerology) Expression() (expression NumerologicalResult)

Expression is an alias for Full().

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Expression().Debug())

Output:

K e v i n
2 5 4 9 5 = 25 = 7
N o r w o o d
5 6 9 5 6 6 4 = 41 = 5
B a c o n
2 1 3 6 5 = 17 = 8
Reduce: 20 = 2

func (NameNumerology) Full 

func (n NameNumerology) Full() (result NumerologicalResult)

Full contains the numerological calculations done using all the letters of the given name. Sometimes referred to as the Destiny or Expression number.

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Full().Debug())

Output:

K e v i n
2 5 4 9 5 = 25 = 7
N o r w o o d
5 6 9 5 6 6 4 = 41 = 5
B a c o n
2 1 3 6 5 = 17 = 8
Reduce: 20 = 2

func (NameNumerology) HeartsDesire 

func (n NameNumerology) HeartsDesire() (heartsDesire NumerologicalResult)

HeartsDesire is an alias for Vowels().

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.HeartsDesire().Debug())

Output:

K e v i n
· 5 · 9 · = 14 = 5
N o r w o o d
· 6 · · 6 6 · = 18 = 9
B a c o n
· 1 · 6 · = 7
Reduce: 21 = 3

func (NameNumerology) HiddenPassions 

func (n NameNumerology) HiddenPassions() (result HiddenPassionResults)

HiddenPassions contains the calculation of the numerological number(s) that repeat the most in the given name.

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, false)
fmt.Printf("%v (%v)", result.Name, result.HiddenPassions().Numbers)

Output:

Kevin Norwood Bacon ([5])

func (NameNumerology) KarmicLessons 

func (n NameNumerology) KarmicLessons() (result KarmicLessonResults)

KarmicLessons contains the calculation of the numerological number(s) that do not appear in the given name.

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, false)
fmt.Printf("%v (%v)", result.Name, result.KarmicLessons().Numbers)

Output:

Kevin Norwood Bacon ([7 8])

func (NameNumerology) Personality 

func (n NameNumerology) Personality() (personality NumerologicalResult)

Personality is an alias for Consonants().

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Personality().Debug())

Output:

K e v i n
2 · 4 · 5 = 11
N o r w o o d
5 · 9 5 · · 4 = 23 = 5
B a c o n
2 · 3 · 5 = 10 = 1
Reduce: 17 = 8

func (NameNumerology) Search 

func (n NameNumerology) Search(opts NameSearchOpts) (results []NameNumerology, offset int64, err error)

Search searches the name database for names that satisfy given numerological criteria.

Example 
opts := NameSearchOpts{
	Count:      10,
	Dictionary: "usa_census",
	Gender:     'M',
	Sort:       "common",
	Full:       []int{3, 5, 8},
	Database:   "sqlite://file::memory:?cache=shared",
}
results, _, err := Name("Abraham ? Lincoln", Chaldean, []int{11, 22, 33}, true).Search(opts)
if err != nil {
	log.Fatal(err)
}
table := tablewriter.NewWriter(os.Stdout)
table.SetHeader([]string{"", "Name", "#"})
for i, result := range results {
	table.Append([]string{fmt.Sprintf("%v", i+1), result.Name, fmt.Sprintf("%v", result.Full().Value)})
}
table.Render()

Output:

+----+-------------------------+---+
|    |          NAME           | # |
+----+-------------------------+---+
|  1 | Abraham James Lincoln   | 3 |
|  2 | Abraham David Lincoln   | 5 |
|  3 | Abraham William Lincoln | 8 |
|  4 | Abraham Daniel Lincoln  | 8 |
|  5 | Abraham Joshua Lincoln  | 3 |
|  6 | Abraham Anthony Lincoln | 8 |
|  7 | Abraham Andrew Lincoln  | 3 |
|  8 | Abraham Kevin Lincoln   | 8 |
|  9 | Abraham Steven Lincoln  | 8 |
| 10 | Abraham Jacob Lincoln   | 3 |
+----+-------------------------+---+

func (NameNumerology) SoulsUrge 

func (n NameNumerology) SoulsUrge() (soulsUrge NumerologicalResult)

SoulsUrge is an alias for Vowels().

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.SoulsUrge().Debug())

Output:

K e v i n
· 5 · 9 · = 14 = 5
N o r w o o d
· 6 · · 6 6 · = 18 = 9
B a c o n
· 1 · 6 · = 7
Reduce: 21 = 3

func (*NameNumerology) UnknownCharacters 

func (n *NameNumerology) UnknownCharacters() (unknowns []string)

UnknownCharacters is a set of characters that cannot be converted to numerological values. They are ignored in calculations.

func (NameNumerology) Vowels 

func (n NameNumerology) Vowels() (result NumerologicalResult)

Vowels contains the numerological calculations done using just the vowel letters of the given name. Sometimes referred to as Heart's Desire or Soul's Urge number.

Example 
result := Name("Kevin Norwood Bacon", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.Vowels().Debug())

Output:

K e v i n
· 5 · 9 · = 14 = 5
N o r w o o d
· 6 · · 6 6 · = 18 = 9
B a c o n
· 1 · 6 · = 7
Reduce: 21 = 3

type NameOpts 

type NameOpts struct {
	// NumberSystem is the numerological number system to use to convert the name into numbers.
	NumberSystem NumberSystem `json:"number_system"`

	// MasterNumbers are two (or more) digit numbers that should not be reduced because they are
	// considered to have special numerological value. The most commonly considered master numbers
	// are repeating digits. ex 11, 22, 33, 44, 55
	MasterNumbers []int `json:"master_numbers"`

	// ReduceWords determines whether a name is first separated into individual names that are
	// reduced independently before summing together and reduce a final time or if the whole
	// name is reduced all at once.
	ReduceWords bool `json:"reduce_words"`
}

NameOpts contains the options that are required in order to get a numerological value from a name.

type NameSearchOpts 

type NameSearchOpts struct {
	// Count is the number of results to return.
	Count int `json:"count,omitempty"`

	// Offset is used to page through the search results. Its main use is with an web service.
	Offset int `json:"offset,omitempty"`

	// Seed is used to generate random search results for names. Seed is necessary in order to page through
	// random results by maintaining the random order.
	Seed int64 `json:"seed,omitempty"`

	// Database is the DSN string that connects to the database that has the precalculated numerological names.
	Database string `json:"db,omitempty"`

	// Dictionary is the name of the database table to search.
	Dictionary string `json:"dictionary,omitempty"`

	// Gender is a filter to limit search results to names that are generally (m)ale, (f)emale, or (b)oth.
	Gender Gender `json:"gender,omitempty"`

	// Sort is the method of sorting used when return names. The options are "common", "uncommon", and "random".
	Sort string `json:"sort,omitempty"`

	// Full is the numerological numbers you want to search for that are calculated with all the letters of the given
	// name. Often referred to as "Destiny" or "Expression" number, Full was chosen in order to avoid favoring
	// one particular designation, and to make it clear what calculation is being performing.
	Full []int `json:"full,omitempty"`

	// Vowels is the numerological numbers you want to search for that are calculated with just the vowel letters of
	// the given name. Often referred to as "Soul's Urge" or "Heart's Desire" number, Vowels was chosen in order to
	// avoid favoring one particular designation, and to make it clear what calculation is being performing.
	//
	// This calculation is complicated by the fact that the letter "Y" sometimes acts like a vowel. Because the
	// database is precomputed, a consistent set rules need to be used in order to get consistent results. The
	// method used will generally be correct, but names with "Y" in them are probably the least reliable results.
	Vowels []int `json:"vowels,omitempty"`

	// Consonants is the numerological numbers you want to search for that are calculated with just the consonant
	// letters of the given name. Sometimes referred to as "Personality", Consonants was chosen in order to avoid
	// favoring one particular designation, and to make it clear what calculation is being performing.
	//
	// This calculation is complicated by the fact that the letter "Y" sometimes acts like a vowel. Because the
	// database is precomputed, a consistent set rules need to be used in order to get consistent results. The
	// method used will generally be correct, but names with "Y" in them are probably the least reliable results.
	Consonants []int `json:"consonants,omitempty"`

	// HiddenPassions contains the numerological number(s) that occur the most frequently in the name.
	// Positive and  negative numbers can be used. Positive numbers are inclusive; they ensure that
	// number will exist in the final grouping. Negative numbers are exclusive, they exclude that number from
	// existing in the final grouping.
	HiddenPassions []int `json:"hidden_passions,omitempty"`

	// KarmicLessons contains the numerological number(s) that do not appear at all in the name.
	// Positive and  negative numbers can be used. Positive numbers are inclusive; they ensure that
	// number will exist in the final grouping. Negative numbers are exclusive, they exclude that number from
	// existing in the final grouping.
	KarmicLessons []int `json:"karmic_lessons,omitempty"`
}

NameSearchOpts contains the search options specific to searching for numerological names.

type NumberSystem 

type NumberSystem struct {
	// Name of the NumberSystem that is used to translate to and from JSON.
	Name string

	// NumberMapping is a map of letters and their corresponding value.
	NumberMapping map[int32]int

	// ValidNumbers shows all the numbers that the number system accepts. The Chaldean number system,
	// in particular, does not use the number 9 in conversions.
	ValidNumbers []int
}

NumberSystem contains the information necessary to convert letters to their numerological value.

func GetNumberSystem 

func GetNumberSystem(s string) (NumberSystem, error)

GetNumberSystem returns the appropriate NumberSystem type from the number systems name. (Pythagorean, Chaldean).

func (NumberSystem) MarshalJSON 

func (ns NumberSystem) MarshalJSON() ([]byte, error)

MarshalJSON returns the name of the number system because it doesn't make sense to encode the whole struct for output to JSON.

func (*NumberSystem) UnmarshalJSON 

func (ns *NumberSystem) UnmarshalJSON(value []byte) error

UnmarshalJSON translates the name of the number system to the appropriate NumberSystem struct.

type NumerologicalResult 

type NumerologicalResult struct {
	// Value contains the reduced numerological value of the name.
	Value int `json:"value"`

	// ReduceSteps contains the conversion at each step until the final number.
	ReduceSteps []int `json:"reduce_steps"`

	// Breakdown contains each individual Breakdown that contributed to the final calculation.
	Breakdown []Breakdown `json:"breakdown"`
}

NumerologicalResult contains the results of the conversion of a name.

func (NumerologicalResult) Debug 

func (n NumerologicalResult) Debug() (debug string)

Debug returns a printable string that offers a simplistic summary of the numerological conversion.

Example 
result := Name("George Washington", Pythagorean, []int{11, 22, 33}, true)
fmt.Print(result.HeartsDesire().Debug())

Output:

G e o r g e
· 5 6 · · 5 = 16 = 7
W a s h i n g t o n
· 1 · · 9 · · · 6 · = 16 = 7
Reduce: 14 = 5

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.