Four is the number of letters in the ...: Difference between revisions

:*   '''twenty─three'''   is considered one word   (which is hyphenated).

:* &nbsp; no &nbsp; <big>''' ''and'' '''</big> &nbsp; words are to be used when spelling a (English) word for a number.

'''2,000,000,000''' &nbsp; is two billion, &nbsp; ''not'' &nbsp; two milliard.

 

=={{header|C}}==

{{libheader|GLib}}

#include <locale.h>

#include <stdbool.h>

word_list_destroy(&result);

return 0;

 

{{out}}

 

=={{header|C++}}==

#include <cstdint>

#include <iomanip>

}

return 0;

 

{{out}}

[[Spelling_of_ordinal_numbers#Go|Spelling of ordinal numbers]] task

(omitted from this listing).

 

import (

// omitted from this listing

// ...

{{out}}

<pre>The lengths of the first 201 words are:

 

=={{header|Haskell}}==

Uses the solution [[Spelling_of_ordinal_numbers#Haskell]] and tying-the-knot technique to create the infinite sentence.

 

where

start = "Four is the number of letters in the first word of this sentence, "

in "The " ++ spellOrdinal n ++ " word is \"" ++ w ++ "\" which has " ++

spellInteger (alphaLength w) ++ " letters. The sentence length is " ++

 

<pre>λ> take 200 sentence

Take care with the requirements. As noted, numberToString(23) = twenty-three. Therefore numberToString(723423) = seven hundred twenty-three thousand four hundred twenty-three (note the two "-").

<br/>The discussion was helpful by providing the first 2202 words of the sentence.

import java.util.HashMap;

import java.util.Map;

}

{{out}}

<pre>

 

=={{header|Julia}}==

 

const seed = "Four is the number of letters in the first word of this sentence, "

println("$n words -> $itercount iterations, $totalletters letters total, ",

"last word \"$lastword\" with $(length(lastword)) letters.")

It is interesting how identical lengths align with 20 columns.

1: 4 2 3 6 2 7 2 3 5 4 2 4 8 3 2 3 6 5 2 3

=={{header|Kotlin}}==

This pulls in (slightly adjusted) code from related tasks to convert numbers to text or ordinals.

 

val names = mapOf(

}

while (n <= 10_000_000)

 

{{out}}

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

 

(*Mathematica has a built-in function for getting the name of an integer. It's a semantically rich function (dealing with many languages and grammatical variants), and consequently it would slow down our algorithm significantly. So, I've used the built-in function to seed/memoize special-purpose functions. Furthermore, the problem is suited to using a representation of the sentence that is an array of strings rather than a single monolithic string, and so these integer name functions will return arrays of strings.*)

},

"\n\n"

 

{{out}}

 

=={{header|Nim}}==

 

####################################################################################################

for n in [1_000, 10_000, 100_000, 1_000_000, 10_000_000]:

echo ""

 

{{out}}

Uses <code>Lingua::EN::Numbers</code> module to generate number names. State variable in <tt>extend_to</tt> routine keeps track of last word tallied.

{{trans|Raku}}

use Lingua::EN::Numbers qw(num2en num2en_ordinal);

 

ucfirst(num2en_ordinal($_)) . " word, '$sentence[$_-1]' has " . alpha($sentence[$_-1]) . " characters. \n" .

count($_) . "\n";

{{out}}

<pre>First 201 word lengths in the sequence:

=={{header|Phix}}==

Note that my version of [[Number_names]] includes "and" (and ","), that others do not, hence the kill_and()/grr below and the minor mismatch of sentence lengths.

{{out}}

<pre>

 

=={{header|Python}}==

# Python implementation of Rosetta Code Task

# http://rosettacode.org/wiki/Four_is_the_number_of_letters_in_the_...

word_and_counts(1000000)

word_and_counts(10000000)

 

Output:

Uses the Lingua::EN::Numbers module to generate both cardinal and ordinal numbers. This module places commas in number words between 3-orders-of-magnitude clusters. E.G. <code>12345678.&ordinal</code> becomes: twelve million, three hundred forty-five thousand, six hundred seventy-eighth. Uses a custom 'no-commas' routine to filter them out for accurate character counts. Generates the 'sentence' lazily so only the words needed are ever calculated and reified.

 

no-commas(True);

 

for 1e3, 1e4, 1e5, 1e6, 1e7 {

say "{.&ordinal.tc} word, '{@sentence[$_ - 1]}', has {@sentence[$_ - 1].&alpha} characters. ", .&count

{{out}}

<pre>First 201 word lengths in the sequence:

 

=={{header|REXX}}==

@= 'Four is the number of letters in the first word of this sentence,' /*···*/

/* [↑] the start of a long sentence. */

 

if $\=='' & z>0 then say right(idx, w)'►'$ /*display if there are residual numbers*/

The &nbsp; '''$SPELL#.REX''' &nbsp; routine can be found here &nbsp; ───► &nbsp; [[$SPELL.REX|$SPELL#.REX]]. <br><br>

 

=={{header|Rust}}==

{{trans|C}}

cardinal: &'static str,

ordinal: &'static str,

n *= 10;

}

 

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

var names = {

n = n * 10

if (n > 1e7) break

 

{{out}}

=={{header|zkl}}==

Uses the nth function from [[Spelling_of_ordinal_numbers#zkl]]

// Save the word counts

fcn fourIsThe(text,numWords){

return(lastWords.strip(),szs,total);

}

sentence,szs,total := fourIsThe(seed,201);

print(" 1:");

if(0 == n%25) print("\n%3d:".fmt(n+1));

}

{{out}}

<pre>

Length of above sentence: 1203

</pre>

sentence,x,total := fourIsThe(seed,n);

word:=lastWord(sentence);

.fmt(n,word,word.len(),total));

n*=10;

{{out}}

<pre>