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

=={{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:

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

sentence = start ++ foldMap add (zip [2..] $ tail $ words 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.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">demo</span><span style="color: #0000FF;">\</span><span style="color: #000000;">rosetta</span><span style="color: #0000FF;">\</span><span style="color: #000000;">number_names</span><span style="color: #0000FF;">.</span><span style="color: #000000;">exw</span> <span style="color: #000080;font-style:italic;">-- see note

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

Note you will have to comment out main()..EOF in the number_names.exw file for pwa/p2js to accept it/not complain about multiple main() or #ilASM (which I may yet remove). Also as indicated 100K words is simply too much for your typical browser, let alone a million, so we limit the last part to 10K under pwa/p2js.

{{out}}

=={{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>