Rosetta Code/Count examples
Find the total number of programming examples for each task and the total for all tasks.
![Task](http://static.miraheze.org/rosettacodewiki/thumb/b/ba/Rcode-button-task-crushed.png/64px-Rcode-button-task-crushed.png)
You are encouraged to solve this task according to the task description, using any language you may know.
Essentially, count the number of occurrences of =={{header| on each task page.
Output:
100 doors: 20 examples. 99 Bottles of Beer: 29 examples. Abstract type: 10 examples. Total: X examples.
You'll need to use the Media Wiki API, which you can find out about locally, here, or in Media Wiki's API documentation at, API:Query
Ada
Parsing XML file with XMLAda from AdaCore <lang Ada>with Aws.Client, Aws.Messages, Aws.Response, Aws.Resources, Aws.Url; with Dom.Readers, Dom.Core, Dom.Core.Documents, Dom.Core.Nodes, Dom.Core.Attrs; with Input_Sources.Strings, Unicode, Unicode.Ces.Utf8; with Ada.Strings.Unbounded, Ada.Strings.Fixed, Ada.Text_IO, Ada.Command_Line; with Ada.Containers.Vectors;
use Aws.Client, Aws.Messages, Aws.Response, Aws.Resources, Aws.Url; use Dom.Readers, Dom.Core, Dom.Core.Documents, Dom.Core.Nodes, Dom.Core.Attrs; use Aws, Ada.Strings.Unbounded, Ada.Strings.Fixed, Input_Sources.Strings; use Ada.Text_IO, Ada.Command_Line;
procedure Count_Examples is
package Members_Vectors is new Ada.Containers.Vectors ( Index_Type => Positive, Element_Type => Unbounded_String); use Members_Vectors;
Exemples : Vector; Nbr_Lg, Total : Natural := 0;
procedure Get_Vector (Category : in String; Mbr_Vector : in out Vector) is Reader : Tree_Reader; Doc : Document; List : Node_List; N : Node; A : Attr; Page : Aws.Response.Data; Uri_Xml : constant String := "http://rosettacode.org/mw/api.php?action=query&list=categorymembers" & "&format=xml&cmlimit=500&cmtitle=Category:"; begin Page := Client.Get (Uri_Xml & Category); if Response.Status_Code (Page) not in Messages.Success then raise Client.Connection_Error; end if; declare Xml : constant String := Message_Body (Page); Source : String_Input; begin Open (Xml'Unrestricted_Access, Unicode.Ces.Utf8.Utf8_Encoding, Source); Parse (Reader, Source); Close (Source); end; Doc := Get_Tree (Reader); List := Get_Elements_By_Tag_Name (Doc, "cm"); for Index in 1 .. Length (List) loop N := Item (List, Index - 1); A := Get_Named_Item (Attributes (N), "title"); Append (Mbr_Vector, To_Unbounded_String (Value (A))); end loop; Free (List); Free (Reader); end Get_Vector;
function Scan_Page (Title : String) return Natural is Page : Aws.Response.Data; File : Aws.Resources.File_Type; Buffer : String (1 .. 1024); Languages, Position, Last : Natural := 0; begin Page := Client.Get ("http://rosettacode.org/mw/index.php?title=" & Aws.Url.Encode (Title) & "&action=raw"); Response.Message_Body (Page, File); while not End_Of_File (File) loop Resources.Get_Line (File, Buffer, Last); Position := Index (Source => Buffer (Buffer'First .. Last), Pattern => "=={{header|"); if Position > 0 then Languages := Languages + 1; end if; end loop; Close (File); return Languages; end Scan_Page;
begin
Get_Vector ("Programming_Tasks", Exemples);
for I in First_Index (Exemples) .. Last_Index (Exemples) loop declare Title : constant String := To_String (Members_Vectors.Element (Exemples, I)); begin Nbr_Lg := Scan_Page (Title); Total := Total + Nbr_Lg; Put_Line (Title & " :" & Integer'Image (Nbr_Lg) & " exemples."); end; end loop;
Put_Line ("Total :" & Integer'Image (Total) & " exemples.");
end Count_Examples; </lang> Output :
100 doors : 107 exemples. 24 game : 30 exemples. .... Yahoo! search interface : 10 exemples. Zig-zag matrix : 49 exemples. Total : 17238 exemples.
AutoHotkey
<lang AutoHotkey>UrlDownloadToFile
, http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml , tasks.xml
FileRead, tasks, tasks.xml pos = 0 quote = " ; " regtitle := "<cm.*?title=" . quote . "(.*?)" . quote While, pos := RegExMatch(tasks, regtitle, title, pos + 1) {
UrlDownloadToFile , % "http://www.rosettacode.org/w/index.php?title=" . title1 . "&action=raw" , task.xml FileRead, task, task.xml RegExReplace(task, "\{\{header\|", "", count) current := title1 . ": " . count . " examples.`n" output .= current TrayTip, current, % current
} MsgBox % output Return</lang>
BBC BASIC
<lang bbcbasic> VDU 23,22,640;512;8,16,16,128+8 : REM Enable UTF-8 support
SYS "LoadLibrary", "URLMON.DLL" TO urlmon% SYS "GetProcAddress", urlmon%, "URLDownloadToFileA" TO UDTF special$ = "+()'" url$ = "http://www.rosettacode.org/w/api.php?action=query" + \ \ "&list=categorymembers&cmtitle=Category:Programming_Tasks" + \ \ "&cmlimit=500&format=xml" file$ = @tmp$ + "tasks.xml" SYS UDTF, 0, url$, file$, 0, 0 TO fail% IF fail% ERROR 100, "File download failed (tasks)" Total% = 0 file% = OPENIN(file$) WHILE NOT EOF#file% a$ = GET$#file% i% = 0 REPEAT i% = INSTR(a$, "title=", i%+1) IF i% THEN j% = INSTR(a$, ">", i%) title$ = MID$(a$, i%+7, j%-i%-10) REM Replace HTML codes: REPEAT k% = INSTR(title$, "&") IF k% THEN l% = INSTR(title$, ";", k%) title$ = LEFT$(title$,k%-1) + \ \ FNhtml(MID$(title$,k%,l%-k%+1)) + MID$(title$,l%+1) ENDIF UNTIL k% = 0 t$ = title$ REM Substitute characters not allowed in a URL: FOR s% = 1 TO LEN(special$) REPEAT s$ = MID$(special$, s%, 1) k% = INSTR(t$, s$) IF k% t$ = LEFT$(t$,k%-1) + "%" + STR$~ASCs$ + MID$(t$,k%+1) UNTIL k% = 0 NEXT url$ = "http://www.rosettacode.org/w/index.php?title=" + t$ + \ \ "&action=raw" file$ = @tmp$ + "title.htm" SYS UDTF, 0, url$, file$, 0, 0 TO fail% IF fail% ERROR 100, "File download failed " + t$ examples% = 0 task% = OPENIN(file$) WHILE NOT EOF#task% IF INSTR(GET$#task%, "=={{header|") examples% += 1 ENDWHILE CLOSE #task% Total% += examples% PRINT title$ ": " ; examples% " examples." ENDIF UNTIL i% = 0 i% = INSTR(a$, "cmcontinue=") IF i% THEN CLOSE #file% j% = INSTR(a$, """", i%+1) k% = INSTR(a$, """", j%+1) url$ = "http://www.rosettacode.org/w/api.php?action=query" + \ \ "&list=categorymembers&cmtitle=Category:Programming_Tasks" + \ \ "&cmlimit=500&format=xml&cmcontinue=" + MID$(a$,j%+1,k%-j%) REPEAT i% = INSTR(url$, "|") IF i% url$ = LEFT$(url$,i%-1) + "%7C" + MID$(url$,i%+1) UNTIL i% = 0 file$ = @tmp$ + "tasks.xml" SYS UDTF, 0, url$, file$, 0, 0 TO fail% IF fail% ERROR 100, "File download failed (continue)" file% = OPENIN(file$) ENDIF ENDWHILE CLOSE #file% PRINT ' "Total: " ; Total% " examples." END DEF FNhtml(h$) IF LEFT$(h$,2) = "&#" THEN = CHR$(VALMID$(h$,3)) CASE h$ OF WHEN """: = """" ENDCASE = h$</lang>
Sample output:
100 doors: 154 examples. 24 game: 53 examples. 24 game/Solve: 30 examples. 99 Bottles of Beer: 181 examples. A+B: 124 examples. Abstract type: 49 examples. Accumulator factory: 65 examples. Ackermann function: 126 examples. Active Directory/Connect: 12 examples. Active Directory/Search for a user: 13 examples. ...... XML/DOM serialization: 33 examples. XML/Input: 50 examples. XML/Output: 41 examples. XML/XPath: 33 examples. Y combinator: 51 examples. Yahoo! search interface: 13 examples. Yin and yang: 36 examples. Zebra puzzle: 11 examples. Zeckendorf number representation: 14 examples. Zig-zag matrix: 64 examples. Total: 27004 examples.
Bracmat
<lang bracmat>( ( get-page
= . sys$(str$("wget -q -O wget.out \"" !arg \")) & get$("wget.out",HT ML) )
& get-page$"http://rosettacode.org/wiki/Category:Programming_Tasks"
: ? (table.?) ?tasklist (.table.) ?
& 0:?list & whl
' ( !tasklist : ? ( a . (href.@(?:"/wiki/" ?href)) (title.?title) & get-page$(str$("http://rosettacode.org/wiki/" !href)) : ?task & 0:?cnt & whl ' ( !task : ? ( (span.(class.mw-headline) (id.?)) ?span (.span.) ?task & !span : ? ( a . (href.@(?:"/wiki/Category:" ?)) (title.@(?:"Category:" ?)) ) @ (.a.) ? ) & 1+!cnt:?cnt ) & (!cnt.!title)+!list:?list ) ?tasklist )
& lst$(list,taskfreq,NEW)
)</lang>
Output (in file tasqfreq
):
list= (2."OLE Automation") + (3."Canny edge detector") + ( 3 . "Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N1, Contined Fraction N2)" ) + (4."Colour pinstripe/Printer") + (4."Vogel's approximation method") + (5."Catmull–Clark subdivision surface") + (5."Percolation/Bond percolation") + (5.Pinstripe/Printer) + (5."Zeckendorf arithmetic") + (6."Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N)") + (6."Percolation/Mean cluster density") + (7."Bitmap/PPM conversion through a pipe") + (7."Deconvolution/2D+") + (7."K-d tree") .... + (125."Greatest element of a list") + (127."Averages/Arithmetic mean") + (131.Arrays) + (131."Increment a numerical string") + (132."Greatest common divisor") + (133.Loops/While) + (134."Conditional structures") + (136.Arithmetic/Integer) + (137.Loops/For) + (145.Loops/Infinite) + (147."Ackermann function") + (148."Reverse a string") + (152."A+B") + (152."Function definition") + (160."Empty program") + (163."Fibonacci sequence") + (164.Factorial) + (182.FizzBuzz) + (187."100 doors") + (188.Comments) + (216."99 Bottles of Beer") + (269."Hello world/Text");
C#
Object-oriented solution.
<lang csharp>using System; using System.Collections.Generic; using System.Linq; using System.Text.RegularExpressions; using System.Net;
class Task {
private string _task; private int _examples;
public Task(string task, int examples) { _task = task; _examples = examples; }
public string Name { get { return _task; } }
public int Examples { get { return _examples; } }
public override string ToString() { return String.Format("{0}: {1} examples.", this._task, this._examples); }
}
class Program {
static List<string> GetTitlesFromCategory(string category, WebClient wc) { string content = wc.DownloadString( String.Format("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:{0}&cmlimit=500&format=json", category) );
return new Regex("\"title\":\"(.+?)\"").Matches(content).Cast<Match>().Select(x => x.Groups[1].Value.Replace("\\/", "/")).ToList(); }
static string GetSourceCodeFromPage(string page, WebClient wc) { return wc.DownloadString( String.Format("http://www.rosettacode.org/w/index.php?title={0}&action=raw", page) ); }
static void Main(string[] args) { WebClient wc = new WebClient(); List<Task> tasks = new List<Task>(); List<string> tasknames = GetTitlesFromCategory("Programming_Tasks", wc);
foreach (string task in tasknames) { string content = GetSourceCodeFromPage(task, wc); int count = new Regex("=={{header", RegexOptions.IgnoreCase).Matches(content).Count; Task t = new Task(task, count);
Console.WriteLine(t); tasks.Add(t); }
Console.WriteLine("\nTotal: {0} examples.", tasks.Select(x => x.Examples).Sum()); }
}</lang>
Clojure
<lang clojure>(ns count-examples
(:import [java.net URLEncoder]) (:use [clojure.contrib.http.agent :only (http-agent string)] [clojure.contrib.json :only (read-json)] [clojure.contrib.string :only (join)]))
(defn url-encode [v] (URLEncoder/encode (str v) "utf-8"))
(defn rosettacode-get [path params]
(let [param-string (join "&" (for [[n v] params] (str (name n) "=" (url-encode v))))] (string (http-agent (format "http://www.rosettacode.org/w/%s?%s" path param-string)))))
(defn rosettacode-query [params]
(read-json (rosettacode-get "api.php" (merge {:action "query" :format "json"} params))))
(defn list-cm
([params] (list-cm params nil)) ([params continue] (let [cm-params (merge {:list "categorymembers"} params (or continue {})) result (rosettacode-query cm-params)] (concat (-> result (:query) (:categorymembers)) (if-let [cmcontinue (-> result (:query-continue) (:categorymembers))] (list-cm params cmcontinue))))))
(defn programming-tasks []
(let [result (list-cm {:cmtitle "Category:Programming_Tasks" :cmlimit 50})] (map #(:title %) result)))
(defn task-count [task]
[task (count (re-seq #"==\{\{header" (rosettacode-get "index.php" {:action "raw" :title task})))])
(defn print-result []
(let [task-counts (map task-count (programming-tasks))] (doseq [[task count] task-counts] (println (str task ":") count) (flush)) (println "Total: " (reduce #(+ %1 (second %2)) 0 task-counts))))
</lang> <lang clojure>count-examples> (print-result) 100 doors: 73 24 game: 18 24 game/Solve: 14 99 Bottles of Beer: 89 Abstract type: 27 Accumulator factory: 23 Ackermann function: 73 Active Directory/Connect: 4 Active Directory/Search for a user: 3 Active object: 14 Add a variable to a class instance at runtime: 21 Address of a variable: 20 ... Total: 11216 nil </lang>
D
<lang D> import tango.io.Stdout; import tango.net.http.HttpClient; import tango.net.http.HttpHeaders; import tango.text.xml.Document; import tango.text.Util;
alias HttpHeader.ContentLength CL;
auto url = "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"; void main() {
auto client = new HttpClient (HttpClient.Get, url); client.open(); char[] mainData, tmp; int total, i;
void cat(void[] content) { tmp ~= cast(char[]) content; }
if (client.isResponseOK) { client.read(&cat, client.getResponseHeaders.getInt(CL)); mainData = tmp; tmp = null;
auto doc = new Document!(char); doc.parse(mainData); foreach (n; doc.query.descendant("cm").attribute("title")) { auto subClient = new HttpClient(HttpClient.Get, "http://www.rosettacode.org/w/index.php?title=" ~ replace(n.value.dup, ' ', '_') ~ "&action=raw"); subClient.open(); if (! subClient.isResponseOK) { Stderr (client.getResponse); break; } subClient.read(&cat, subClient.getResponseHeaders.getInt(CL)); foreach (segment; patterns(cast(char[])tmp, "=={{header|")) i++; --i; if (i) --i; Stdout.formatln ("{0,-40} - {}", n.value, i); total += i; tmp = null; i = 0; } Stdout("total examples: ", total).newline; } else { Stderr (client.getResponse); }
} </lang>
EGL
A graphical implementation with a grid showing the number of implementations for each Rosetta Code task as well as total task and implementation counts. Uses MediaWiki API service call to fetch tasks/categories in a JSON format and meets API data limit and continuation requirements to consume 100% of the items.
User Interface: RosettaCodeHandler.egl <lang EGL>package com.eglexamples.client;
import org.eclipse.edt.rui.widgets.*;
handler RosettaCodeHandler type RUIhandler{initialUI =[ui], title = "Rosetta Code Tasks and Counts"}
ui GridLayout{columns = 3, rows = 4, cellPadding = 4, children = [ b1, dg1, l1, l2, l3, l4 ]}; b1 Button{ layoutData = new GridLayoutData{ row = 1, column = 1 }, text = "Go!", onClick ::= b1_onClick }; l1 TextLabel{ layoutData = new GridLayoutData{ row = 1, column = 2 }, text = "Total Tasks:" }; l2 TextLabel{ layoutData = new GridLayoutData{ row = 1, column = 3 }, text = "0" };
l3 TextLabel{ layoutData = new GridLayoutData{ row = 2, column = 2 }, text = "Total Implementations:" }; l4 TextLabel{ layoutData = new GridLayoutData{ row = 2, column = 3 }, text = "0" }; dg1 DataGrid{ layoutData = new GridLayoutData{ row = 3, column = 1, horizontalSpan = 3 }, pageSize = 10, showScrollbar = true,
columns = [ new DataGridColumn{name = "title", displayName = "Task", width=220}, new DataGridColumn{name = "count", displayName = "Count", width=100} ] };
cmcontinue string?; title string?; allTasks Task[];
restBindingTasks IHttp? = new HttpRest{ restType = eglx.rest.ServiceType.TrueRest, request.uri = "http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=1&format=json"};
restBindingPageDetail IHttp? = new HttpRest{ restType = eglx.rest.ServiceType.TrueRest, request.uri = "http://rosettacode.org/mw/index.php"};
function b1_onClick(event Event in)
call ProxyFunctions.listTasks("") using restBindingTasks
returning to listTasksCallBack onException exceptionHandler; end function listTasksCallBack(retResult RosettaCodeJSON in)
title = retResult.query.categorymembers[1].title; cmcontinue = retResult.queryContinue.categorymembers.cmcontinue;
call ProxyFunctions.fetchPageDetail(title) using restBindingPageDetail
returning to pageDetailCallBack onException exceptionHandler; end
function pageDetailCallBack(pageResults string in) count int = countSubstring("=={{header", pageResults); allTasks.appendElement(new Task { title = title, count = count });
l2.text = l2.text as int + 1; l4.text = l4.text as int + count;
if(cmcontinue != null)
call ProxyFunctions.listTasks(cmcontinue) using restBindingTasks returning to listTasksCallBack onException exceptionHandler; else dg1.data = allTasks as any[]; end
end function countSubstring(substr string in, str string in) returns(int)
if(str.length() > 0 and substr.length() > 0) return (str.length() - str.replaceStr(subStr, "").length()) / subStr.length(); else return 0; end
end
function exceptionHandler(exp AnyException in) end
end
record Task title string; count int; end</lang>
Service Interface: ProxyFunctions.egl <lang EGL>package com.eglexamples.client;
library ProxyFunctions
function listTasks(continueLocation String in) returns (RosettaCodeJSON) {
@Rest{method = _GET, uriTemplate = "&cmcontinue={continueLocation}", requestFormat = None, responseFormat = JSON}
} end
function fetchPageDetail(title String in) returns (String) {
@Rest{method = _GET, uriTemplate = "?title={title}&action=raw", requestFormat = None, responseFormat = None}
} end
end
record RosettaCodeJSON
query Query; queryContinue QueryContinue{JSONName = "query-continue"};
end
record Query
categorymembers Categorymembers[];
end
record Categorymembers
cmcontinue string?; pageid int?; ns int?; title string?;
end
record QueryContinue
categorymembers Categorymembers;
end</lang>
Erlang
<lang erlang> -module(rosseta_examples). -include_lib("xmerl/include/xmerl.hrl").
-export([main/0]).
main() ->
application:start(inets), Titles = read_titles(empty), Result = lists:foldl(fun(Title,Acc) -> Acc + calculate_one(Title) end, 0, Titles), io:format("Total: ~p examples.\n",[Result]), application:stop(inets).
read_titles(CurrentContinue) ->
URL0 = "http://rosettacode.org/mw/api.php?" ++ "action=query&list=categorymembers&cmtitle=Category:Programming_Tasks" ++ "&cmlimit=500&format=xml", URL = case CurrentContinue of empty -> URL0; _ -> URL0 ++ "&cmcontinue=" ++ CurrentContinue end, {ok,Answer} = httpc:request(URL), {Document,_} = xmerl_scan:string(lists:last(tuple_to_list(Answer))), Continue = [Value || #xmlAttribute{value = Value} <- xmerl_xpath:string("//@cmcontinue", Document)], Titles = [Value || #xmlAttribute{value = Value} <- xmerl_xpath:string("//@title", Document)], case Continue of []-> Titles; [ContValue | _] -> Titles ++ read_titles(ContValue) end.
calculate_one(Title0) ->
Title = replace_chars(Title0), URL = "http://www.rosettacode.org/w/index.php?title=" ++ Title ++ "&action=raw", case httpc:request(URL) of {ok,Result} -> {match,Found} = re:run(lists:last(tuple_to_list(Result)), "\n=={{header(|)", [global]), io:format("~ts: ~p examples.\n",[Title0,length(Found)]), length(Found); {error,socket_closed_remotely} -> io:format("Socket closed remotely. Retry.\n"), calculate_one(Title0) end.
replace_chars(String) ->
replace_chars(String,[]).
replace_chars([$ | T],Acc) ->
replace_chars(T, [$_| Acc]);
replace_chars([$+| T],Acc) ->
replace_chars(T, lists:reverse("%2B") ++ Acc);
replace_chars([8211| T],Acc) ->
replace_chars(T, lists:reverse("%E2%80%93") ++ Acc);
replace_chars([Other| T],Acc) ->
replace_chars(T, [Other| Acc]);
replace_chars([],Acc) ->
lists:reverse(Acc).
</lang>
Outputs:
> rosseta_examples:main(). 100 doors: 165 examples. 24 game: 56 examples. 24 game/Solve: 33 examples. ... Zebra puzzle: 12 examples. Zeckendorf number representation: 18 examples. Zig-zag matrix: 65 examples. Total: 28629 examples.
F#
Using asynchronous workflows to perform downloads concurrently:
<lang fsharp>#r "System.Xml.Linq.dll"
let uri1 = "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml" let uri2 task = sprintf "http://www.rosettacode.org/w/index.php?title=%s&action=raw" task
[|for xml in (System.Xml.Linq.XDocument.Load uri1).Root.Descendants() do
for attrib in xml.Attributes() do if attrib.Name.LocalName = "title" then yield async { let uri = uri2 (attrib.Value.Replace(" ", "_") |> System.Web.HttpUtility.UrlEncode) use client = new System.Net.WebClient() let! html = client.AsyncDownloadString(System.Uri uri) let sols' = html.Split([|"{{header|"|], System.StringSplitOptions.None).Length - 1 lock stdout (fun () -> printfn "%s: %d examples" attrib.Value sols') return sols' }|]
|> Async.Parallel |> Async.RunSynchronously |> fun xs -> printfn "Total: %d examples" (Seq.sum xs)</lang>
This is 21× faster than the python thanks to the concurrency.
Factor
Runs in about a minute. The number of threads is limited to 10 avoid cloudfare's protection mechanism.
<lang factor>USING: arrays assocs concurrency.combinators concurrency.semaphores formatting hashtables http.client io json.reader kernel math math.parser sequences splitting urls.encoding ; IN: rosetta-code.count-examples
CONSTANT: list-url "http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&cmprop=title&format=json"
- titles ( query -- titles )
"query" of "categorymembers" of [ "title" of ] map ;
- continued-url ( query -- url/f )
"query-continue" of "categorymembers" of [ assoc>query list-url swap "&" glue ] [ f ] if* ;
- (all-programming-titles) ( titles url -- titles' url' )
http-get nip json> [ titles append ] [ continued-url ] bi [ (all-programming-titles) ] [ f ] if* ;
- all-programming-titles ( -- titles ) { } list-url (all-programming-titles) drop ;
CONSTANT: content-base-url "http://rosettacode.org/mw/index.php?title=&action=raw"
- content-url ( title -- url )
" " "_" replace "title" associate assoc>query content-base-url swap "&" glue ;
- occurences ( seq subseq -- n ) split-subseq length 1 - ;
- count-examples ( title -- n )
content-url http-get nip "=={{header|" occurences ;
- print-task ( title n -- ) "%s: %d examples.\n" printf ;
- print-total ( assoc -- ) values sum "Total: %d examples.\n" printf ;
- fetch-counts ( titles -- assoc )
10 <semaphore> [ [ dup count-examples 2array ] with-semaphore ] curry parallel-map ;
- print-counts ( titles -- )
[ [ print-task ] assoc-each nl ] [ print-total ] bi ;
- rosetta-examples ( -- )
all-programming-titles fetch-counts print-counts ;
MAIN: rosetta-examples</lang> Outputs:
100 doors: 169 examples. 24 game: 58 examples. ... Zeckendorf number representation: 22 examples. Zig-zag matrix: 66 examples. Total: 30745 examples.
Go
<lang go>package main
import (
"bytes" "encoding/xml" "fmt" "io" "io/ioutil" "net/http" "net/url" "strings"
)
func req(u string, foundCm func(string)) string {
resp, err := http.Get(u) if err != nil { fmt.Println(err) // connection or request fail return "" } defer resp.Body.Close() for p := xml.NewDecoder(resp.Body); ; { t, err := p.RawToken() switch s, ok := t.(xml.StartElement); { case err == io.EOF: return "" case err != nil: fmt.Println(err) return "" case !ok: continue case s.Name.Local == "cm": for _, a := range s.Attr { if a.Name.Local == "title" { foundCm(a.Value) } } case s.Name.Local == "categorymembers" && len(s.Attr) > 0 && s.Attr[0].Name.Local == "cmcontinue": return url.QueryEscape(s.Attr[0].Value) } } return ""
}
func main() {
taskQuery := "http://rosettacode.org/mw/api.php?action=query" + "&format=xml&list=categorymembers&cmlimit=500" + "&cmtitle=Category:Programming_Tasks" continueAt := req(taskQuery, count) for continueAt > "" { continueAt = req(taskQuery+"&cmcontinue="+continueAt, count) } fmt.Printf("Total: %d examples.\n", total)
}
var marker = []byte("=={{header|") var total int
func count(cm string) {
taskFmt := "http://rosettacode.org/mw/index.php?title=%s&action=raw" taskEsc := url.QueryEscape(strings.Replace(cm, " ", "_", -1)) resp, err := http.Get(fmt.Sprintf(taskFmt, taskEsc)) var page []byte if err == nil { page, err = ioutil.ReadAll(resp.Body) resp.Body.Close() } if err != nil { fmt.Println(err) return } examples := bytes.Count(page, marker) fmt.Printf("%s: %d\n", cm, examples) total += examples
}</lang>
- Output
- (May 25, 2011):
... Y combinator: 40 Yahoo! search interface: 10 Yin and yang: 18 Zig-zag matrix: 50 Total: 18290 examples.
Haskell
from HackageDB
<lang haskell>import Network.Browser import Network.HTTP import Network.URI import Data.List import Data.Maybe import Text.XML.Light import Control.Arrow
justifyR w = foldl ((.return).(++).tail) (replicate w ' ') showFormatted t n = t ++ ": " ++ justifyR 4 (show n)
getRespons url = do
rsp <- Network.Browser.browse $ do setAllowRedirects True setOutHandler $ const (return ()) -- quiet request $ getRequest url return $ rspBody $ snd rsp
getNumbOfExampels p = do
let pg = intercalate "_" $ words p rsp <- getRespons $ "http://www.rosettacode.org/w/index.php?title=" ++ pg ++ "&action=raw" let taskPage = rsp countEx = length $ filter (=="=={{header|") $ takeWhile(not.null) $ unfoldr (Just. (take 11 &&& drop 1)) taskPage return countEx
progTaskExamples = do
rsp <- getRespons "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"
let xmls = onlyElems $ parseXML $ rsp tasks = concatMap (map (fromJust.findAttr (unqual "title")). filterElementsName (== unqual "cm")) xmls
taskxx <- mapM getNumbOfExampels tasks let ns = taskxx tot = sum ns
mapM_ putStrLn $ zipWith showFormatted tasks ns putStrLn $ ("Total: " ++) $ show tot</lang>
some output: <lang haskell>*Main> progTaskExamples 100 doors: 56 24 game: 11 24 game Player: 9 99 Bottles of Beer: 73 Abstract type: 23 Ackermann Function: 61 Active object: 9 ... Total: 9156</lang>
Icon and Unicon
The following code uses features exclusive to Unicon. This version handles all tasks, not just the first 500.
<lang Unicon>$define RCINDEX "http://rosettacode.org/mw/api.php?format=xml&action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500" $define RCTASK "http://rosettacode.org/mw/index.php?action=raw&title=" $define RCUA "User-Agent: Unicon Rosetta 0.1" $define RCXUA "X-Unicon: http://unicon.org/" $define TASKTOT "* Total Tasks *" $define TOTTOT "* Total Headers*"
link strings link hexcvt
procedure main(A) # simple single threaded read all at once implementation
Tasks := table(0) every task := taskNames() do { Tasks[TASKTOT] +:= 1 # count tasks every lang := languages(task) do { # count languages Tasks[task] +:= 1 Tasks[TOTTOT] +:= 1 } } every insert(O := set(),key(Tasks)) # extract & sort keys O := put(sort(O--set(TOTTOT,TASKTOT)),TASKTOT,TOTTOT) # move totals to end every write(k := !O, " : ", Tasks[k]," examples.") # report
end
- Generate task names
procedure taskNames()
continue := "" while \(txt := ReadURL(RCINDEX||continue)) do { txt ? { while tab(find("<cm ") & find(s :="title=\"")+*s) do suspend tab(find("\""))\1 if tab(find("cmcontinue=")) then { continue := "&"||tab(upto(' \t')) } else break } }
end
- Generate language headers in a task
procedure languages(task)
static WS initial WS := ' \t' page := ReadURL(RCTASK||CleanURI(task)) page ? while (tab(find("\n==")),tab(many(WS))|"",tab(find("{{"))) do { header := tab(find("==")) header ? { while tab(find("{{header|")) do { suspend 2(="",tab(find("")))\1 } } }
end
procedure CleanURI(u) #: clean up a URI
static tr,dxml # xml & http translation initial { tr := table() every c := !string(~(&digits++&letters++'-_.!~*()/\'`')) do tr[c] := "%"||hexstring(ord(c),2) every /tr[c := !string(&cset)] := c tr[" "] := "_" # wiki convention every push(dxml := [],"&#"||right(ord(c := !"&<>'\""),3,"0")||";",c) } dxml[1] := u # insert URI as 1st arg u := replacem!dxml # de-xml it every (c := "") ||:= tr[!u] # reencode everything c := replace(c,"%3E","'") # Hack to put single quotes back in c := replace(c,"%26quot%3B","\"") # Hack to put double quotes back in return c
end
procedure ReadURL(url) #: read URL into string
page := open(url,"m",RCUA,RCXUA) | stop("Unable to open ",url) text := "" if page["Status-Code"] < 300 then while text ||:= reads(page,-1) else write(&errout,image(url),": ", page["Status-Code"]," ",page["Reason-Phrase"]) close(page) return text
end</lang>
strings provides replacem hexcvt provides hexstring
Sample Output for July 6, 2013 (abridged):
100 doors : 171 examples. 24 game : 60 examples. 24 game/Solve : 37 examples. 9 billion names of God the integer : 12 examples. 99 Bottles of Beer : 199 examples. A+B : 137 examples. Abstract type : 54 examples. Accumulator factory : 67 examples. Ackermann function : 137 examples. ... Y combinator : 56 examples. Yahoo! search interface : 18 examples. Yin and yang : 39 examples. Zebra puzzle : 12 examples. Zeckendorf arithmetic : 3 examples. Zeckendorf number representation : 21 examples. Zig-zag matrix : 67 examples. * Total Tasks * : 676 examples. * Total Headers* : 31146 examples.
J
Solution:
Using getCategoryMembers
from Find unimplemented tasks.
<lang j>require 'web/gethttp'
getAllTaskSolnCounts=: monad define
tasks=. getCategoryMembers 'Programming_Tasks' counts=. getTaskSolnCounts &> tasks tasks;counts
)
getTaskSolnCounts=: monad define
makeuri=. 'http://www.rosettacode.org/w/index.php?title=' , ,&'&action=raw' wikidata=. gethttp makeuri urlencode y ([: +/ '{{header|'&E.) wikidata
)
formatSolnCounts=: monad define
'tasks counts'=. y tasks=. tasks , &.>':' res=. ;:^:_1 tasks ,. (8!:0 counts) ,. <'examples.' res , 'Total examples: ' , ": +/counts
)</lang>
Example Usage: <lang j> formatSolnCounts getAllTaskSolnCounts 100 doors: 61 examples. 24 game: 15 examples. 24 game Player: 11 examples. 99 Bottles of Beer: 76 examples. ...</lang>
Java
<lang java5> import java.util.ArrayList; import ScreenScrape;
public class CountProgramExamples {
private static final String baseURL = "http://rosettacode.org/wiki/"; private static final String rootURL = "http://www.rosettacode.org/w/" + "api.php?action=query&list=categorymembers" + "&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"; private static final String taskBegin = "title=\""; private static final String taskEnd = "\""; private static final String exmplBegin = ""; private static final String exmplEnd = ""; private static final String editBegin = "";
/** * @param args */ public static void main(String[] args) { int exTotal = 0; try { // Get root query results ArrayList<String> tasks = new ArrayList<String>(); ScreenScrape ss = new ScreenScrape(); String rootPage = ss.read(rootURL); while (rootPage.contains(taskBegin)) { rootPage = rootPage.substring(rootPage.indexOf(taskBegin) + taskBegin.length()); String title = rootPage.substring(0, rootPage.indexOf(taskEnd)); if (!title.contains("Category:")) { tasks.add(title); } rootPage = rootPage.substring(rootPage.indexOf(taskEnd)); } // Loop through each task and print count for (String task : tasks) { String title = task.replaceAll("'", "'"); String taskPage = ss.read(baseURL + title.replaceAll(" ", "_")); int exSubTot; if (taskPage.contains(exmplBegin)) { int startPos = taskPage.lastIndexOf(exmplBegin) + exmplBegin.length(); String countStr = taskPage.substring(startPos, taskPage.indexOf(exmplEnd, startPos)); exSubTot = Integer .parseInt(countStr.contains(".") ? countStr .substring(0, countStr.indexOf(".")) : countStr); } else { exSubTot = 0; while (taskPage.contains(editBegin)) { taskPage = taskPage.substring(taskPage .indexOf(editBegin) + editBegin.length()); exSubTot++; } } exTotal += exSubTot; System.out.println(title + ": " + exSubTot + " examples."); } // Print total System.out.println("\nTotal: " + exTotal + " examples."); } catch (Exception e) { System.out.println(title); System.out.println(startPos + ":" + taskPage.indexOf(exmplEnd, startPos)); System.out.println(taskPage); e.printStackTrace(System.out); } }
} </lang> ScreenScrape class
jq
jq does not duplicate the functionality of `curl` but works seamlessly with it, as illustrated by the following bash script. Note in particular the use of jq's `@uri` filter in the bash function `titles`.
<lang bash>#!/bin/bash
- Produce lines of the form: URI TITLE
function titles {
local uri="http://www.rosettacode.org/mw/api.php?action=query&list=categorymembers" uri+="&cmtitle=Category:Programming_Tasks&cmlimit=5000&format=json" curl -Ss "$uri" | jq -r '.query.categorymembers[] | .title | "\(@uri) \(.)"'
}
- Syntax: count URI
function count {
local uri="$1" curl -Ss "http://rosettacode.org/mw/index.php?title=${uri}&action=raw" | jq -R -n 'reduce (inputs|select(test("=={{header\\|"))) as $x(0; .+1)'
}
local n=0 i while read uri title do
i=$(count "$uri") echo "$title: $i examples." n=$((n + i))
done < <(titles) echo Total: $n examples.</lang>
- Output:
100 doors: 252 examples. 15 Puzzle Game: 36 examples. 2048: 24 examples. ... Order two numerical lists: 65 examples. Ordered Partitions: 28 examples. Ordered words: 85 examples. Palindrome detection: 136 examples. Total: 32416 examples.
Lasso
<lang Lasso>local(root = json_deserialize(curl('http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=10&format=json')->result)) local(tasks = array, title = string, urltitle = string, thiscount = 0, totalex = 0) with i in #root->find('query')->find('categorymembers') do => {^ #thiscount = 0 #title = #i->find('title') #urltitle = #i->find('title') #urltitle->replace(' ','_')
#title+': ' local(src = curl('http://rosettacode.org/mw/index.php?title='+#urltitle->asBytes->encodeurl+'&action=raw')->result->asString) #thiscount = (#src->split('==[[:Category:{PercentEncode Xr}
else
{Append &%|{PercentEncode Xr}
else
{Append &%]] [[Category:{PercentEncode Xr}
else
{Append &%]] Property "Implemented in language" (as page type) with input value "{PercentEncode Xr}</br> else</br> {Append &%" contains invalid characters or is incomplete and therefore can cause unexpected results during a query or annotation process.
end
end
end
fun {ToHex2 X}
[{ToHex1 X div 16} {ToHex1 X mod 16}]
end
fun {ToHex1 X}
if X >= 0 andthen X =< 9 then &0 + X
elseif X >= 10 andthen X =< 15 then &A + X - 10
end
end
in
{Main}</lang>
Example output:
100 doors: 86 examples. 24 game: 22 examples. 24 game/Solve: 15 examples. 99 Bottles of Beer: 108 examples. A+B: 59 examples. ... Xiaolin Wu's line algorithm: 5 examples. Y combinator: 29 examples. Yahoo! Search: 10 examples. Zig-zag matrix: 43 examples. Total: 14099 examples.
Perl
<lang Perl>use LWP::Simple;
my $site = "http://rosettacode.org"; my $list_url = "/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml";
for (get("$site$list_url") =~ /cm.*?title="(.*?)"/g) {
(my $slug = $_) =~ tr/ /_/; my $count = () = get("$site/wiki/$slug") =~ /toclevel-1/g; print "$_: $count examples\n";
}</lang>
<lang Perl>use v5.10; use Mojo::UserAgent;
my $site = "http://rosettacode.org"; my $list_url = "/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml";
my $ua = Mojo::UserAgent->new; $ua->get("$site$list_url")->res->dom->find('cm')->each(sub {
(my $slug = $_->{title}) =~ tr/ /_/; my $count = $ua->get("$site/wiki/$slug")->res->dom->find("#toc .toclevel-1")->size; say "$_->{title}: $count examples";
});</lang>
Perl 6
<lang perl6>use HTTP::UserAgent; use URI::Escape; use JSON::Fast;
- Friendlier descriptions for task categories
my %cat = (
'Programming_Tasks' => 'Task', 'Draft_Programming_Tasks' => 'Draft'
);
my $client = HTTP::UserAgent.new;
my $url = 'http://rosettacode.org/mw';
my $hashfile = './RC_Task_count.json'; my $tablefile = './RC_Task_count.txt';
my %tasks;
- =begin update
note 'Retrieving task information...';
for %cat.keys -> $cat {
mediawiki-query( $url, 'pages', :generator<categorymembers>, :gcmtitle("Category:$cat"), :gcmlimit<350>, :rawcontinue(), :prop<title> ).map({ my $page = mediawiki-query( $url, 'pages', :titles(.<title>), :prop<revisions>, :rvprop<content>, ); my $count = +$page.comb(/'=={{header|'/); %tasks{.<title>} = {'cat' => %cat{$cat}, :$count}; (state $throbber += 1) mod= 40; print "\b" x 40, ' ' x 40, "\b" x 40, '█' x $throbber; })
}
print "\b" x 40, ' ' x 40, "\b" x 40;
note "\nTask information saved to local file: {$hashfile.IO.absolute}"; $hashfile.IO.spurt(%tasks.&to-json);
- =end update
- Load information from local file
%tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( );
- Convert saved task / author info to a table
note "\nBuilding table..."; my $count = +%tasks; my $taskcnt = +%tasks.grep: *.value.<cat> eq %cat<Programming_Tasks>; my $draftcnt = $count - $taskcnt;
- Dump table to a file
my $out = open($tablefile, :w) or die "$!\n";
- Add table boilerplate and caption
$out.say:
'
'{|class="wikitable sortable"', "\n", "|+ As of { Date.today } :: Tasks: { $taskcnt } :: Draft Tasks: { $draftcnt } :: Total: { $count }\n", "! Count !! Task !! Category"
- Sort tasks by count then add row
for %tasks.sort: -*.value<count> -> $task {
$out.say: "|-\n", "| { $task.value<count> }\n", ( $task.key ~~ /\d/ ?? "|data-sort-value=\"{ $task.key.&naturally }\"| { $task.key }\n" !! "| { $task.key }\n" ), "| { $task.value<cat> }"
}
$out.say( "|}\n", '' );
$out.close;
note "Table file saved as: {$tablefile.IO.absolute}";
sub mediawiki-query ($site, $type, *%query) {
my $url = "$site/api.php?" ~ uri-query-string( :action<query>, :format<json>, :formatversion<2>, |%query); my $continue = ;
gather loop { my $response = $client.get("$url&$continue"); my $data = from-json($response.content); take $_ for $data.<query>.{$type}.values; $continue = uri-query-string |($data.<query-continue>{*}».hash.hash or last); }
}
sub uri-query-string (*%fields) { %fields.map({ "{.key}={uri-escape .value}" }).join("&") }
sub naturally ($a) { $a.lc.subst(/(\d+)/, ->$/ {0~(65+$0.chars).chr~$0},:g) } </lang>
- Output:
Count | Task | Category |
---|---|---|
383 | Hello world/Text | Task |
288 | 99 Bottles of Beer | Task |
266 | FizzBuzz | Task |
265 | 100 doors | Task |
244 | Fibonacci sequence | Task |
242 | Comments | Task |
236 | Factorial | Task |
224 | A+B | Task |
215 | Empty program | Task |
208 | Function definition | Task |
196 | Loops/For | Task |
195 | Loops/Infinite | Task |
194 | Ackermann function | Task |
190 | Loops/While | Task |
187 | Arrays | Task |
185 | Reverse a string | Task |
174 | Arithmetic/Integer | Task |
173 | Greatest common divisor | Task |
172 | Conditional structures | Task |
171 | Greatest element of a list | Task |
167 | Averages/Arithmetic mean | Task |
164 | Integer comparison | Task |
161 | Increment a numerical string | Task |
160 | Loops/For with a specified step | Task |
159 | Loops/Downward for | Task |
159 | Array concatenation | Task |
158 | Repeat a string | Task |
156 | Loops/Foreach | Task |
155 | Copy a string | Task |
155 | Boolean values | Task |
150 | Hello world/Graphical | Task |
149 | Sum and product of an array | Task |
148 | String length | Task |
148 | Even or odd | Task |
148 | String case | Task |
146 | Hailstone sequence | Task |
146 | Character codes | Task |
144 | Loops/Do-while | Task |
144 | Apply a callback to an array | Task |
141 | Hello world/Newline omission | Task |
140 | String concatenation | Task |
139 | Loops/N plus one half | Task |
138 | Binary digits | Task |
138 | Sum of a series | Task |
138 | Tokenize a string | Task |
137 | Loops/Break | Task |
137 | Palindrome detection | Task |
137 | Filter | Task |
137 | Sum of squares | Task |
137 | Generic swap | Task |
136 | Integer sequence | Task |
136 | Rot-13 | Task |
136 | Logical operations | Task |
135 | Execute a system command | Task |
134 | Sieve of Eratosthenes | Task |
133 | Towers of Hanoi | Task |
131 | Sort an integer array | Task |
130 | Dot product | Task |
129 | File input/output | Task |
129 | Leap year | Task |
127 | Associative array/Creation | Task |
126 | Sorting algorithms/Bubble sort | Task |
126 | Higher-order functions | Task |
126 | Remove duplicate elements | Task |
125 | Determine if a string is numeric | Task |
124 | Array length | Task |
123 | User input/Text | Task |
123 | Quine | Task |
123 | Hello world/Standard error | Task |
123 | Empty string | Task |
122 | Guess the number | Task |
122 | Read entire file | Task |
121 | Command-line arguments | Task |
121 | Roman numerals/Encode | Task |
120 | Create a file | Task |
120 | Loops/Continue | Task |
119 | Primality by trial division | Task |
118 | Loop over multiple arrays simultaneously | Task |
118 | Ethiopian multiplication | Task |
118 | Bitwise operations | Task |
117 | Sleep | Task |
117 | Least common multiple | Task |
116 | Sorting algorithms/Quicksort | Task |
116 | System time | Task |
116 | Day of the week | Task |
116 | Factors of an integer | Task |
115 | Substring | Task |
115 | Check that file exists | Task |
115 | Happy numbers | Task |
115 | Include a file | Task |
114 | Caesar cipher | Task |
114 | Literals/String | Task |
113 | Literals/Integer | Task |
113 | Mutual recursion | Task |
112 | Pascal's triangle | Task |
112 | Detect division by zero | Task |
111 | Luhn test of credit card numbers | Task |
111 | Flatten a list | Task |
111 | Averages/Root mean square | Task |
111 | Balanced brackets | Task |
110 | Stack | Task |
110 | Program termination | Task |
109 | Knuth shuffle | Task |
109 | File size | Task |
108 | Variables | Task |
108 | Compound data type | Task |
107 | Read a file line by line | Task |
107 | Associative array/Iteration | Task |
107 | Date format | Task |
106 | Rename a file | Task |
106 | Search a list | Task |
106 | Generate lower case ASCII alphabet | Task |
106 | Real constants and functions | Task |
106 | Delete a file | Task |
105 | Mandelbrot set | Task |
104 | Count in octal | Task |
104 | Return multiple values | Task |
104 | ABC Problem | Task |
104 | Input loop | Task |
104 | Function composition | Task |
104 | Null object | Task |
103 | Loops/Nested | Task |
103 | Classes | Task |
103 | Sorting algorithms/Insertion sort | Task |
103 | Case-sensitivity of identifiers | Task |
103 | Binary search | Task |
103 | Formatted numeric output | Task |
102 | Averages/Median | Task |
102 | Hostname | Task |
102 | Count occurrences of a substring | Task |
101 | Hash from two arrays | Task |
101 | Arithmetic/Complex | Task |
101 | Random numbers | Task |
100 | Pick random element | Task |
100 | Multiplication tables | Task |
100 | HTTP | Task |
99 | Pangram checker | Task |
99 | Matrix multiplication | Task |
99 | Matrix transposition | Task |
99 | N-queens problem | Task |
99 | Find limit of recursion | Task |
99 | Anagrams | Task |
99 | Environment variables | Task |
98 | Conway's Game of Life | Task |
98 | Guess the number/With feedback | Task |
98 | Horner's rule for polynomial evaluation | Task |
97 | Create a two-dimensional array at runtime | Task |
97 | Align columns | Task |
97 | Accumulator factory | Task |
97 | Perfect numbers | Task |
96 | Haversine formula | Task |
96 | Roman numerals/Decode | Task |
96 | Temperature conversion | Task |
96 | Assertions | Task |
96 | Identity matrix | Task |
96 | Strip a set of characters from a string | Task |
95 | String matching | Task |
95 | Averages/Pythagorean means | Task |
95 | Evaluate binomial coefficients | Task |
94 | Middle three digits | Task |
94 | Substring/Top and tail | Task |
94 | Variadic function | Task |
93 | Run-length encoding | Task |
93 | Zero to the zero power | Task |
93 | Catalan numbers | Task |
92 | Zig-zag matrix | Task |
92 | Strip whitespace from a string/Top and tail | Task |
92 | Arithmetic-geometric mean | Task |
92 | Program name | Task |
92 | Shell one-liner | Task |
91 | Trigonometric functions | Task |
91 | Exceptions | Task |
90 | Infinity | Task |
90 | String interpolation (included) | Task |
90 | Prime decomposition | Task |
90 | Letter frequency | Task |
90 | Regular expressions | Task |
89 | Combinations | Task |
88 | Sorting algorithms/Merge sort | Task |
88 | Random number generator (included) | Task |
88 | 24 game | Task |
88 | Sierpinski triangle | Task |
88 | Sorting algorithms/Selection sort | Task |
88 | Short-circuit evaluation | Task |
88 | Power set | Task |
88 | Enumerations | Task |
87 | One-dimensional cellular automata | Task |
87 | Collections | Task |
87 | Ordered words | Task |
86 | Anonymous recursion | Task |
86 | Interactive programming | Task |
85 | Levenshtein distance | Task |
85 | Comma quibbling | Task |
85 | Exponentiation operator | Task |
85 | Queue/Definition | Task |
85 | Sequence of non-squares | Task |
84 | Reverse words in a string | Task |
84 | Walk a directory/Non-recursively | Task |
84 | Range extraction | Task |
84 | First-class functions | Task |
84 | Arbitrary-precision integers (included) | Task |
84 | Look-and-say sequence | Task |
84 | Permutations | Task |
83 | Cumulative standard deviation | Task |
83 | Sort using a custom comparator | Task |
82 | Inheritance/Single | Task |
82 | Range expansion | Task |
82 | Nth root | Task |
82 | Bulls and cows | Task |
81 | Symmetric difference | Task |
81 | MD5 | Task |
81 | Sorting algorithms/Gnome sort | Task |
81 | Sum multiples of 3 and 5 | Task |
81 | Window creation | Task |
81 | String prepend | Task |
81 | Five weekends | Task |
80 | Evolutionary algorithm | Task |
80 | Y combinator | Task |
80 | Time a function | Task |
80 | Create an HTML table | Task |
79 | Sum digits of an integer | Task |
79 | String append | Task |
79 | Forward difference | Task |
78 | Averages/Simple moving average | Task |
78 | Call a function | Task |
78 | File modification time | Task |
78 | Price fraction | Task |
78 | Monty Hall problem | Task |
77 | Greatest subsequential sum | Task |
77 | Vector products | Task |
77 | Sierpinski carpet | Task |
77 | Abstract type | Task |
77 | Dragon curve | Task |
76 | Spiral matrix | Task |
76 | Menu | Task |
76 | Babbage problem | Task |
76 | Hamming numbers | Task |
76 | Langton's ant | Task |
76 | Sorting algorithms/Cocktail sort | Task |
76 | Entropy | Task |
75 | Map range | Task |
75 | Averages/Mode | Task |
75 | Walk a directory/Recursively | Task |
75 | Sorting algorithms/Bogosort | Task |
75 | Hello world/Line printer | Task |
74 | Simple windowed application | Task |
74 | Show the epoch | Task |
74 | Non-decimal radices/Convert | Task |
74 | The Twelve Days of Christmas | Task |
74 | Execute Brain**** | Task |
74 | JSON | Task |
74 | Web scraping | Task |
74 | Harshad or Niven series | Task |
73 | Monte Carlo methods | Task |
73 | Set | Task |
73 | Tree traversal | Task |
73 | Digital root | Task |
73 | Closures/Value capture | Task |
73 | Gray code | Task |
72 | Read a specific line from a file | Task |
72 | Queue/Usage | Task |
72 | SEDOLs | Task |
72 | Introspection | Task |
72 | Man or boy test | Task |
71 | Last Friday of each month | Task |
71 | Terminal control/Ringing the terminal bell | Task |
71 | Singly-linked list/Traversal | Task |
71 | CSV to HTML translation | Task |
71 | Number reversal game | Task |
71 | Sort an array of composite structures | Task |
71 | Literals/Floating point | Task |
70 | Count in factors | Task |
70 | CSV data manipulation | Task |
70 | Keyboard input/Obtain a Y or N response | Task |
70 | Bitmap | Task |
70 | URL decoding | Task |
70 | Sorting algorithms/Heapsort | Task |
69 | Linear congruential generator | Task |
69 | Sockets | Task |
69 | Amicable pairs | Task |
69 | Floyd's triangle | Task |
68 | Abundant, deficient and perfect number classifications | Task |
68 | String comparison | Task |
68 | Find the missing permutation | Task |
68 | List comprehensions | Task |
68 | Josephus problem | Task |
68 | XML/Input | Task |
68 | Take notes on the command line | Task |
68 | Top rank per group | Task |
68 | Knapsack problem/0-1 | Task |
68 | Special characters | Task |
67 | Strip comments from a string | Task |
67 | Concurrent computing | Task |
67 | Kaprekar numbers | Task |
67 | Number names | Task |
67 | Address of a variable | Task |
67 | Date manipulation | Task |
67 | Catamorphism | Task |
67 | Roots of unity | Task |
67 | Sorting algorithms/Shell sort | Task |
67 | Terminal control/Clear the screen | Task |
67 | Find common directory path | Task |
66 | Unicode variable names | Task |
66 | URL encoding | Task |
66 | Singly-linked list/Element definition | Task |
66 | Stair-climbing puzzle | Task |
66 | Non-decimal radices/Output | Task |
66 | Playing cards | Task |
66 | Box the compass | Task |
66 | Soundex | Task |
66 | Dynamic variable names | Task |
65 | Polymorphism | Task |
65 | Equilibrium index | Task |
65 | Order two numerical lists | Task |
65 | Longest common subsequence | Task |
65 | Lucas-Lehmer test | Task |
65 | Bitmap/Bresenham's line algorithm | Task |
64 | Sorting algorithms/Counting sort | Task |
64 | Empty directory | Task |
64 | Find the last Sunday of each month | Task |
64 | Write float arrays to a text file | Task |
64 | Flow-control structures | Task |
63 | Sorting algorithms/Comb sort | Task |
63 | Anagrams/Deranged anagrams | Task |
63 | Parsing/RPN calculator algorithm | Task |
63 | Multifactorial | Task |
63 | Hello world/Web server | Task |
63 | Multiple distinct objects | Task |
63 | Semordnilap | Task |
63 | Here document | Task |
63 | Word wrap | Task |
63 | N'th | Task |
63 | Forest fire | Task |
63 | Read a configuration file | Task |
63 | Averages/Mean angle | Task |
62 | Largest int from concatenated ints | Task |
62 | Sorting algorithms/Stooge sort | Task |
62 | Guess the number/With feedback (player) | Task |
62 | Compare a list of strings | Task |
62 | Euler method | Task |
62 | Enforced immutability | Task |
62 | Fibonacci n-step number sequences | Task |
62 | Jensen's Device | Task |
62 | Hofstadter Q sequence | Task |
62 | Pythagorean triples | Task |
62 | Exceptions/Catch an exception thrown in a nested call | Task |
62 | Vigenère cipher | Task |
62 | Count the coins | Task |
62 | Convert seconds to compound duration | Task |
62 | Constrained random points on a circle | Task |
61 | Sudoku | Task |
61 | Trabb Pardo–Knuth algorithm | Task |
61 | Call an object method | Task |
61 | Sort disjoint sublist | Task |
61 | Long multiplication | Task |
61 | Hello world/Newbie | Task |
61 | Draw a sphere | Task |
61 | Animation | Task |
60 | Sort stability | Task |
60 | Execute HQ9+ | Task |
60 | Operator precedence | Task |
60 | Numerical integration | Task |
60 | Probabilistic choice | Task |
60 | Strip control codes and extended characters from a string | Task |
60 | Singly-linked list/Element insertion | Task |
59 | Four bit adder | Task |
59 | Named parameters | Task |
59 | Runtime evaluation | Task |
59 | Gamma function | Task |
59 | Write language name in 3D ASCII | Task |
59 | Fork | Task |
59 | Undefined values | Task |
58 | Benford's law | Task |
58 | Roots of a quadratic function | Task |
58 | Text processing/Max licenses in use | Task |
58 | One of n lines in a file | Task |
58 | Variable size/Get | Task |
58 | Remove lines from a file | Task |
58 | Call a foreign-language function | Task |
57 | Fractal tree | Task |
57 | Optional parameters | Task |
57 | Priority queue | Task |
57 | Phrase reversals | Task |
57 | Roots of a function | Task |
57 | IBAN | Task |
57 | Quaternion type | Task |
57 | Pi | Task |
57 | Runge-Kutta method | Task |
57 | Proper divisors | Draft |
57 | Arithmetic/Rational | Task |
57 | Closest-pair problem | Task |
57 | Rock-paper-scissors | Task |
57 | Combinations with repetitions | Task |
56 | Memory allocation | Task |
56 | Catalan numbers/Pascal's triangle | Task |
56 | Magic squares of odd order | Task |
56 | Almost prime | Task |
56 | Horizontal sundial calculations | Task |
56 | Host introspection | Task |
56 | HTTPS | Task |
56 | Hofstadter-Conway $10,000 sequence | Task |
56 | SHA-1 | Task |
56 | Zeckendorf number representation | Task |
56 | Self-describing numbers | Task |
56 | Van der Corput sequence | Task |
55 | Special variables | Task |
55 | Knapsack problem/Unbounded | Task |
55 | AKS test for primes | Task |
55 | Narcissistic decimal number | Task |
55 | Modular inverse | Task |
55 | Sorting algorithms/Sleep sort | Task |
55 | Cholesky decomposition | Task |
55 | Extend your language | Task |
55 | XML/Output | Task |
55 | CRC-32 | Task |
55 | Sorting algorithms/Pancake sort | Task |
55 | Currying | Task |
55 | Fast Fourier transform | Task |
54 | Documentation | Task |
54 | 24 game/Solve | Task |
54 | Partial function application | Task |
54 | Jump anywhere | Task |
54 | Maze generation | Task |
54 | SHA-256 | Task |
54 | Non-decimal radices/Input | Task |
53 | Stem-and-leaf plot | Task |
53 | Binary strings | Task |
53 | Globally replace text in several files | Task |
53 | Test a function | Task |
53 | Calendar | Task |
53 | Reduced row echelon form | Task |
53 | Huffman coding | Task |
53 | Animate a pendulum | Task |
53 | Yin and yang | Task |
53 | Factors of a Mersenne number | Task |
53 | Old lady swallowed a fly | Task |
53 | Pernicious numbers | Task |
53 | Inheritance/Multiple | Task |
52 | Fibonacci word | Task |
52 | Best shuffle | Task |
52 | Extreme floating point values | Task |
52 | Sorting algorithms/Bead sort | Task |
52 | Odd word problem | Task |
52 | Synchronous concurrency | Task |
52 | XML/XPath | Task |
52 | Scope modifiers | Task |
52 | Write entire file | Task |
51 | Knapsack problem/Continuous | Task |
51 | Rep-string | Task |
51 | Sequence of primes by trial division | Task |
51 | Repeat | Draft |
51 | Dinesman's multiple-dwelling problem | Task |
51 | Hash join | Task |
51 | Arithmetic evaluation | Task |
51 | Rosetta Code/Count examples | Task |
51 | Singleton | Task |
50 | Miller–Rabin primality test | Task |
50 | Unbias a random generator | Task |
50 | Compile-time calculation | Task |
50 | Brownian tree | Task |
50 | Unix/ls | Task |
50 | Truncate a file | Task |
50 | Stack traces | Task |
50 | Continued fraction | Task |
50 | Draw a clock | Task |
50 | Runtime evaluation/In an environment | Task |
50 | Add a variable to a class instance at runtime | Task |
50 | Sorting algorithms/Permutation sort | Task |
50 | Semiprime | Task |
49 | Knight's tour | Task |
49 | Averages/Mean time of day | Task |
49 | Plot coordinate pairs | Task |
49 | Deal cards for FreeCell | Task |
49 | Tic-tac-toe | Task |
49 | Euler's sum of powers conjecture | Task |
49 | LZW compression | Task |
49 | Morse code | Task |
49 | Topological sort | Task |
48 | Pointers and references | Task |
48 | Generator/Exponential | Task |
48 | Circles of given radius through two points | Task |
48 | I before E except after C | Task |
48 | Modular exponentiation | Task |
48 | Modulinos | Draft |
48 | Unicode strings | Task |
48 | Terminal control/Display an extended character | Task |
47 | Bitmap/Write a PPM file | Task |
47 | Send email | Task |
47 | Left factorials | Task |
47 | Split a character string based on change of character | Task |
47 | Non-continuous subsequences | Task |
47 | Wireworld | Task |
47 | Dutch national flag problem | Task |
47 | Integer overflow | Task |
47 | Multisplit | Task |
47 | Statistics/Basic | Task |
47 | Doubly-linked list/Element definition | Task |
47 | Mouse position | Task |
47 | Rosetta Code/Rank languages by popularity | Task |
46 | Grayscale image | Task |
46 | Truncatable primes | Task |
46 | Text processing/2 | Task |
46 | Nested function | Task |
46 | User input/Graphical | Task |
46 | Text processing/1 | Task |
45 | XML/DOM serialization | Task |
45 | JortSort | Task |
45 | Define a primitive data type | Task |
45 | Draw a cuboid | Task |
45 | Random number generator (device) | Task |
45 | Thue-Morse | Task |
45 | Maximum triangle path sum | Task |
45 | Respond to an unknown method call | Task |
45 | Ludic numbers | Task |
45 | First-class functions/Use numbers analogously | Task |
45 | Stable marriage problem | Task |
45 | Seven-sided dice from five-sided dice | Task |
45 | Handle a signal | Task |
45 | Munchausen numbers | Task |
44 | Chinese remainder theorem | Task |
44 | Table creation/Postal addresses | Task |
44 | Delegates | Task |
44 | Sierpinski triangle/Graphical | Task |
44 | Heronian triangles | Task |
44 | Population count | Task |
44 | Matrix-exponentiation operator | Task |
44 | Ternary logic | Task |
44 | General FizzBuzz | Task |
43 | Discordian date | Task |
43 | Longest increasing subsequence | Task |
43 | Call a function in a shared library | Task |
43 | Bernoulli numbers | Task |
43 | Keyboard input/Keypress check | Task |
43 | Munching squares | Task |
43 | Quickselect algorithm | Task |
43 | Terminal control/Cursor positioning | Task |
42 | Mad Libs | Task |
42 | Emirp primes | Task |
42 | Send an unknown method call | Task |
42 | 9 billion names of God the integer | Task |
42 | Polymorphic copy | Task |
42 | 15 Puzzle Game | Task |
41 | Doubly-linked list/Element insertion | Task |
41 | Colour bars/Display | Task |
41 | Strip block comments | Task |
41 | Inverted syntax | Task |
41 | Longest string challenge | Task |
41 | Two Sum | Draft |
41 | Convert decimal number to rational | Task |
41 | Holidays related to Easter | Task |
41 | Color of a screen pixel | Task |
41 | Rate counter | Task |
41 | Universal Turing machine | Task |
41 | Dining philosophers | Task |
41 | Make directory path | Task |
41 | Exponentiation order | Task |
41 | Iterated digits squaring | Task |
41 | Execute a Markov algorithm | Task |
41 | Hofstadter Figure-Figure sequences | Task |
40 | Echo server | Task |
40 | Last letter-first letter | Task |
40 | Doubly-linked list/Traversal | Task |
40 | Parsing/Shunting-yard algorithm | Task |
40 | Verify distribution uniformity/Naive | Task |
40 | Move-to-front algorithm | Task |
39 | GUI component interaction | Task |
39 | Get system command output | Task |
39 | Zebra puzzle | Task |
39 | Search a list of records | Task |
39 | Archimedean spiral | Task |
39 | Polynomial regression | Task |
39 | Bitmap/Read a PPM file | Task |
39 | Extract file extension | Draft |
39 | Barnsley fern | Task |
39 | Greyscale bars/Display | Task |
39 | Bitmap/Flood fill | Task |
38 | Polynomial long division | Task |
38 | History variables | Task |
38 | Digital root/Multiplicative digital root | Task |
38 | FASTA format | Task |
38 | Set consolidation | Task |
38 | Determine if only one instance is running | Task |
38 | Sorting algorithms/Strand sort | Task |
38 | Problem of Apollonius | Task |
38 | Secure temporary file | Task |
38 | Sparkline in unicode | Task |
38 | DNS query | Task |
38 | Atomic updates | Task |
38 | OpenGL | Task |
37 | Fractran | Task |
37 | Variable size/Set | Task |
37 | Pig the dice game | Task |
37 | Parametric polymorphism | Task |
37 | Terminal control/Inverse video | Task |
37 | Image noise | Task |
37 | Perfect shuffle | Task |
37 | Subtractive generator | Task |
36 | Dijkstra's algorithm | Draft |
36 | Metaprogramming | Task |
36 | Generate Chess960 starting position | Task |
36 | Pascal matrix generation | Task |
36 | Narcissist | Task |
36 | Doubly-linked list/Definition | Task |
36 | Terminal control/Coloured text | Task |
36 | Active object | Task |
36 | Inverted index | Task |
36 | Department Numbers | Task |
36 | MD5/Implementation | Task |
36 | Permutations by swapping | Task |
36 | Stern-Brocot sequence | Task |
36 | Terminal control/Dimensions | Task |
36 | Twelve statements | Task |
35 | Validate International Securities Identification Number | Task |
35 | Percentage difference between images | Task |
35 | Append a record to the end of a text file | Task |
35 | Ray-casting algorithm | Task |
35 | Knapsack problem/Bounded | Task |
35 | Subleq | Task |
35 | Farey sequence | Task |
35 | Kronecker product | Task |
35 | Sum to 100 | Task |
35 | Base64 encode data | Draft |
35 | Bulls and cows/Player | Task |
35 | Matrix arithmetic | Task |
35 | Visualize a tree | Task |
35 | Permutations/Derangements | Task |
35 | Leonardo numbers | Task |
35 | Bitmap/Midpoint circle algorithm | Task |
35 | Variable-length quantity | Task |
35 | Smith numbers | Task |
34 | Average loop length | Task |
34 | Longest common prefix | Draft |
34 | Element-wise operations | Task |
34 | Self-referential sequence | Task |
34 | Calendar - for "REAL" programmers | Task |
34 | Tokenize a string with escaping | Task |
34 | Jaro distance | Task |
34 | Keyboard input/Flush the keyboard buffer | Task |
34 | Statistics/Normal distribution | Task |
34 | Parallel calculations | Task |
34 | Balanced ternary | Task |
34 | GUI enabling/disabling of controls | Task |
34 | Hickerson series of almost integers | Task |
34 | Chaos game | Task |
33 | Parsing/RPN to infix conversion | Task |
33 | Start from a main routine | Task |
33 | Gaussian elimination | Task |
33 | Password generator | Task |
33 | Amb | Task |
33 | Sorting algorithms/Radix sort | Task |
33 | Naming conventions | Task |
33 | Ulam spiral (for primes) | Task |
33 | Topswops | Task |
33 | Carmichael 3 strong pseudoprimes | Task |
33 | Combinations and permutations | Task |
33 | Constrained genericity | Task |
32 | Pascal's triangle/Puzzle | Task |
32 | Multiline shebang | Draft |
32 | S-Expressions | Task |
32 | Sort three variables | Task |
32 | 2048 | Task |
32 | Vampire number | Task |
32 | Knuth's algorithm S | Task |
32 | Aliquot sequence classifications | Task |
32 | Order disjoint list items | Task |
32 | Test integerness | Task |
32 | 4-rings or 4-squares puzzle | Task |
31 | Events | Task |
31 | Extensible prime generator | Task |
31 | Metered concurrency | Task |
31 | Deepcopy | Task |
31 | CUSIP | Task |
31 | Break OO privacy | Task |
31 | Vector | Draft |
31 | Taxicab numbers | Task |
31 | MD4 | Task |
31 | Permutation test | Task |
31 | Voronoi diagram | Task |
30 | Function prototype | Task |
30 | LU decomposition | Task |
30 | GUI/Maximum window dimensions | Task |
30 | Numerical integration/Gauss-Legendre Quadrature | Task |
30 | Scope/Function names and labels | Task |
30 | Fibonacci word/fractal | Task |
30 | Ordered Partitions | Task |
30 | Casting out nines | Task |
30 | Cartesian product of two or more lists | Task |
30 | Permutations with repetitions | Draft |
30 | Speech synthesis | Task |
30 | Bitmap/Bézier curves/Cubic | Task |
29 | Input/Output for Pairs of Numbers | Draft |
29 | Julia set | Task |
29 | Conjugate transpose | Task |
29 | Bitmap/Histogram | Task |
29 | Maze solving | Task |
29 | Terminal control/Hiding the cursor | Task |
28 | Terminal control/Unicode output | Task |
28 | Executable library | Task |
28 | Topic variable | Task |
28 | Minesweeper game | Task |
28 | Simple database | Task |
28 | Bitwise IO | Task |
28 | Elementary cellular automaton | Task |
28 | Sutherland-Hodgman polygon clipping | Task |
28 | Find the intersection of two lines | Task |
28 | Object serialization | Task |
28 | Primorial numbers | Task |
28 | Water collected between towers | Task |
28 | Flipping bits game | Task |
28 | Parse command-line arguments | Draft |
28 | Bitmap/Bézier curves/Quadratic | Task |
27 | File extension is in extensions list | Draft |
27 | Penney's game | Task |
27 | Multiple regression | Task |
27 | Sattolo cycle | Draft |
27 | Input/Output for Lines of Text | Draft |
27 | Colour pinstripe/Display | Task |
27 | Bitcoin/address validation | Task |
27 | Pinstripe/Display | Task |
26 | Sailors, coconuts and a monkey problem | Task |
26 | RSA code | Task |
26 | Sorting Algorithms/Circle Sort | Draft |
26 | Memory layout of a data structure | Task |
26 | Zhang-Suen thinning algorithm | Task |
26 | Numeric error propagation | Task |
26 | Set puzzle | Task |
26 | Pathological floating point problems | Task |
26 | Ranking methods | Task |
25 | Update a configuration file | Task |
25 | Textonyms | Task |
25 | Straddling checkerboard | Task |
25 | Magic squares of doubly even order | Task |
25 | Formal power series | Task |
25 | Subset sum problem | Draft |
25 | Execute SNUSP | Task |
25 | Check output device is a terminal | Draft |
25 | Entropy/Narcissist | Task |
25 | State name puzzle | Task |
25 | Parametrized SQL statement | Task |
25 | Multiplicative order | Task |
25 | Arena storage pool | Task |
25 | Floyd-Warshall algorithm | Task |
25 | RIPEMD-160 | Task |
25 | Continued fraction/Arithmetic/Construct from rational number | Task |
25 | Solve a Hidato puzzle | Task |
25 | QR decomposition | Task |
25 | Xiaolin Wu's line algorithm | Task |
25 | Same Fringe | Task |
25 | Read a file character by character/UTF8 | Draft |
25 | First class environments | Task |
25 | Use another language to call a function | Task |
25 | Longest Common Substring | Draft |
24 | Brace expansion | Task |
24 | Egyptian division | Task |
24 | Musical scale | Draft |
24 | Deconvolution/1D | Task |
24 | Distributed programming | Task |
24 | Rosetta Code/Fix code tags | Task |
24 | Sorting algorithms/Cycle sort | Draft |
24 | Metronome | Task |
24 | Resistor mesh | Task |
24 | Pragmatic directives | Task |
24 | Find palindromic numbers in both binary and ternary bases | Task |
24 | Chinese zodiac | Task |
24 | Rosetta Code/Find bare lang tags | Task |
24 | Keyboard macros | Task |
23 | Find first and last set bit of a long integer | Draft |
23 | Natural sorting | Task |
23 | Cramer's rule | Task |
23 | Solve the no connection puzzle | Task |
23 | Sort a list of object identifiers | Task |
23 | Paraffins | Task |
23 | Death Star | Task |
23 | Window creation/X11 | Task |
23 | Pythagoras tree | Task |
23 | Lychrel numbers | Task |
23 | Arithmetic-geometric mean/Calculate Pi | Task |
23 | Truth table | Task |
23 | Pattern matching | Task |
23 | Sorting algorithms/Patience sort | Draft |
22 | Active Directory/Connect | Task |
22 | Create a file on magnetic tape | Task |
22 | Go Fish | Task |
22 | Terminal control/Cursor movement | Task |
22 | Word count | Draft |
22 | Rosetta Code/Find unimplemented tasks | Task |
22 | Galton box animation | Task |
22 | Text between | Draft |
22 | Prime conspiracy | Draft |
22 | FTP | Task |
22 | Write to Windows event log | Task |
22 | Check Machin-like formulas | Task |
22 | Angle difference between two bearings | Task |
21 | UTF-8 encode and decode | Task |
21 | The ISAAC Cipher | Task |
21 | Welch's t-test | Draft |
21 | Find largest left truncatable prime in a given base | Task |
21 | Terminal control/Preserve screen | Task |
21 | Nautical bell | Task |
21 | Sum and Product Puzzle | Task |
21 | Verify distribution uniformity/Chi-squared test | Task |
21 | Currency | Draft |
21 | Check input device is a terminal | Draft |
21 | Checkpoint synchronization | Task |
21 | URL parser | Task |
21 | Implicit type conversion | Draft |
21 | Honeycombs | Task |
21 | Table creation | Draft |
20 | Pentagram | Task |
20 | Set of real numbers | Task |
20 | Permutations/Rank of a permutation | Task |
20 | Birthday problem | Draft |
20 | Multi-dimensional array | Draft |
20 | RCRPG | Task |
20 | Shoelace formula for polygonal area | Task |
20 | Substitution Cipher | Draft |
20 | Safe addition | Task |
20 | Partition an integer X into N primes | Task |
20 | Decimal floating point number to binary | Draft |
20 | Simulate input/Keyboard | Task |
20 | Ramsey's theorem | Draft |
20 | Image convolution | Task |
20 | Chat server | Task |
20 | Cycle detection | Draft |
20 | Function frequency | Task |
20 | Percolation/Mean run density | Task |
20 | Solve a Holy Knight's tour | Task |
20 | Play recorded sounds | Task |
20 | MAC Vendor Lookup | Task |
19 | Thiele's interpolation formula | Task |
19 | Total circles area | Task |
19 | Record sound | Task |
19 | Old Russian measure of length | Draft |
19 | Idiomatically determine all the lowercase and uppercase letters | Draft |
19 | Elliptic curve arithmetic | Draft |
19 | Damm algorithm | Draft |
19 | Yahoo! search interface | Task |
19 | Superellipse | Task |
19 | HTTPS/Authenticated | Task |
19 | Main step of GOST 28147-89 | Task |
19 | Window management | Task |
19 | Cut a rectangle | Task |
19 | Decision tables | Draft |
18 | AVL tree | Task |
18 | K-means++ clustering | Task |
18 | Hough transform | Task |
18 | Egyptian fractions | Task |
18 | Create an object at a given address | Task |
18 | Stream Merge | Task |
18 | Reflection/List methods | Draft |
18 | Parse an IP Address | Task |
18 | Dice game probabilities | Draft |
18 | Make a backup file | Draft |
18 | Poker hand analyser | Task |
17 | Display a linear combination | Draft |
17 | Pig the dice game/Player | Task |
17 | Playfair cipher | Draft |
17 | SOAP | Task |
17 | Reflection/List properties | Task |
17 | Parallel Brute Force | Task |
17 | Polyspiral | Task |
17 | Modular arithmetic | Draft |
17 | Integer roots | Draft |
17 | Sequence of primorial primes | Draft |
17 | Draw a rotating cube | Task |
17 | Sokoban | Task |
17 | Plasma effect | Task |
16 | Kahan summation | Draft |
16 | Kronecker product based fractals | Task |
16 | Median filter | Task |
16 | Simulate input/Mouse | Task |
16 | Pythagorean quadruples | Task |
16 | Linux CPU utilization | Draft |
16 | Perlin noise | Draft |
16 | Elementary cellular automaton/Random Number Generator | Draft |
16 | Idiomatically determine all the characters that can be used for symbols | Draft |
15 | Machine code | Task |
15 | Active Directory/Search for a user | Task |
15 | Levenshtein distance/Alignment | Draft |
15 | Solve a Numbrix puzzle | Task |
15 | Compiler/lexical analyzer | Task |
15 | Bacon cipher | Draft |
15 | Card shuffles | Draft |
14 | Negative base numbers | Task |
14 | Faulhaber's formula | Draft |
14 | Elementary cellular automaton/Infinite length | Draft |
14 | Deming's Funnel | Draft |
14 | Magic squares of singly even order | Task |
14 | Names to numbers | Draft |
14 | Reverse the gender of a string | Draft |
14 | World Cup group stage | Task |
14 | Solve a Hopido puzzle | Task |
14 | Chebyshev coefficients | Draft |
14 | K-d tree | Task |
14 | Native shebang | Draft |
14 | Selective File Copy | Draft |
14 | Assertions in design by contract | Draft |
14 | Tonelli-Shanks algorithm | Draft |
14 | AudioAlarm | Draft |
14 | Vigenère cipher/Cryptanalysis | Task |
14 | Index finite lists of positive integers | Draft |
13 | SQL-based authentication | Task |
13 | Bitcoin/public point to address | Task |
13 | Type detection | Draft |
13 | Terminal control/Positional read | Task |
13 | Color quantization | Task |
13 | Sierpinski pentagon | Task |
13 | A* search algorithm | Draft |
13 | Create an object/Native demonstration | Draft |
13 | Nonoblock | Task |
13 | Video display modes | Task |
13 | Apply a digital filter (direct form II transposed) | Task |
13 | Rendezvous | Task |
13 | Superpermutation minimisation | Draft |
13 | Cipolla's algorithm | Draft |
13 | Fivenum | Draft |
13 | Percolation/Site percolation | Task |
12 | Retrieve and search chat history | Task |
12 | Diversity prediction theorem | Draft |
12 | Percolation/Bond percolation | Task |
12 | Lucky and even lucky numbers | Task |
12 | Most frequent k chars distance | Draft |
12 | Untrusted environment | Draft |
12 | Percolation/Mean cluster density | Task |
12 | Reflection/Get source | Task |
12 | Word break problem | Draft |
12 | Joystick position | Task |
12 | Bitmap/Read an image through a pipe | Task |
12 | I.Q. Puzzle | Draft |
12 | Convex hull | Draft |
11 | Find URI in text | Draft |
11 | NYSIIS | Draft |
11 | Knuth's power tree | Draft |
11 | Faulhaber's triangle | Draft |
11 | Polynomial synthetic division | Draft |
11 | Arithmetic coding/As a generalized change of radix | Draft |
11 | Monads/Maybe monad | Draft |
11 | Shortest common supersequence | Draft |
11 | Ramer-Douglas-Peucker line simplification | Task |
11 | Bilinear interpolation | Draft |
11 | List rooted trees | Draft |
11 | Vogel's approximation method | Task |
11 | N-body problem | Draft |
11 | Proof | Draft |
11 | Compare sorting algorithms' performance | Task |
11 | Find the intersection of a line with a plane | Task |
11 | Separate the house number from the street name | Draft |
10 | Find duplicate files | Draft |
10 | P-value correction | Draft |
10 | Generate random chess position | Draft |
10 | Commatizing numbers | Task |
10 | Mersenne primes | Draft |
10 | Monads/List monad | Draft |
10 | Zeckendorf arithmetic | Task |
10 | Aspect Oriented Programming | Draft |
10 | Nonogram solver | Task |
10 | Markov chain text generator | Draft |
10 | Determine if two triangles overlap | Draft |
10 | Readline interface | Draft |
10 | Snake | Draft |
10 | Primes - allocate descendants to their ancestors | Task |
10 | Compiler/virtual machine interpreter | Task |
10 | HTTPS/Client-authenticated | Task |
10 | Compiler/code generator | Task |
10 | Topological sort/Extracted top item | Draft |
9 | Bitmap/PPM conversion through a pipe | Task |
9 | XML Validation | Draft |
9 | Suffix tree | Draft |
9 | Base58Check encoding | Draft |
9 | Eertree | Task |
9 | VList | Draft |
9 | Code segment unload | Draft |
9 | Word search | Task |
9 | Transportation problem | Draft |
9 | Abbreviations, automatic | Draft |
9 | File size distribution | Draft |
9 | Four is magic | Draft |
9 | Color wheel | Draft |
9 | Free polyominoes enumeration | Draft |
9 | Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N) | Draft |
8 | Compiler/AST interpreter | Task |
8 | Self-hosting compiler | Draft |
8 | Loops/Increment loop index within loop body | Draft |
8 | Hunt The Wumpus | Task |
8 | Montgomery reduction | Draft |
8 | Kosaraju | Draft |
8 | Largest number divisible by its digits | Draft |
8 | Perceptron | Draft |
8 | Compiler/syntax analyzer | Task |
8 | Finite state machine | Draft |
7 | Run as a daemon or service | Draft |
7 | Mastermind | Draft |
7 | Time-based One-time Password Algorithm | Draft |
7 | Particle Swarm Optimization | Draft |
7 | The Name Game | Task |
7 | Generalised floating point addition | Draft |
7 | Singly-linked list/Element removal | Draft |
7 | Deconvolution/2D+ | Task |
7 | Orbital elements | Draft |
7 | Canny edge detector | Task |
7 | Abbreviations, easy | Draft |
7 | User defined pipe and redirection operators | Draft |
7 | IPC via named pipe | Draft |
7 | Monads/Writer monad | Draft |
6 | Just in time processing on a character stream | Draft |
6 | Catmull–Clark subdivision surface | Task |
6 | French Republican calendar | Draft |
6 | Parse EBNF | Draft |
6 | Addition chains | Draft |
6 | Morpion solitaire | Draft |
6 | Banker's algorithm | Draft |
5 | Spelling of ordinal numbers | Draft |
5 | Sorting algorithms/Tree sort on a linked list | Draft |
5 | Combinations with repetitions/Square Digit Chain | Draft |
5 | Abbreviations, simple | Draft |
5 | Audio frequency generator | Draft |
5 | Imaginary base numbers | Draft |
5 | ASCII art diagram converter | Draft |
5 | Pinstripe/Printer | Task |
5 | Starting a web browser | Draft |
5 | OpenGL Pixel Shader | Draft |
4 | Using the Meetup.com API | Draft |
4 | 15 puzzle solver | Task |
4 | Snake And Ladder | Draft |
4 | Gauss-Jordan matrix inversion | Draft |
4 | Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N1, Contined Fraction N2) | Draft |
4 | Four is the number of letters in the ... | Draft |
4 | Geometric algebra | Draft |
4 | Data Encryption Standard | Draft |
4 | Tetris | Draft |
4 | Pentomino tiling | Draft |
4 | Fibonacci heap | Draft |
4 | Remote agent/Agent interface | Draft |
4 | Functional coverage tree | Draft |
4 | Greed | Draft |
4 | Addition-chain exponentiation | Draft |
4 | Rosetta Code/Run examples | Draft |
4 | Remote agent/Simulation | Draft |
4 | Colour pinstripe/Printer | Task |
4 | Remote agent/Agent logic | Draft |
4 | Railway circuit | Draft |
4 | Using a Speech engine to highlight words | Draft |
4 | One-time pad | Draft |
4 | Tarjan | Draft |
3 | Hexapawn | Draft |
3 | OpenGL/Utah Teapot | Draft |
3 | Rosetta Code/Rank languages by number of users | Draft |
3 | Robots | Draft |
3 | Boids | Draft |
3 | Text to HTML | Draft |
3 | Rosetta Code/Tasks without examples | Draft |
3 | Simulated annealing | Draft |
2 | Recursive descent parser generator | Draft |
2 | Tamagotchi emulator | Draft |
2 | OpenWebNet Password | Draft |
2 | Solve a Rubik's Cube | Draft |
2 | External sort | Draft |
2 | OLE Automation | Task |
2 | Audio Overlap Loop | Draft |
2 | Chess player | Draft |
2 | Penrose tiling | Draft |
1 | Terminal control/Restricted width positional input/With wrapping | Draft |
1 | Solving coin problems | Draft |
1 | Generalised floating point multiplication | Draft |
1 | Multidimensional Newton-Raphson metod | Draft |
1 | Terminal control/Restricted width positional input/No wrapping | Draft |
1 | IRC gateway | Draft |
1 | Rosetta Code/List authors of task descriptions | Draft |
1 | Process SMIL directives in XML data | Draft |
1 | Black Box | Draft |
0 | Waveform analysis/Doh ray me | Draft |
0 | Rosetta Code/Tasks sorted by average lines of code | Draft |
0 | Waveform analysis/Top and tail | Draft |
0 | Ukkonen’s Suffix Tree Construction | Draft |
0 | Weather Routing | Draft |
0 | Chess player/Search and evaluation | Draft |
0 | Blackjack strategy | Draft |
0 | Chess player/Program options and user interface | Draft |
0 | Chess player/Move generation | Draft |
0 | Unicode polynomial equation | Draft |
PicoLisp
<lang PicoLisp>(load "@lib/http.l")
(client "rosettacode.org" 80
"mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"
(while (from " title=\"")
(let Task (till "\"")
(client "rosettacode.org" 80 (pack "wiki/" (replace Task " " "_"))
(let Cnt 0
(while (from "")
(unless (sub? "." (till "<" T))
(inc 'Cnt) ) )
(out NIL (prinl (ht:Pack Task) ": " Cnt)) ) ) ) ) )</lang>
Output (05may10):
100 doors: 79 24 game: 21 24 game/Solve: 15 99 Bottles of Beer: 95 A+B: 37 Abstract type: 29 ...
PureBasic
<lang PureBasic>Procedure handleError(value, msg.s)
If value = 0 MessageRequester("Error", msg) End EndIf
EndProcedure
handleError(InitNetwork(), "Unable to initialize network functions.") If OpenConsole()
Define url$, x1$, y1$, title$, unescapedTitle$, encodedURL$ Define x2, i, j, totalExamples, totalTasks url$ = "http://www.rosettacode.org/mw/api.php?action=query" + "&list=categorymembers&cmtitle=Category:Programming_Tasks" + "&cmlimit=500&format=xml" Repeat handleError(ReceiveHTTPFile(url$, "tasks.xml"), "Unable to access tasks URL.") handleError(ReadFile(0, "tasks.xml"), "Unable to read 'task.xml' file.") x1$ = ReadString(0) CloseFile(0) Repeat x2 = FindString(x1$, "title=", x2 + 1) If x2 title$ = Mid(x1$, x2 + 7, 99) title$ = Left(title$, FindString(title$, ">", 1) - 4) unescapedTitle$ = UnescapeString(ReplaceString(title$, "'", "'"), #PB_String_EscapeXML) encodedURL$ = URLEncoder("http://www.rosettacode.org/mw/index.php?title=" + unescapedTitle$ + "&action=raw") If ReceiveHTTPFile(encodedURL$, "task.xml") ReadFile(0, "task.xml") While Not Eof(0) y1$ = ReadString(0) If FindString(y1$, "=={{header|", 1, #PB_String_NoCase) totalExamples + 1 EndIf Wend CloseFile(0) PrintN(unescapedTitle$ +": " + Str(totalExamples) + " examples") totalTasks + totalExamples totalExamples = 0 EndIf EndIf Until x2 = 0 ;check for additional pages of tasks x2 = FindString(x1$, "cmcontinue=") If x2 i = FindString(x1$, #DQUOTE$, x2 + 1) j = FindString(x1$, #DQUOTE$, i + 1) url$ = URLEncoder("http://www.rosettacode.org/mw/api.php?action=query" + "&list=categorymembers&cmtitle=Category:Programming_Tasks" + "&cmlimit=500&format=xml&cmcontinue=" + Mid(x1$, i + 1, j - i)) Else Break ;all done EndIf ForEver PrintN("Total: " + Str(totalTasks) + " examples") Input() CloseConsole()
EndIf</lang> Sample output:
100 doors: 224 examples 24 game: 78 examples 24 game/Solve: 46 examples 9 billion names of God the integer: 33 examples 99 Bottles of Beer: 253 examples A+B: 187 examples ...... Zeckendorf arithmetic: 6 examples Zeckendorf number representation: 37 examples Zero to the zero power: 71 examples Zhang-Suen thinning algorithm: 18 examples Zig-zag matrix: 83 examples Total: 44140 examples
Python
<lang python>import urllib, xml.dom.minidom
x = urllib.urlopen("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml")
tasks = [] for i in xml.dom.minidom.parseString(x.read()).getElementsByTagName("cm"):
t = i.getAttribute('title').replace(" ", "_") y = urllib.urlopen("http://www.rosettacode.org/w/index.php?title=%s&action=raw" % t.encode('utf-8')) tasks.append( y.read().lower().count("{{header|") ) print t.replace("_", " ") + ": %d examples." % tasks[-1]
print "\nTotal: %d examples." % sum(tasks)</lang>
R
<lang R> library(XML) library(RCurl) doc <- xmlInternalTreeParse("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml") nodes <- getNodeSet(doc,"//cm") titles = as.character( sapply(nodes, xmlGetAttr, "title") ) headers <- list() counts <- list() for (i in 1:length(titles)){ headersi <- getURL( paste("http://rosettacode.org/mw/index.php?title=", gsub(" ", "_", titles[i]), "&action=raw", sep="") ) countsi <- strsplit(headersi,split=" ")1 countsi <- grep("\\{\\{header", countsi) cat(titles[i], ":", length(countsi), "examples\n") } cat("Total: ", length(unlist(counts)), "examples\n") </lang>
Racket
<lang racket>
- lang racket
(require net/url net/uri-codec json (only-in racket/dict [dict-ref ref]))
(define (RC-get verb params)
((compose1 get-pure-port string->url format) "http://rosettacode.org/mw/~a.php?~a" verb (alist->form-urlencoded params)))
(define (get-category catname)
(let loop ([c #f]) (define t ((compose1 read-json RC-get) 'api `([action . "query"] [format . "json"] [list . "categorymembers"] [cmtitle . ,(format "Category:~a" catname)] [cmcontinue . ,(and c (ref c 'cmcontinue))] [cmlimit . "500"]))) (define (c-m key) (ref (ref t key '()) 'categorymembers #f)) (append (for/list ([page (c-m 'query)]) (ref page 'title)) (cond [(c-m 'query-continue) => loop] [else '()]))))
(printf "Total: ~a\n"
(for/sum ([task (get-category 'Programming_Tasks)]) (define s ((compose1 length regexp-match-positions*) #rx"=={{" (RC-get 'index `([action . "raw"] [title . ,task])))) (printf "~a: ~a\n" task s) s))
</lang>
Ruby
First, a RosettaCode module, saved as rosettacode.rb: <lang ruby>require 'open-uri' require 'rexml/document'
module RosettaCode
URL_ROOT = "http://rosettacode.org/mw"
def self.get_url(page, query) begin # Ruby 1.9.2 pstr = URI.encode_www_form_component(page) qstr = URI.encode_www_form(query) rescue NoMethodError require 'cgi' pstr = CGI.escape(page) qstr = query.map {|k,v| "%s=%s" % [CGI.escape(k.to_s), CGI.escape(v.to_s)]}.join("&") end url = "#{URL_ROOT}/#{pstr}?#{qstr}" p url if $DEBUG url end
def self.get_api_url(query) get_url "api.php", query end
def self.category_members(category) query = { "action" => "query", "list" => "categorymembers", "cmtitle" => "Category:#{category}", "format" => "xml", "cmlimit" => 500, } while true url = get_api_url query doc = REXML::Document.new open(url)
REXML::XPath.each(doc, "//cm") do |task| yield task.attribute("title").value end
continue = REXML::XPath.first(doc, "//query-continue") break if continue.nil? cm = REXML::XPath.first(continue, "categorymembers") query["cmcontinue"] = cm.attribute("cmcontinue").value end end
end</lang>
Then, we implement the task with: <lang ruby>require 'rosettacode'
total_examples = 0
RosettaCode.category_members("Programming_Tasks") do |task|
url = RosettaCode.get_url("index.php", {"action" => "raw", "title" => task}) examples = open(url).read.scan("=={{header").length puts "#{task}: #{examples}" total_examples += examples
end
puts puts "Total: #{total_examples}"</lang>
Rust
<lang rust>extern crate reqwest; extern crate url; extern crate rustc_serialize;
use std::io::Read; use self::url::Url; use rustc_serialize::json::{self, Json};
pub struct Task {
page_id: u64, pub title: String,
}
- [derive(Debug)]
enum ParseError {
/// Something went wrong with the HTTP request to the API. Http(reqwest::Error),
/// There was a problem parsing the API response into JSON. Json(json::ParserError),
/// Unexpected JSON format from response UnexpectedFormat,
} impl From<json::ParserError> for ParseError {
fn from(error: json::ParserError) -> Self { ParseError::Json(error) }
}
impl From<reqwest::Error> for ParseError {
fn from(error: reqwest::Error) -> Self { ParseError::Http(error) }
}
fn construct_query_category(category: &str) -> Url {
let mut base_url = Url::parse("http://rosettacode.org/mw/api.php").unwrap(); let cat = format!("Category:{}", category); let query_pairs = vec![("action", "query"), ("format", "json"), ("list", "categorymembers"), ("cmlimit", "500"), ("cmtitle", &cat), ("continue", "")]; base_url.query_pairs_mut().extend_pairs(query_pairs.into_iter()); base_url
}
fn construct_query_task_content(task_id: &str) -> Url {
let mut base_url = Url::parse("http://rosettacode.org/mw/api.php").unwrap(); let mut query_pairs = vec![("action", "query"), ("format", "json"), ("prop", "revisions"), ("rvprop", "content")]; query_pairs.push(("pageids", task_id)); base_url.query_pairs_mut().extend_pairs(query_pairs.into_iter()); base_url
}
fn query_api(url: Url) -> Result<Json, ParseError> {
let mut response = try!(reqwest::get(url.as_str())); // Build JSON let mut body = String::new(); response.read_to_string(&mut body).unwrap();
Ok(try!(Json::from_str(&body)))
}
fn parse_all_tasks(reply: &Json) -> Result<Vec<Task>, ParseError> {
let json_to_task = |json: &Json| -> Result<Task, ParseError> { let page_id: u64 = try!(json.find("pageid") .and_then(|id| id.as_u64()) .ok_or(ParseError::UnexpectedFormat)); let title: &str = try!(json.find("title") .and_then(|title| title.as_string()) .ok_or(ParseError::UnexpectedFormat));
Ok(Task { page_id: page_id, title: title.to_owned(), }) }; let tasks_json = try!(reply.find_path(&["query", "categorymembers"]) .and_then(|tasks| tasks.as_array()) .ok_or(ParseError::UnexpectedFormat));
// Convert into own type tasks_json.iter().map(json_to_task).collect()
} fn count_number_examples(task: &Json, task_id: u64) -> Result<u32, ParseError> {
let revisions = try!(task.find_path(&["query", "pages", task_id.to_string().as_str(), "revisions"]) .and_then(|content| content.as_array()) .ok_or(ParseError::UnexpectedFormat)); let content = try!(revisions[0] .find("*") .and_then(|content| content.as_string()) .ok_or(ParseError::UnexpectedFormat)); Ok(content.split("=={{header").count() as u32)
}
pub fn query_all_tasks() -> Vec<Task> {
let query = construct_query_category("Programming_Tasks"); let json: Json = query_api(query).unwrap(); parse_all_tasks(&json).unwrap()
}
pub fn query_a_task(task: &Task) -> u32 {
let query = construct_query_task_content(&task.page_id.to_string()); let json: Json = query_api(query).unwrap(); count_number_examples(&json, task.page_id).unwrap()
}</lang>
The function is then run using the following: <lang rust> extern crate count_examples; fn main() {
let all_tasks = count_examples::query_all_tasks(); for task in &all_tasks { let count = count_examples::query_a_task(task); println!("Task: {} has {} examples", task.title, count); }
}</lang>
Run BASIC
<lang runbasic>html "
"a$ = httpGet$("http://rosettacode.org/wiki/Category:Programming_Tasks")
a$ = word$(a$,1,"Num | Task | Examples |
")
i = instr(a$,"<a href=""/wiki/") i = instr(a$,"<a href=""/wiki/",i+1) while i > 0
count = count + 1 i = instr(a$,"<a href=""/wiki/",i+1) j = instr(a$,">",i+5) a1$ = mid$(a$,i+15,j-i) taskId$ = word$(a1$,1,"""") task$ = word$(a1$,3,"""") url$ = "http://rosettacode.org/wiki/";taskId$ a2$ = httpGet$(url$) ii = instr(a2$,"") jj = 0 while ii > 0 jj = ii ii = instr(a2$,"",ii+10) wend if jj = 0 then examp = 0 else kk = instr(a2$,"<",jj+24) examp = int(val(mid$(a2$,jj+24,kk-jj-24))) end if
html "";count;"";task$;"";examp;""
totExamp = totExamp + examp
wend
html "**** Total **";totExamp;""
end</lang>
Num | Task | Examples |
1 | 100 doors | 165 |
2 | 24 game | 56 |
3 | 24 game/Solve | 34 |
4 | 99 Bottles of Beer | 192 |
5 | A+B | 129 |
6 | Abstract type | 51 |
7 | Accumulator factory | 65 |
8 | Ackermann function | 132 |
9 | Active Directory/Connect | 13 |
10 | Active Directory/Search for a user | 13 |
11 | Active object | 22 |
12 | Add a variable to a class instance at runtime | 37 |
... | ... | ... |
655 | Y combinator | 53 |
656 | Yahoo! search interface | 16 |
657 | Yin and yang | 38 |
658 | Zebra puzzle | 12 |
659 | Zeckendorf number representation | 18 |
660 | Zig-zag matrix | 65 |
** | ** Total ** | 28611 |
Scala
<lang Scala>import scala.language.postfixOps
object TaskCount extends App {
import java.net.{ URL, URLEncoder } import scala.io.Source.fromURL
System.setProperty("http.agent", "*") val allTasksURL = "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml" val allTasks = xml.parsing.XhtmlParser(fromURL(new URL(allTasksURL)))
val regexExpr = "(?i)==\\{\\{header\\|".r
def oneTaskURL(title: String) = { println(s"Check $title") "http://www.rosettacode.org/w/index.php?title=%s&action=raw" format URLEncoder.encode(title.replace(' ', '_'), "UTF-8") }
def count(title: String) = regexExpr findAllIn fromURL(new URL(oneTaskURL(title)))(io.Codec.UTF8).mkString length
val counts = for (task <- allTasks \\ "cm" \\ "@title" map (_.text)) yield scala.actors.Futures.future((task, count(task)))
counts map (_.apply) map Function.tupled("%s: %d examples." format (_, _)) foreach println println("\nTotal: %d examples." format (counts map (_.apply._2) sum))
}</lang>
Sidef
<lang ruby>var lwp = require('LWP::UserAgent').new(agent => 'Mozilla/5.0');
var site = 'http://rosettacode.org'; var list_url = '/mw/api.php?action=query&list=categorymembers&'+
'cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml';
var content = lwp.get(site + list_url).decoded_content;
while (var m = content.match(/cm.*?title="(.*?)"/g)) {
(var slug = m[0]).gsub!(' ', '_'); var count = lwp.get("#{site}/wiki/#{slug}").decoded_content.count(/toclevel-1/g); say "#{m[0]}: #{count} examples";
}</lang>
- Output:
100 doors: 2180 examples 24 game: 760 examples 24 game/Solve: 450 examples 9 billion names of God the integer: 320 examples 99 Bottles of Beer: 2330 examples A+B: 1800 examples ABC Problem: 720 examples Abstract type: 680 examples ...
Tcl
<lang tcl>package require Tcl 8.5 package require http package require json
fconfigure stdout -buffering none
proc get_tasks {category} {
set start [clock milliseconds] puts -nonewline "getting $category members..." set base_url http://www.rosettacode.org/w/api.php set query {action query list categorymembers cmtitle Category:%s format json cmlimit 500} set this_query [dict create {*}[split [format $query $category]]] set tasks [list]
while {1} { set url [join [list $base_url [http::formatQuery {*}$this_query]] ?] set response [http::geturl $url] if {[set s [http::status $response]] ne "ok" || [http::ncode $response] != 200} { error "Oops: url=$url\nstatus=$s\nhttp code=[http::code $response]" } set data [json::json2dict [http::data $response]] http::cleanup $response # add tasks to list foreach task [dict get $data query categorymembers] { lappend tasks [dict get [dict create {*}$task] title] } if {[catch {dict get $data query-continue categorymembers cmcontinue} continue_task] != 0} { # no more continuations, we're done break } dict set this_query cmcontinue $continue_task } puts " found [llength $tasks] tasks in [expr {[clock milliseconds] - $start}] milliseconds" return $tasks
}
- This proc can be replaced by a single regexp command:
- set count [regexp -all "***=$needle" $haystack]
- However this proc is more efficient -- we're dealing with plain strings only.
proc count_substrings {needle haystack} {
set count 0 set idx 0 while {[set idx [string first $needle $haystack $idx]] != -1} { incr count incr idx } return $count
}
set total 0 foreach task [get_tasks Programming_Tasks] {
set url [format "http://www.rosettacode.org/w/index.php?title=%s&action=raw" [string map {{ } _} $task]] set response [http::geturl $url] if {[set s [http::status $response]] ne "ok" || [http::ncode $response] != 200} { error "Oops: url=$url\nstatus=$s\nhttp code=[http::code $response]" } set count [count_substrings "\{\{header|" [http::data $response]] puts [format "%3d examples in %s" $count $task] http::cleanup $response incr total $count
}
puts "\nTotal: $total examples"</lang>
TUSCRIPT
<lang tuscript>$$ MODE TUSCRIPT url="http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml" data=REQUEST (url)
BUILD S_TABLE beg=* DATA :title=": BUILD S_TABLE end=* DATA :":
titles=EXTRACT (data,beg|,end,1,0,"~~") titles=SPLIT (titles,":~~:") sz_titles=SIZE (titles)
BUILD R_TABLE header=":==\{\{header|:" all=*
ERROR/STOP CREATE ("tasks",seq-e,-std-)
COMPILE LOOP title=titles ask=* ask =SET_VALUE(ask,"title",title) ask =SET_VALUE(ask,"action","raw") ask =ENCODE (ask,cgi) http ="http://www.rosettacode.org/mw/index.php" url =CONCAT (http,"?",ask) data =REQUEST (url) header =FILTER_INDEX (data,header,-) sz_header=SIZE(header) line =CONCAT (title,"=",sz_header," members") FILE "tasks" = line all =APPEND(all,sz_header) ENDLOOP
ENDCOMPILE all =JOIN(all),sum=SUM(all),time=time() line=CONCAT (time,": ", sz_titles, " Programing Tasks: ", sum, " solutions")
FILE "tasks" = line </lang> Output in file "tasks":
100 doors=104 members 24 game=27 members 24 game/Solve=21 members 99 Bottles of Beer=124 members A+B=76 members Abstract type=35 members Accumulator factory=44 members ... XML/Input=39 members XML/Output=32 members XML/XPath=24 members Xiaolin Wu's line algorithm=0 members Y combinator=33 members Yahoo! search interface=10 members Zig-zag matrix=46 members 2011-01-15 03:41:30: 455 Programing Tasks: 16009 solutions
zkl
Uses shared libraries YAJL and cURL and handles "continue" responses. <lang zkl>var [const] YAJL=Import("zklYAJL")[0], CURL=Import("zklCurl");
fcn getTasks(language){
continueValue,tasks:="",Data(0,String); // "nm\0nm\0...." do{ page:=CURL().get(("http://rosettacode.org/mw/api.php?" "action=query&cmlimit=500"
"&format=json" "&list=categorymembers" "&cmtitle=Category:%s" "&cmcontinue=%s").fmt(language,continueValue));
page=page[0].del(0,page[1]); // get rid of HTML header json:=YAJL().write(page).close(); json["query"]["categorymembers"].pump(tasks,T("get","title")); continueValue=json.find("continue") //continue:-||,cmcontinue:page|954|19) .toList().apply("concat","=").concat("&"); }while(continueValue); tasks
} re:=RegExp(0'!\s+==\s*{{\s*header\s*|!); // == {{ header | zkl foreach task in (getTasks("Programming_Tasks")){
page:=CURL().get( "http://www.rosettacode.org/mw/index.php?title=%s&action=raw" .fmt(CURL.urlEncode(task))); page=page[0].del(0,page[1]); // get rid of HTML header cnt,n:=0,0; while(re.search(page,True,n)){ cnt+=1; n=re.matched[0].sum(0); } "%4d: %s".fmt(cnt,task).println();
}</lang>
- Output:
229: 100 doors 15: 15 Puzzle Game ... 257: 99 Bottles of Beer 199: A+B ... 28: Calendar - for "REAL" programmers ... 9: Stream Merge ... 78: Zero to the zero power 19: Zhang-Suen thinning algorithm 83: Zig-zag matrix