pharo-llm/pharo-exercism-benchmark huggingface dataset:
"Exercise: Luhn"

luhn: aString
"Given a number determine whether or not it is valid per the Luhn formula.
    The Luhn algorithm is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers and Canadian Social Insurance Numbers.
    The task is to check if a given string is valid.
    Strings of length 1 or less are not valid.
    Spaces are allowed in the input, but they should be stripped before checking.
    All other non-digit characters are disallowed.
    The first step of the Luhn algorithm is to double every second digit, starting from the right.
    If doubling the number results in a number greater than 9 then subtract 9 from the product.
    Then sum all of the digits and if the sum is evenly divisible by 10, then the number is valid."
"(self new luhn: '4539 3195 0343 6467') >>> true"
"(self new luhn: '8273 1232 7352 0569') >>> false"
| digits sum |
	digits := OrderedCollection new.

	aString do: [ :ch |
			ch isSpaceSeparator ifFalse: [
					ch isDigit
						ifTrue: [ digits add: ch digitValue ]
						ifFalse: [ ^ false ] ] ].

	digits size < 2 ifTrue: [ ^ false ].

	sum := 0.
	1 to: digits size do: [ :i |
			| d idx |
			idx := digits size - i + 1.
			d := digits at: idx.
			i even ifTrue: [
					d := d * 2.
					d > 9 ifTrue: [ d := d - 9 ] ].
			sum := sum + d ].

	^ sum \\ 10 = 0


"Tests"
testLuhn
self assert: (task luhn: '1') equals: false.
  self assert: (task luhn: '0') equals: false.
  self assert: (task luhn: '059') equals: true.
  self assert: (task luhn: '59') equals: true.
  self assert: (task luhn: '055 444 285') equals: true.
  self assert: (task luhn: '055 444 286') equals: false.
  self assert: (task luhn: '8273 1232 7352 0569') equals: false.
  self assert: (task luhn: '095 245 88') equals: true.
  self assert: (task luhn: '059a') equals: false.
  self assert: (task luhn: '055-444-285') equals: false.
  self assert: (task luhn: '055 444$ 285') equals: false.
  self assert: (task luhn: ' 0') equals: false.
  self assert: (task luhn: '0000 0') equals: true.
  self assert: (task luhn: '091') equals: true.
  self assert: (task luhn: '055b 444 285') equals: false.
  self assert: (task luhn: ':9') equals: false
"Exercise: Acronym"

acronym: aString
"Convert a phrase to its acronym.
	Techies love their TLA (Three Letter Acronyms)!
	Help generate some jargon by writing a program that converts a long name like Portable Network Graphics to its acronym (PNG).
	Punctuation is handled as follows: hyphens are word separators (like whitespace); all other punctuation can be removed from the input."
"(self new acronym: 'As Soon As Possible') >>> 'ASAP'"
"(self new acronym: 'Liquid-crystal display') >>> 'LCD'"
"(self new acronym: 'Thank George It''s Friday!') >>> 'TGIF'"
| words |
	words := aString splitOn: [ :ch | ch isSeparator or: [ ch = $- ] ].
	^ String streamContents: [ :out |
			  (words select: [ :w | w notEmpty ]) do: [ :word |
					  | first |
					  first := word
						           detect: [ :ch | ch isAlphaNumeric ]
						           ifNone: [ nil ].
					  first ifNotNil: [ out nextPut: first uppercase ] ] ]


"Tests"
testAcronym
self assert: (task acronym: 'Portable Network Graphics') equals: 'PNG'.
  self assert: (task acronym: 'Ruby on Rails') equals: 'ROR'.
  self assert: (task acronym: 'First In, First Out') equals: 'FIFO'.
  self assert: (task acronym: 'GNU Image Manipulation Program') equals: 'GIMP'.
  self assert: (task acronym: 'Complementary metal-oxide semiconductor') equals: 'CMOS'.
  self assert: (task acronym: 'Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me') equals: 'ROTFLSHTMDCOALM'.
  self assert: (task acronym: 'Something - I made up from thin air') equals: 'SIMUFTA'.
  self assert: (task acronym: 'Halley''s Comet') equals: 'HC'.
  self assert: (task acronym: 'The Road _Not_ Taken') equals: 'TRNT'
"Exercise: IsbnVerifier"

isbnVerifier: aString
"Given a string the program should check if the provided string is a valid ISBN-10.
    The ISBN-10 verification process is used to validate book identification numbers.
    These normally contain dashes and look like: 3-598-21508-8
    The ISBN-10 format is 9 digits (0 to 9) plus one check character (either a digit or an X only).
    In the case the check character is an X, this represents the value '10'.
    These may be communicated with or without hyphens, and can be checked for their validity by the following formula:
    (d_1 * 10 + d_2 * 9 + d_3 * 8 + d_4 * 7 + d_5 * 6 + d_6 * 5 + d_7 * 4 + d_8 * 3 + d_9 * 2 + d_10 * 1) mod 11 == 0
    If the result is 0, then it is a valid ISBN-10, otherwise it is invalid.
    The program should be able to verify ISBN-10 both with and without separating dashes."
"(self new isbnVerifier: '3-598-21508-8') >>> true"
"(self new isbnVerifier: '3-598-21508-9') >>> false"
"(self new isbnVerifier: '3-598-21507-X') >>> true"
| string digits control acc |
	aString isEmpty ifTrue: [ ^ false ].
	string := aString.
	digits := string allButLast asOrderedCollection
		          select: [ :each | each isDecimalDigit ]
		          thenCollect: [ :each | each digitValue ].
	digits size = 9 ifFalse: [ ^ false ].

	control := string last.
	((control between: $0 and: $9) or: [ control lowercase = $x ])
		ifFalse: [ ^ false ].

	acc := digits
		       with: (10 to: 2 by: -1)
		       collect: [ :digit :multiplier | digit * multiplier ].
	^ (acc sum + (control digitValue min: 10) % 11) isZero


"Tests"
testIsbnVerifier
self assert: (task isbnVerifier: '3-598-21508-8') equals: true.
  self assert: (task isbnVerifier: '3-598-21508-9') equals: false.
  self assert: (task isbnVerifier: '3-598-21507-X') equals: true.
  self assert: (task isbnVerifier: '3-598-21507-A') equals: false.
  self assert: (task isbnVerifier: '3-598-P1581-X') equals: false.
  self assert: (task isbnVerifier: '3-598-2X507-9') equals: false.
  self assert: (task isbnVerifier: '3598215088') equals: true.
  self assert: (task isbnVerifier: '359821507X') equals: true.
  self assert: (task isbnVerifier: '359821507') equals: false.
  self assert: (task isbnVerifier: '3598215078X') equals: false.
  self assert: (task isbnVerifier: '00') equals: false.
  self assert: (task isbnVerifier: '3-598-21507') equals: false.
  self assert: (task isbnVerifier: '3-598-21515-X') equals: false.
  self assert: (task isbnVerifier: '') equals: false.
  self assert: (task isbnVerifier: '134456729') equals: false.
  self assert: (task isbnVerifier: '3132P34035') equals: false.
  self assert: (task isbnVerifier: '98245726788') equals: false
"Exercise: FlattenArray"

flattenArray: aCollection
"Take a nested list and return a single flattened list with all values except nil.
    The challenge is to write a function that accepts an arbitrarily-deep nested list-like structure and returns a flattened structure without any nil values."
"(self new flattenArray: #(1 #(2 3 nil 4) #(nil) 5)) >>> #(1 2 3 4 5)"
| result queue |
	result := OrderedCollection new.
	queue := OrderedCollection new.
	aCollection do: [ :e |
			queue add: e.
			[ queue isEmpty ] whileFalse: [
					| element |
					element := queue removeFirst.
					element isCollection
						ifTrue: [ queue addAllFirst: element ]
						ifFalse: [ element ifNotNil: [ result add: element ] ] ] ].
	^ result asArray


"Tests"
testFlattenArray
self assert: (task flattenArray: #(0 1 2)) equals: #(0 1 2).
  self assert: (task flattenArray: #(1 #(2 3 4 5 6 7) 8)) equals: #(1 2 3 4 5 6 7 8).
  self assert: (task flattenArray: #(0 2 #(#(2 3) 8 100 4 #(#(#(50))) ) -2)) equals: #(0 2 2 3 8 100 4 50 -2).
  self assert: (task flattenArray: #(1 #(2 #(#(3)) #(4 #(#(5)) ) 6 7) 8)) equals: #(1 2 3 4 5 6 7 8).
  self assert: (task flattenArray: #(0 2 #(#(2 3) 8 #(#(100)) nil #(#(nil)) ) -2)) equals: #(0 2 2 3 8 100 -2).
  self assert: (task flattenArray: #(nil #(#(#(nil)) ) nil nil #(#(nil nil) nil) nil)) equals: #()
"Exercise: Anagram"

anagram: aCollectionOfWords subject: aString
"Your task is to, given a target word and a set of candidate words, to find the subset of the candidates that are anagrams of the target. 
    An anagram is a rearrangement of letters to form a new word. A word is not its own anagram.
    The target and candidates are words of one or more ASCII alphabetic characters (A-Z and a-z).
    Lowercase and uppercase characters are equivalent.
    The anagram set is the subset of the candidate set that are anagrams of the target.
    Words in the anagram set should have the same letter case as in the candidate set.
    You must return the anagrams in the same order as they are listed in the candidate words."
"(self new anagram: #('owns') subject: 'snow') >>> #('owns')"
"(self new anagram: #('stop') subject: 'stop') >>> #()"
"(self new anagram: #('PoTS' 'StoP') subject: 'sTOp') >>> #('PoTS')"
"(self new anagram: #('stone' 'tones' 'banana' 'tons' 'notes' 'Seton') subject: 'stone') >>> #('tones' 'notes' 'Seton')"
| letterBag |
  letterBag := aString asLowercase asBag.
  ^ aCollectionOfWords
    reject: [:word | (word sameAs: aString) or: [ word asLowercase asBag ~= letterBag ] ]


"Tests"
testAnagram
self assert: (task anagram: #('hello' 'world' 'zombies' 'pants') subject: 'diaper') equals: #().
  self assert: (task anagram: #('stream' 'pigeon' 'maters') subject: 'master') equals: #('stream' 'maters').
  self assert: (task anagram: #('dog' 'goody') subject: 'good') equals: #().
  self assert: (task anagram: #('enlists' 'google' 'inlets' 'banana') subject: 'listen') equals: #('inlets').
  self assert: (task anagram: #('gallery' 'ballerina' 'regally' 'clergy' 'largely' 'leading') subject: 'allergy') equals: #('gallery' 'regally' 'largely').
  self assert: (task anagram: #('last') subject: 'mass') equals: #().
  self assert: (task anagram: #('cashregister' 'Carthorse' 'radishes') subject: 'Orchestra') equals: #('Carthorse').
  self assert: (task anagram: #('cashregister' 'carthorse' 'radishes') subject: 'Orchestra') equals: #('carthorse').
  self assert: (task anagram: #('cashregister' 'Carthorse' 'radishes') subject: 'orchestra') equals: #('Carthorse').
  self assert: (task anagram: #('go Go GO') subject: 'go') equals: #().
  self assert: (task anagram: #('patter') subject: 'tapper') equals: #().
  self assert: (task anagram: #('BANANA' 'Banana' 'banana') subject: 'BANANA') equals: #()
"Exercise: ResistorColorDuo"

resistorColorDuo: colours
"If you want to build something using a Raspberry Pi, you'll probably use resistors.
    For this exercise, you need to know two things about them:
    - Each resistor has a resistance value.
    - Resistors are small - so small in fact that if you printed the resistance value on them, it would be hard to read.
    To get around this problem, manufacturers print color-coded bands onto the resistors to denote their resistance values.
    Each band has a position and a numeric value.
    The first 2 bands of a resistor have a simple encoding scheme: each color maps to a single number.
    For example, if they printed a brown band (value 1) followed by a green band (value 5), it would translate to the number 15.
    In this exercise you are going to create a helpful method so that you don't have to remember the values of the bands.
    The program will take color names as input and output a two digit number, even if the input is more than two colors!
    The band colors are encoded as follows:
    - black: 0
    - brown: 1
    - red: 2
    - orange: 3
    - yellow: 4
    - green: 5
    - blue: 6
    - violet: 7
    - grey: 8
    - white: 9"
"(self new resistorColorDuo: #('brown' 'green')) >>> 15"
"(self new resistorColorDuo: #('brown' 'green' 'violet')) >>> 15"
| table firstTwo |
    table := #('black' 'brown' 'red' 'orange' 'yellow' 'green' 'blue' 'violet' 'grey' 'white').
    firstTwo := colours copyFrom: 1 to: (colours size min: 2).
    ^ firstTwo
        inject: 0
        into: [:result :colour |
            | idx |
            idx := table indexOf: colour.
            idx = 0 ifTrue: [ Error signal: 'Invalid color' ].
            result * 10 + (idx - 1) ]


"Tests"
testResistorColorDuo
self assert: (task resistorColorDuo: #('brown' 'black')) equals: 10.
  self assert: (task resistorColorDuo: #('blue' 'grey')) equals: 68.
  self assert: (task resistorColorDuo: #('yellow' 'violet')) equals: 47.
  self assert: (task resistorColorDuo: #('white' 'red')) equals: 92.
  self assert: (task resistorColorDuo: #('orange' 'orange')) equals: 33.
  self assert: (task resistorColorDuo: #('green' 'brown' 'orange')) equals: 51.
  self assert: (task resistorColorDuo: #('black' 'brown')) equals: 1.

  self
    should: [ task resistorColorDuo: #('unknown' 'black') ]
    raise: Error.
  self
    should: [ task resistorColorDuo: #('black' 'unknown') ]
    raise: Error
"Exercise: Hamming"

hamming: strand1 strand2: strand2
"Calculate the Hamming Distance between two DNA strands.
    Your body is made up of cells that contain DNA.
    Those cells regularly wear out and need replacing, which they achieve by dividing into daughter cells.
    In fact, the average human body experiences about 10 quadrillion cell divisions in a lifetime!
    When cells divide, their DNA replicates too.
    Sometimes during this process mistakes happen and single pieces of DNA get encoded with the incorrect information.
    If we compare two strands of DNA and count the differences between them we can see how many mistakes occurred.
    This is known as the Hamming Distance.
    The Hamming distance is only defined for sequences of equal length, so an attempt to calculate it between sequences of different lengths should not work."
"(self new hamming: 'GAGCCTACTAACGGGAT' strand2: 'CATCGTAATGACGGCCT') >>> 7"
strand1 size = strand2 size ifFalse: [
			^ DomainError signal: 'both strands must have the same length.' ].

	^ (1 to: strand1 size) sumNumbers: [ :i |
			  (strand1 at: i) = (strand2 at: i)
				  ifTrue: [ 0 ]
				  ifFalse: [ 1 ] ]


"Tests"
testHamming
self assert: (task hamming: '' strand2: '') equals: 0.
  self assert: (task hamming: 'A' strand2: 'A') equals: 0.
  self assert: (task hamming: 'G' strand2: 'T') equals: 1.
  self assert: (task hamming: 'GGACTGAAATCTG' strand2: 'GGACTGAAATCTG') equals: 0.
  self assert: (task hamming: 'GGACGGATTCTG' strand2: 'AGGACGGATTCT') equals: 9.

  self
    should: [ task hamming: 'AATG' strand2: 'AAA' ]
    raise: Error.

  self
    should: [ task hamming: 'ATA' strand2: 'AGTG' ]
    raise: Error.

  self
    should: [ task hamming: '' strand2: 'G' ]
    raise: Error.

  self
    should: [ task hamming: 'G' strand2: '' ]
    raise: Error.
"Exercise: MatchingBrackets"

matchingBrackets: aString
"Given a string containing brackets `[]`, braces `{}`, parentheses `()`, or any combination thereof, verify that any and all pairs are matched and nested correctly.
	The string may also contain other characters, which for the purposes of this exercise should be ignored."
"(self new matchingBrackets: '[]') >>> true"
"(self new matchingBrackets: '{[(])}') >>> false"
"(self new matchingBrackets: 'abc(123)[xyz]{!}') >>> true"
| stack openingBrackets closingBrackets top |
	stack := Stack new.
	openingBrackets := '([{'.
	closingBrackets := ')]}'.
	aString do: [ :each |
			(openingBrackets includes: each) ifTrue: [ stack push: each ].
			(closingBrackets includes: each) ifTrue: [
					stack isEmpty ifTrue: [ ^ false ].
					top := stack top.
					((top = $( and: [ each = $) ]) or: [
						 (top = $[ and: [ each = $] ]) or: [
							 top = ${ and: [ each = $} ] ] ])
						ifTrue: [ stack pop ]
						ifFalse: [ ^ false ] ] ].
	^ stack isEmpty


"Tests"
testMatchingBrackets
self assert: (task matchingBrackets: '[]') equals: true.
  self assert: (task matchingBrackets: '') equals: true.
  self assert: (task matchingBrackets: '[[') equals: false.
  self assert: (task matchingBrackets: '}{') equals: false.
  self assert: (task matchingBrackets: '{]') equals: false.
  self assert: (task matchingBrackets: '{ }') equals: true.
  self assert: (task matchingBrackets: '{[])') equals: false.
  self assert: (task matchingBrackets: '{[]}') equals: true.
  self assert: (task matchingBrackets: '{}[]') equals: true.
  self assert: (task matchingBrackets: '([{}({}[])])') equals: true.
  self assert: (task matchingBrackets: '{[)][]}') equals: false.
  self assert: (task matchingBrackets: '([{])') equals: false.
  self assert: (task matchingBrackets: '[({]})') equals: false.
  self assert: (task matchingBrackets: '{}[') equals: false.
  self assert: (task matchingBrackets: '[]]') equals: false.
  self assert: (task matchingBrackets: '(((185 + 223.85) * 15) - 543)/2') equals: true.
  self assert: (task matchingBrackets: '\left(\begin{array}{cc} \frac{1}{3} & x\\ \mathrm{e}^{x} &... x^2 \end{array}\right)') equals: true
"Exercise: HighScores"

highScores: anArray
"Manage a game player's High Score list.
    Your task is to build a high-score component of the classic Frogger game, one of the highest selling and most addictive games of all time, and a classic of the arcade era.
    Your task is to write a method that return the highest score from the list, the last added score and the three highest scores."
"(self new highScores: #(30 50 20 70 40)) >>> (Dictionary new at: #bestScore put: 70; at: #latestScore put: 40; at: #topThreeScore put: #(70 50 40); yourself)"
| latest best top3 |
	best := anArray max.
	latest := anArray last.
	top3 := (anArray asSortedCollection: [ :a :b | a > b ]) asArray
		        first: (3 min: anArray size).

	^ Dictionary new
		  at: #bestScore put: best;
		  at: #latestScore put: latest;
		  at: #topThreeScores put: top3;
		  yourself


"Tests"
testHighScores
| result topThree |

  "List of scores"
  result := task highScores: #(30 50 20 70).

  "Latest score"
  result := task highScores: #(100 0 90 30).
  self assert: (result at: #latestScore) equals: 30.

  "Personal best"
  result := task highScores: #(40 100 70).
  self assert: (result at: #bestScore) equals: 100.

  "Top 3 - personal top three from a list of scores"
  result := task highScores: #(10 30 90 30 100 20 10 0 30 40 40 70 70).
  self assert: (result at: #topThreeScores) equals: #(100 90 70).

  "Top 3 - highest to lowest"
  result := task highScores: #(20 10 30).
  self assert: (result at: #topThreeScores) equals: #(30 20 10).

  "Top 3 - when there is a tie"
  result := task highScores: #(40 20 40 30).
  self assert: (result at: #topThreeScores) equals: #(40 40 30).

  "Top 3 - when there are less than 3"
  result := task highScores: #(30 70).
  self assert: (result at: #topThreeScores) equals: #(70 30).

  "Top 3 - when there is only one"
  result := task highScores: #(40).
  self assert: (result at: #topThreeScores) equals: #(40).

  "Personal best with ties"
  result := task highScores: #(40 100 70 60 100).
  self assert: (result at: #bestScore) equals: 100.

  "Personal top three does not sort stored scores"
  result := task highScores: #(1 2 3 4).
  topThree := result at: #topThreeScores.
  self assert: topThree equals: #(4 3 2).
  self assert: (result at: #latestScore) equals: 4.
"Exercise: Minesweeper"

minesweeper: aMinefield
"Your task is to add the mine counts to empty squares in a completed Minesweeper board.
    The board itself is a rectangle composed of squares that are either empty (' ') or a mine ('*').
    For each empty square, count the number of mines adjacent to it (horizontally, vertically, diagonally).
    If the empty square has no adjacent mines, leave it empty.
    Otherwise replace it with the adjacent mines count."
"(self new minesweeper: #(' * * ' '  *  ' '  *  ' '     ')) >>> #('1*3*1' '13*31' ' 2*2 ' ' 111 ')"
aMinefield ifEmpty: [ ^ aMinefield ].

	^ aMinefield withIndexCollect: [ :rowString :rowIndex |
			  | rowLength annotatedRow zeroCode inBounds atMine |
			  rowLength := rowString size.
			  annotatedRow := String new: rowLength.
			  zeroCode := $0 codePoint.

			  inBounds := [ :y :x |
				              (y between: 1 and: aMinefield size) and: [
						              | neighborRow |
						              neighborRow := aMinefield at: y.
						              x between: 1 and: neighborRow size ] ].
			  atMine := [ :y :x |
				            | neighborRow |
				            neighborRow := aMinefield at: y.
				            (neighborRow at: x) = $* ].

			  1 to: rowLength do: [ :colIndex |
					  | cell mineCount |
					  cell := rowString at: colIndex.
					  cell = $*
						  ifTrue: [ annotatedRow at: colIndex put: $* ]
						  ifFalse: [
								  mineCount := 0.
								  -1 to: 1 do: [ :dy |
										  -1 to: 1 do: [ :dx |
												  (dx = 0 and: [ dy = 0 ]) ifFalse: [
														  (inBounds value: rowIndex + dy value: colIndex + dx)
															  ifTrue: [
																	  (atMine value: rowIndex + dy value: colIndex + dx)
																		  ifTrue: [ mineCount := mineCount + 1 ] ] ] ] ].
								  annotatedRow at: colIndex put: (mineCount = 0
										   ifTrue: [ $  ]
										   ifFalse: [ Character value: zeroCode + mineCount ]) ] ].
			  annotatedRow ]


"Tests"
testMinesweeper
self assert: (task minesweeper: #()) equals: #().
  self assert: (task minesweeper: #('')) equals: #('').
  self assert: (task minesweeper: #('   ' '   ' '   ')) equals: #('   ' '   ' '   ').
  self assert: (task minesweeper: #('***' '***' '***')) equals: #('***' '***' '***').
  self assert: (task minesweeper: #('   ' ' * ' '   ')) equals: #('111' '1*1' '111').
  self assert: (task minesweeper: #('***' '* *' '***')) equals: #('***' '*8*' '***').
  self assert: (task minesweeper: #(' * * ')) equals: #('1*2*1').
  self assert: (task minesweeper: #('*   *')) equals: #('*1 1*').
  self assert: (task minesweeper: #(' ' '*' ' ' '*' ' ')) equals: #('1' '*' '2' '*' '1').
  self assert: (task minesweeper: #('*' ' ' ' ' ' ' '*')) equals: #('*' '1' ' ' '1' '*').
  self assert: (task minesweeper: #('  *  ' '  *  ' '*****' '  *  ' '  *  ')) equals: #(' 2*2 ' '25*52' '*****' '25*52' ' 2*2 ').
  self assert: (task minesweeper: #(' *  * ' '  *   ' '    * ' '   * *' ' *  * ' '      ')) equals: #('1*22*1' '12*322' ' 123*2' '112*4*' '1*22*2' '111111')
"Exercise: ArmstrongNumbers"

armstrongNumbers: anInteger
"An Armstrong number is a number that is the sum of its own digits each raised to the power of the number of digits. Write some code to determine whether a number is an Armstrong number."
"(self new armstrongNumbers: 9) >>> true"
"(self new armstrongNumbers: 10) >>> false"
"(self new armstrongNumbers: 153) >>> true"
"(self new armstrongNumbers: 154) >>> false"
| armstrongValue decimalDigitLength |
    decimalDigitLength := anInteger decimalDigitLength.
    armstrongValue := ((1 to: decimalDigitLength)
        collect: [ :index | (anInteger decimalDigitAt: index) raisedTo: decimalDigitLength ])
        sumNumbers.
    ^ anInteger = armstrongValue


"Tests"
testArmstrongNumbers
self assert: (task armstrongNumbers: 5) equals: true.
  self assert: (task armstrongNumbers: 10) equals: false.
  self assert: (task armstrongNumbers: 153) equals: true.
  self assert: (task armstrongNumbers: 100) equals: false.
  self assert: (task armstrongNumbers: 9474) equals: true.
  self assert: (task armstrongNumbers: 9475) equals: false.
  self assert: (task armstrongNumbers: 9926315) equals: true.
  self assert: (task armstrongNumbers: 9926314) equals: false