Rosetta Code/Count examples

Rosetta Code/Count examples
You are encouraged to solve this task according to the task description, using any language you may know.

Find the total number of programming examples for each task and the total for all tasks.

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

Library: AWS

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

Works with: BBC BASIC for Windows

<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

Works with: Tango

<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

Works with: EDT

EGL: Graphical client implementation

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

Library: xmerl

<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

Library: HTTP XML

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

1. 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

1. 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>

Library: Icon Programming Library

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

Works with: Java version 1.5+

<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

1. 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) \(.)"'

}

1. 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>

Library: Mojolicious

<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

Works with: Rakudo version 2018.03

Retrieves counts for both Tasks and Draft Tasks. Save / Display results as a sortable wikitable rather than a static list. Click on a column header to sort on that column. To do a secondary sort, hold down the shift key and click on a second column header. Tasks have a gray (default) background, Draft Tasks have a yellow background. <lang perl6>use HTTP::UserAgent; use URI::Escape; use JSON::Fast;

class Progress-Bar {

   has $.width = 40;
   has $.count is rw = 0;
   has @!bar = < ▏ ▎ ▍ ▌ ▋ ▊ ▉ █ >;

   method inc {
       ($.count += 1) mod= $.width * 8;
       self.clear ~ @!bar.tail x $.count div 8 ~ @!bar[ $.count % 8 ]
           ~ ' ' x $.width - 1 - ($.count / 8).floor
   }

   method clear {
       "\r" ~ ' ' x $.width ~ "\r"
   }

}

1. 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;

1. =begin update

note 'Retrieving task information...';

my $progress = Progress-Bar.new(width => 79);

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};
       print $progress.inc;
   })

}

print $progress.clear;

note "\nTask information saved to local file: {$hashfile.IO.absolute}"; $hashfile.IO.spurt(%tasks.&to-json);

1. =end update

1. Load information from local file

%tasks = $hashfile.IO.e ?? $hashfile.IO.slurp.&from-json !! ( );

1. 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; my $total = sum %tasks{*}»<count>;

1. Dump table to a file

my $out = open($tablefile, :w) or die "$!\n";

1. Add table boilerplate and caption

$out.say:

'

', "\n",

   '{|class="wikitable sortable"', "\n",
   "|+ As of { Date.today } :: Tasks: { $taskcnt } :: Draft Tasks: ",
   "{ $draftcnt } :: Total Tasks: { $count } :: Total Examples: { $total }\n",
   "! Count !! Task !! Category"

1. Sort tasks by count then add row

for %tasks.sort: { [-.value<count>, .key] } -> $task {

   $out.say:
     ( $task.value<cat> eq 'Draft'
       ?? "|- style=\"background-color: #ffc\"\n"
       !! "|-\n"
     ),
     "| { $task.value<count> }\n",
     ( $task.key ~~ /\d/
       ?? "|data-sort-value=\"{ $task.key.&naturally }\"| [[{uri-escape $task.key}|{$task.key}]]\n"
       !! "| [[{uri-escape $task.key}|{$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:

As of 2018-03-30 :: Tasks: 871 :: Draft Tasks: 209 :: Total Tasks: 1080 :: Total Examples: 56069

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	Array concatenation	Task
159	Loops/Downward for	Task
158	Repeat a string	Task
156	Loops/Foreach	Task
155	Boolean values	Task
155	Copy a string	Task
150	Hello world/Graphical	Task
149	Sum and product of an array	Task
148	Even or odd	Task
148	String case	Task
148	String length	Task
146	Character codes	Task
146	Hailstone sequence	Task
144	Apply a callback to an array	Task
144	Loops/Do-while	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	Filter	Task
137	Generic swap	Task
137	Loops/Break	Task
137	Palindrome detection	Task
137	Sum of squares	Task
136	Integer sequence	Task
136	Logical operations	Task
136	Rot-13	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	Higher-order functions	Task
126	Remove duplicate elements	Task
126	Sorting algorithms/Bubble sort	Task
125	Determine if a string is numeric	Task
124	Array length	Task
123	Empty string	Task
123	Hello world/Standard error	Task
123	Quine	Task
123	User input/Text	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	Bitwise operations	Task
118	Ethiopian multiplication	Task
118	Loop over multiple arrays simultaneously	Task
117	Least common multiple	Task
117	Sleep	Task
116	Day of the week	Task
116	Factors of an integer	Task
116	Sorting algorithms/Quicksort	Task
116	System time	Task
115	Check that file exists	Task
115	Happy numbers	Task
115	Include a file	Task
115	Substring	Task
114	Caesar cipher	Task
114	Literals/String	Task
113	Literals/Integer	Task
113	Mutual recursion	Task
112	Detect division by zero	Task
112	Pascal's triangle	Task
111	Averages/Root mean square	Task
111	Balanced brackets	Task
111	Flatten a list	Task
111	Luhn test of credit card numbers	Task
110	Program termination	Task
110	Stack	Task
109	File size	Task
109	Knuth shuffle	Task
108	Compound data type	Task
108	Variables	Task
107	Associative array/Iteration	Task
107	Date format	Task
107	Read a file line by line	Task
106	Delete a file	Task
106	Generate lower case ASCII alphabet	Task
106	Real constants and functions	Task
106	Rename a file	Task
106	Search a list	Task
105	Mandelbrot set	Task
104	ABC Problem	Task
104	Count in octal	Task
104	Function composition	Task
104	Input loop	Task
104	Null object	Task
104	Return multiple values	Task
103	Binary search	Task
103	Case-sensitivity of identifiers	Task
103	Classes	Task
103	Formatted numeric output	Task
103	Loops/Nested	Task
103	Sorting algorithms/Insertion sort	Task
102	Averages/Median	Task
102	Count occurrences of a substring	Task
102	Hostname	Task
101	Arithmetic/Complex	Task
101	Hash from two arrays	Task
101	Random numbers	Task
100	HTTP	Task
100	Multiplication tables	Task
100	Pick random element	Task
99	Anagrams	Task
99	Environment variables	Task
99	Find limit of recursion	Task
99	Matrix multiplication	Task
99	Matrix transposition	Task
99	N-queens problem	Task
99	Pangram checker	Task
98	Conway's Game of Life	Task
98	Guess the number/With feedback	Task
98	Horner's rule for polynomial evaluation	Task
97	Accumulator factory	Task
97	Align columns	Task
97	Create a two-dimensional array at runtime	Task
97	Perfect numbers	Task
96	Assertions	Task
96	Haversine formula	Task
96	Identity matrix	Task
96	Roman numerals/Decode	Task
96	Strip a set of characters from a string	Task
96	Temperature conversion	Task
95	Averages/Pythagorean means	Task
95	Evaluate binomial coefficients	Task
95	String matching	Task
94	Middle three digits	Task
94	Substring/Top and tail	Task
94	Variadic function	Task
93	Catalan numbers	Task
93	Run-length encoding	Task
93	Zero to the zero power	Task
92	Arithmetic-geometric mean	Task
92	Program name	Task
92	Shell one-liner	Task
92	Strip whitespace from a string/Top and tail	Task
92	Zig-zag matrix	Task
91	Exceptions	Task
91	Trigonometric functions	Task
90	Infinity	Task
90	Letter frequency	Task
90	Prime decomposition	Task
90	Regular expressions	Task
90	String interpolation (included)	Task
89	Combinations	Task
88	24 game	Task
88	Enumerations	Task
88	Power set	Task
88	Random number generator (included)	Task
88	Short-circuit evaluation	Task
88	Sierpinski triangle	Task
88	Sorting algorithms/Merge sort	Task
88	Sorting algorithms/Selection sort	Task
87	Collections	Task
87	One-dimensional cellular automata	Task
87	Ordered words	Task
86	Anonymous recursion	Task
86	Interactive programming	Task
85	Comma quibbling	Task
85	Exponentiation operator	Task
85	Levenshtein distance	Task
85	Queue/Definition	Task
85	Sequence of non-squares	Task
84	Arbitrary-precision integers (included)	Task
84	First-class functions	Task
84	Look-and-say sequence	Task
84	Permutations	Task
84	Range extraction	Task
84	Reverse words in a string	Task
84	Walk a directory/Non-recursively	Task
83	Cumulative standard deviation	Task
83	Sort using a custom comparator	Task
82	Bulls and cows	Task
82	Inheritance/Single	Task
82	Nth root	Task
82	Range expansion	Task
81	Five weekends	Task
81	MD5	Task
81	Sorting algorithms/Gnome sort	Task
81	String prepend	Task
81	Sum multiples of 3 and 5	Task
81	Symmetric difference	Task
81	Window creation	Task
80	Create an HTML table	Task
80	Evolutionary algorithm	Task
80	Time a function	Task
80	Y combinator	Task
79	Forward difference	Task
79	String append	Task
79	Sum digits of an integer	Task
78	Averages/Simple moving average	Task
78	Call a function	Task
78	File modification time	Task
78	Monty Hall problem	Task
78	Price fraction	Task
77	Abstract type	Task
77	Dragon curve	Task
77	Greatest subsequential sum	Task
77	Sierpinski carpet	Task
77	Vector products	Task
76	Babbage problem	Task
76	Entropy	Task
76	Hamming numbers	Task
76	Langton's ant	Task
76	Menu	Task
76	Sorting algorithms/Cocktail sort	Task
76	Spiral matrix	Task
75	Averages/Mode	Task
75	Hello world/Line printer	Task
75	Map range	Task
75	Sorting algorithms/Bogosort	Task
75	Walk a directory/Recursively	Task
74	Execute Brain****	Task
74	Harshad or Niven series	Task
74	JSON	Task
74	Non-decimal radices/Convert	Task
74	Show the epoch	Task
74	Simple windowed application	Task
74	The Twelve Days of Christmas	Task
74	Web scraping	Task
73	Closures/Value capture	Task
73	Digital root	Task
73	Gray code	Task
73	Monte Carlo methods	Task
73	Set	Task
73	Tree traversal	Task
72	Introspection	Task
72	Man or boy test	Task
72	Queue/Usage	Task
72	Read a specific line from a file	Task
72	SEDOLs	Task
71	CSV to HTML translation	Task
71	Last Friday of each month	Task
71	Literals/Floating point	Task
71	Number reversal game	Task
71	Singly-linked list/Traversal	Task
71	Sort an array of composite structures	Task
71	Terminal control/Ringing the terminal bell	Task
70	Bitmap	Task
70	CSV data manipulation	Task
70	Count in factors	Task
70	Keyboard input/Obtain a Y or N response	Task
70	Sorting algorithms/Heapsort	Task
70	URL decoding	Task
69	Amicable pairs	Task
69	Floyd's triangle	Task
69	Linear congruential generator	Task
69	Sockets	Task
68	Abundant, deficient and perfect number classifications	Task
68	Find the missing permutation	Task
68	Josephus problem	Task
68	Knapsack problem/0-1	Task
68	List comprehensions	Task
68	Special characters	Task
68	String comparison	Task
68	Take notes on the command line	Task
68	Top rank per group	Task
68	XML/Input	Task
67	Address of a variable	Task
67	Catamorphism	Task
67	Concurrent computing	Task
67	Date manipulation	Task
67	Find common directory path	Task
67	Kaprekar numbers	Task
67	Number names	Task
67	Roots of unity	Task
67	Sorting algorithms/Shell sort	Task
67	Strip comments from a string	Task
67	Terminal control/Clear the screen	Task
66	Box the compass	Task
66	Dynamic variable names	Task
66	Non-decimal radices/Output	Task
66	Playing cards	Task
66	Singly-linked list/Element definition	Task
66	Soundex	Task
66	Stair-climbing puzzle	Task
66	URL encoding	Task
66	Unicode variable names	Task
65	Bitmap/Bresenham's line algorithm	Task
65	Equilibrium index	Task
65	Longest common subsequence	Task
65	Lucas-Lehmer test	Task
65	Order two numerical lists	Task
65	Polymorphism	Task
64	Empty directory	Task
64	Find the last Sunday of each month	Task
64	Flow-control structures	Task
64	Sorting algorithms/Counting sort	Task
64	Write float arrays to a text file	Task
63	Anagrams/Deranged anagrams	Task
63	Averages/Mean angle	Task
63	Forest fire	Task
63	Hello world/Web server	Task
63	Here document	Task
63	Multifactorial	Task
63	Multiple distinct objects	Task
63	N'th	Task
63	Parsing/RPN calculator algorithm	Task
63	Read a configuration file	Task
63	Semordnilap	Task
63	Sorting algorithms/Comb sort	Task
63	Word wrap	Task
62	Compare a list of strings	Task
62	Constrained random points on a circle	Task
62	Convert seconds to compound duration	Task
62	Count the coins	Task
62	Enforced immutability	Task
62	Euler method	Task
62	Exceptions/Catch an exception thrown in a nested call	Task
62	Fibonacci n-step number sequences	Task
62	Guess the number/With feedback (player)	Task
62	Hofstadter Q sequence	Task
62	Jensen's Device	Task
62	Largest int from concatenated ints	Task
62	Pythagorean triples	Task
62	Sorting algorithms/Stooge sort	Task
62	Vigenère cipher	Task
61	Animation	Task
61	Call an object method	Task
61	Draw a sphere	Task
61	Hello world/Newbie	Task
61	Long multiplication	Task
61	Sort disjoint sublist	Task
61	Sudoku	Task
61	Trabb Pardo–Knuth algorithm	Task
60	Execute HQ9+	Task
60	Numerical integration	Task
60	Operator precedence	Task
60	Probabilistic choice	Task
60	Singly-linked list/Element insertion	Task
60	Sort stability	Task
60	Strip control codes and extended characters from a string	Task
59	Fork	Task
59	Four bit adder	Task
59	Gamma function	Task
59	Named parameters	Task
59	Runtime evaluation	Task
59	Undefined values	Task
59	Write language name in 3D ASCII	Task
58	Benford's law	Task
58	Call a foreign-language function	Task
58	One of n lines in a file	Task
58	Remove lines from a file	Task
58	Roots of a quadratic function	Task
58	Text processing/Max licenses in use	Task
58	Variable size/Get	Task
57	Arithmetic/Rational	Task
57	Closest-pair problem	Task
57	Combinations with repetitions	Task
57	Fractal tree	Task
57	IBAN	Task
57	Optional parameters	Task
57	Phrase reversals	Task
57	Pi	Task
57	Priority queue	Task
57	Proper divisors	Draft
57	Quaternion type	Task
57	Rock-paper-scissors	Task
57	Roots of a function	Task
57	Runge-Kutta method	Task
56	Almost prime	Task
56	Catalan numbers/Pascal's triangle	Task
56	HTTPS	Task
56	Hofstadter-Conway $10,000 sequence	Task
56	Horizontal sundial calculations	Task
56	Host introspection	Task
56	Magic squares of odd order	Task
56	Memory allocation	Task
56	SHA-1	Task
56	Self-describing numbers	Task
56	Van der Corput sequence	Task
56	Zeckendorf number representation	Task
55	AKS test for primes	Task
55	CRC-32	Task
55	Cholesky decomposition	Task
55	Currying	Task
55	Extend your language	Task
55	Fast Fourier transform	Task
55	Knapsack problem/Unbounded	Task
55	Modular inverse	Task
55	Narcissistic decimal number	Task
55	Sorting algorithms/Pancake sort	Task
55	Sorting algorithms/Sleep sort	Task
55	Special variables	Task
55	XML/Output	Task
54	24 game/Solve	Task
54	Documentation	Task
54	Jump anywhere	Task
54	Maze generation	Task
54	Non-decimal radices/Input	Task
54	Partial function application	Task
54	SHA-256	Task
53	Animate a pendulum	Task
53	Binary strings	Task
53	Calendar	Task
53	Factors of a Mersenne number	Task
53	Globally replace text in several files	Task
53	Huffman coding	Task
53	Inheritance/Multiple	Task
53	Old lady swallowed a fly	Task
53	Pernicious numbers	Task
53	Reduced row echelon form	Task
53	Stem-and-leaf plot	Task
53	Test a function	Task
53	Yin and yang	Task
52	Best shuffle	Task
52	Extreme floating point values	Task
52	Fibonacci word	Task
52	Odd word problem	Task
52	Scope modifiers	Task
52	Sorting algorithms/Bead sort	Task
52	Synchronous concurrency	Task
52	Write entire file	Task
52	XML/XPath	Task
51	Arithmetic evaluation	Task
51	Dinesman's multiple-dwelling problem	Task
51	Hash join	Task
51	Knapsack problem/Continuous	Task
51	Rep-string	Task
51	Repeat	Draft
51	Rosetta Code/Count examples	Task
51	Sequence of primes by trial division	Task
51	Singleton	Task
50	Add a variable to a class instance at runtime	Task
50	Brownian tree	Task
50	Compile-time calculation	Task
50	Continued fraction	Task
50	Draw a clock	Task
50	Miller–Rabin primality test	Task
50	Runtime evaluation/In an environment	Task
50	Semiprime	Task
50	Sorting algorithms/Permutation sort	Task
50	Stack traces	Task
50	Truncate a file	Task
50	Unbias a random generator	Task
50	Unix/ls	Task
49	Averages/Mean time of day	Task
49	Deal cards for FreeCell	Task
49	Euler's sum of powers conjecture	Task
49	Knight's tour	Task
49	LZW compression	Task
49	Morse code	Task
49	Plot coordinate pairs	Task
49	Tic-tac-toe	Task
49	Topological sort	Task
48	Circles of given radius through two points	Task
48	Generator/Exponential	Task
48	I before E except after C	Task
48	Modular exponentiation	Task
48	Modulinos	Draft
48	Pointers and references	Task
48	Terminal control/Display an extended character	Task
48	Unicode strings	Task
47	Bitmap/Write a PPM file	Task
47	Doubly-linked list/Element definition	Task
47	Dutch national flag problem	Task
47	Integer overflow	Task
47	Left factorials	Task
47	Mouse position	Task
47	Multisplit	Task
47	Non-continuous subsequences	Task
47	Rosetta Code/Rank languages by popularity	Task
47	Send email	Task
47	Split a character string based on change of character	Task
47	Statistics/Basic	Task
47	Wireworld	Task
46	Grayscale image	Task
46	Nested function	Task
46	Text processing/1	Task
46	Text processing/2	Task
46	Truncatable primes	Task
46	User input/Graphical	Task
45	Define a primitive data type	Task
45	Draw a cuboid	Task
45	First-class functions/Use numbers analogously	Task
45	Handle a signal	Task
45	JortSort	Task
45	Ludic numbers	Task
45	Maximum triangle path sum	Task
45	Munchausen numbers	Task
45	Random number generator (device)	Task
45	Respond to an unknown method call	Task
45	Seven-sided dice from five-sided dice	Task
45	Stable marriage problem	Task
45	Thue-Morse	Task
45	XML/DOM serialization	Task
44	Chinese remainder theorem	Task
44	Delegates	Task
44	General FizzBuzz	Task
44	Heronian triangles	Task
44	Matrix-exponentiation operator	Task
44	Population count	Task
44	Sierpinski triangle/Graphical	Task
44	Table creation/Postal addresses	Task
44	Ternary logic	Task
43	Bernoulli numbers	Task
43	Call a function in a shared library	Task
43	Discordian date	Task
43	Keyboard input/Keypress check	Task
43	Longest increasing subsequence	Task
43	Munching squares	Task
43	Quickselect algorithm	Task
43	Terminal control/Cursor positioning	Task
42	15 Puzzle Game	Task
42	9 billion names of God the integer	Task
42	Emirp primes	Task
42	Mad Libs	Task
42	Polymorphic copy	Task
42	Send an unknown method call	Task
41	Color of a screen pixel	Task
41	Colour bars/Display	Task
41	Convert decimal number to rational	Task
41	Dining philosophers	Task
41	Doubly-linked list/Element insertion	Task
41	Execute a Markov algorithm	Task
41	Exponentiation order	Task
41	Hofstadter Figure-Figure sequences	Task
41	Holidays related to Easter	Task
41	Inverted syntax	Task
41	Iterated digits squaring	Task
41	Longest string challenge	Task
41	Make directory path	Task
41	Rate counter	Task
41	Strip block comments	Task
41	Two Sum	Draft
41	Universal Turing machine	Task
40	Doubly-linked list/Traversal	Task
40	Echo server	Task
40	Last letter-first letter	Task
40	Move-to-front algorithm	Task
40	Parsing/Shunting-yard algorithm	Task
40	Verify distribution uniformity/Naive	Task
39	Archimedean spiral	Task
39	Barnsley fern	Task
39	Bitmap/Flood fill	Task
39	Bitmap/Read a PPM file	Task
39	Extract file extension	Draft
39	GUI component interaction	Task
39	Get system command output	Task
39	Greyscale bars/Display	Task
39	Polynomial regression	Task
39	Search a list of records	Task
39	Zebra puzzle	Task
38	Atomic updates	Task
38	DNS query	Task
38	Determine if only one instance is running	Task
38	Digital root/Multiplicative digital root	Task
38	FASTA format	Task
38	History variables	Task
38	OpenGL	Task
38	Polynomial long division	Task
38	Problem of Apollonius	Task
38	Secure temporary file	Task
38	Set consolidation	Task
38	Sorting algorithms/Strand sort	Task
38	Sparkline in unicode	Task
37	Fractran	Task
37	Image noise	Task
37	Parametric polymorphism	Task
37	Perfect shuffle	Task
37	Pig the dice game	Task
37	Subtractive generator	Task
37	Terminal control/Inverse video	Task
37	Variable size/Set	Task
36	Active object	Task
36	Department Numbers	Task
36	Dijkstra's algorithm	Draft
36	Doubly-linked list/Definition	Task
36	Generate Chess960 starting position	Task
36	Inverted index	Task
36	MD5/Implementation	Task
36	Metaprogramming	Task
36	Narcissist	Task
36	Pascal matrix generation	Task
36	Permutations by swapping	Task
36	Stern-Brocot sequence	Task
36	Terminal control/Coloured text	Task
36	Terminal control/Dimensions	Task
36	Twelve statements	Task
35	Append a record to the end of a text file	Task
35	Base64 encode data	Draft
35	Bitmap/Midpoint circle algorithm	Task
35	Bulls and cows/Player	Task
35	Farey sequence	Task
35	Knapsack problem/Bounded	Task
35	Kronecker product	Task
35	Leonardo numbers	Task
35	Matrix arithmetic	Task
35	Percentage difference between images	Task
35	Permutations/Derangements	Task
35	Ray-casting algorithm	Task
35	Smith numbers	Task
35	Subleq	Task
35	Sum to 100	Task
35	Validate International Securities Identification Number	Task
35	Variable-length quantity	Task
35	Visualize a tree	Task
34	Average loop length	Task
34	Balanced ternary	Task
34	Calendar - for "REAL" programmers	Task
34	Chaos game	Task
34	Element-wise operations	Task
34	GUI enabling/disabling of controls	Task
34	Hickerson series of almost integers	Task
34	Jaro distance	Task
34	Keyboard input/Flush the keyboard buffer	Task
34	Longest common prefix	Draft
34	Parallel calculations	Task
34	Self-referential sequence	Task
34	Statistics/Normal distribution	Task
34	Tokenize a string with escaping	Task
33	Amb	Task
33	Carmichael 3 strong pseudoprimes	Task
33	Combinations and permutations	Task
33	Constrained genericity	Task
33	Gaussian elimination	Task
33	Naming conventions	Task
33	Parsing/RPN to infix conversion	Task
33	Password generator	Task
33	Sorting algorithms/Radix sort	Task
33	Start from a main routine	Task
33	Topswops	Task
33	Ulam spiral (for primes)	Task
32	2048	Task
32	4-rings or 4-squares puzzle	Task
32	Aliquot sequence classifications	Task
32	Knuth's algorithm S	Task
32	Multiline shebang	Draft
32	Order disjoint list items	Task
32	Pascal's triangle/Puzzle	Task
32	S-Expressions	Task
32	Sort three variables	Task
32	Test integerness	Task
32	Vampire number	Task
31	Break OO privacy	Task
31	CUSIP	Task
31	Deepcopy	Task
31	Events	Task
31	Extensible prime generator	Task
31	MD4	Task
31	Metered concurrency	Task
31	Permutation test	Task
31	Taxicab numbers	Task
31	Vector	Draft
31	Voronoi diagram	Task
30	Bitmap/Bézier curves/Cubic	Task
30	Cartesian product of two or more lists	Task
30	Casting out nines	Task
30	Fibonacci word/fractal	Task
30	Function prototype	Task
30	GUI/Maximum window dimensions	Task
30	LU decomposition	Task
30	Numerical integration/Gauss-Legendre Quadrature	Task
30	Ordered Partitions	Task
30	Permutations with repetitions	Draft
30	Scope/Function names and labels	Task
30	Speech synthesis	Task
29	Bitmap/Histogram	Task
29	Conjugate transpose	Task
29	Input/Output for Pairs of Numbers	Draft
29	Julia set	Task
29	Maze solving	Task
29	Terminal control/Hiding the cursor	Task
28	Bitmap/Bézier curves/Quadratic	Task
28	Bitwise IO	Task
28	Elementary cellular automaton	Task
28	Executable library	Task
28	Find the intersection of two lines	Task
28	Flipping bits game	Task
28	Minesweeper game	Task
28	Object serialization	Task
28	Parse command-line arguments	Draft
28	Primorial numbers	Task
28	Simple database	Task
28	Sutherland-Hodgman polygon clipping	Task
28	Terminal control/Unicode output	Task
28	Topic variable	Task
28	Water collected between towers	Task
27	Bitcoin/address validation	Task
27	Colour pinstripe/Display	Task
27	File extension is in extensions list	Draft
27	Input/Output for Lines of Text	Draft
27	Multiple regression	Task
27	Penney's game	Task
27	Pinstripe/Display	Task
27	Sattolo cycle	Draft
26	Memory layout of a data structure	Task
26	Numeric error propagation	Task
26	Pathological floating point problems	Task
26	RSA code	Task
26	Ranking methods	Task
26	Sailors, coconuts and a monkey problem	Task
26	Set puzzle	Task
26	Sorting Algorithms/Circle Sort	Draft
26	Zhang-Suen thinning algorithm	Task
25	Arena storage pool	Task
25	Check output device is a terminal	Draft
25	Continued fraction/Arithmetic/Construct from rational number	Task
25	Entropy/Narcissist	Task
25	Execute SNUSP	Task
25	First class environments	Task
25	Floyd-Warshall algorithm	Task
25	Formal power series	Task
25	Longest Common Substring	Draft
25	Magic squares of doubly even order	Task
25	Multiplicative order	Task
25	Parametrized SQL statement	Task
25	QR decomposition	Task
25	RIPEMD-160	Task
25	Read a file character by character/UTF8	Draft
25	Same Fringe	Task
25	Solve a Hidato puzzle	Task
25	State name puzzle	Task
25	Straddling checkerboard	Task
25	Subset sum problem	Draft
25	Textonyms	Task
25	Update a configuration file	Task
25	Use another language to call a function	Task
25	Xiaolin Wu's line algorithm	Task
24	Brace expansion	Task
24	Chinese zodiac	Task
24	Deconvolution/1D	Task
24	Distributed programming	Task
24	Egyptian division	Task
24	Find palindromic numbers in both binary and ternary bases	Task
24	Keyboard macros	Task
24	Metronome	Task
24	Musical scale	Draft
24	Pragmatic directives	Task
24	Resistor mesh	Task
24	Rosetta Code/Find bare lang tags	Task
24	Rosetta Code/Fix code tags	Task
24	Sorting algorithms/Cycle sort	Draft
23	Arithmetic-geometric mean/Calculate Pi	Task
23	Cramer's rule	Task
23	Death Star	Task
23	Find first and last set bit of a long integer	Draft
23	Lychrel numbers	Task
23	Natural sorting	Task
23	Paraffins	Task
23	Pattern matching	Task
23	Pythagoras tree	Task
23	Solve the no connection puzzle	Task
23	Sort a list of object identifiers	Task
23	Sorting algorithms/Patience sort	Draft
23	Truth table	Task
23	Window creation/X11	Task
22	Active Directory/Connect	Task
22	Angle difference between two bearings	Task
22	Check Machin-like formulas	Task
22	Create a file on magnetic tape	Task
22	FTP	Task
22	Galton box animation	Task
22	Go Fish	Task
22	Prime conspiracy	Draft
22	Rosetta Code/Find unimplemented tasks	Task
22	Terminal control/Cursor movement	Task
22	Text between	Draft
22	Word count	Draft
22	Write to Windows event log	Task
21	Check input device is a terminal	Draft
21	Checkpoint synchronization	Task
21	Currency	Draft
21	Find largest left truncatable prime in a given base	Task
21	Honeycombs	Task
21	Implicit type conversion	Draft
21	Nautical bell	Task
21	Sum and Product Puzzle	Task
21	Table creation	Draft
21	Terminal control/Preserve screen	Task
21	The ISAAC Cipher	Task
21	URL parser	Task
21	UTF-8 encode and decode	Task
21	Verify distribution uniformity/Chi-squared test	Task
21	Welch's t-test	Draft
20	Birthday problem	Draft
20	Chat server	Task
20	Cycle detection	Draft
20	Decimal floating point number to binary	Draft
20	Function frequency	Task
20	Image convolution	Task
20	MAC Vendor Lookup	Task
20	Multi-dimensional array	Draft
20	Partition an integer X into N primes	Task
20	Pentagram	Task
20	Percolation/Mean run density	Task
20	Permutations/Rank of a permutation	Task
20	Play recorded sounds	Task
20	RCRPG	Task
20	Ramsey's theorem	Draft
20	Safe addition	Task
20	Set of real numbers	Task
20	Shoelace formula for polygonal area	Task
20	Simulate input/Keyboard	Task
20	Solve a Holy Knight's tour	Task
20	Substitution Cipher	Draft
19	Cut a rectangle	Task
19	Damm algorithm	Draft
19	Decision tables	Draft
19	Elliptic curve arithmetic	Draft
19	HTTPS/Authenticated	Task
19	Idiomatically determine all the lowercase and uppercase letters	Draft
19	Main step of GOST 28147-89	Task
19	Old Russian measure of length	Draft
19	Record sound	Task
19	Superellipse	Task
19	Thiele's interpolation formula	Task
19	Total circles area	Task
19	Window management	Task
19	Yahoo! search interface	Task
18	AVL tree	Task
18	Create an object at a given address	Task
18	Dice game probabilities	Draft
18	Egyptian fractions	Task
18	Hough transform	Task
18	K-means++ clustering	Task
18	Make a backup file	Draft
18	Parse an IP Address	Task
18	Poker hand analyser	Task
18	Reflection/List methods	Draft
18	Stream Merge	Task
17	Display a linear combination	Draft
17	Draw a rotating cube	Task
17	Integer roots	Draft
17	Modular arithmetic	Draft
17	Parallel Brute Force	Task
17	Pig the dice game/Player	Task
17	Plasma effect	Task
17	Playfair cipher	Draft
17	Polyspiral	Task
17	Reflection/List properties	Task
17	SOAP	Task
17	Sequence of primorial primes	Draft
17	Sokoban	Task
16	Elementary cellular automaton/Random Number Generator	Draft
16	Idiomatically determine all the characters that can be used for symbols	Draft
16	Kahan summation	Draft
16	Kronecker product based fractals	Task
16	Linux CPU utilization	Draft
16	Median filter	Task
16	Perlin noise	Draft
16	Pythagorean quadruples	Task
16	Simulate input/Mouse	Task
15	Active Directory/Search for a user	Task
15	Bacon cipher	Draft
15	Card shuffles	Draft
15	Compiler/lexical analyzer	Task
15	Levenshtein distance/Alignment	Draft
15	Machine code	Task
15	Solve a Numbrix puzzle	Task
14	Assertions in design by contract	Draft
14	AudioAlarm	Draft
14	Chebyshev coefficients	Draft
14	Deming's Funnel	Draft
14	Elementary cellular automaton/Infinite length	Draft
14	Faulhaber's formula	Draft
14	Index finite lists of positive integers	Draft
14	K-d tree	Task
14	Magic squares of singly even order	Task
14	Names to numbers	Draft
14	Native shebang	Draft
14	Negative base numbers	Task
14	Reverse the gender of a string	Draft
14	Selective File Copy	Draft
14	Solve a Hopido puzzle	Task
14	Tonelli-Shanks algorithm	Draft
14	Vigenère cipher/Cryptanalysis	Task
14	World Cup group stage	Task
13	A* search algorithm	Draft
13	Apply a digital filter (direct form II transposed)	Task
13	Bitcoin/public point to address	Task
13	Cipolla's algorithm	Draft
13	Color quantization	Task
13	Create an object/Native demonstration	Draft
13	Fivenum	Draft
13	Nonoblock	Task
13	Percolation/Site percolation	Task
13	Rendezvous	Task
13	SQL-based authentication	Task
13	Sierpinski pentagon	Task
13	Superpermutation minimisation	Draft
13	Terminal control/Positional read	Task
13	Type detection	Draft
13	Video display modes	Task
12	Bitmap/Read an image through a pipe	Task
12	Convex hull	Draft
12	Diversity prediction theorem	Draft
12	I.Q. Puzzle	Draft
12	Joystick position	Task
12	Lucky and even lucky numbers	Task
12	Most frequent k chars distance	Draft
12	Percolation/Bond percolation	Task
12	Percolation/Mean cluster density	Task
12	Reflection/Get source	Task
12	Retrieve and search chat history	Task
12	Untrusted environment	Draft
12	Word break problem	Draft
11	Arithmetic coding/As a generalized change of radix	Draft
11	Bilinear interpolation	Draft
11	Compare sorting algorithms' performance	Task
11	Faulhaber's triangle	Draft
11	Find URI in text	Draft
11	Find the intersection of a line with a plane	Task
11	Knuth's power tree	Draft
11	List rooted trees	Draft
11	Monads/Maybe monad	Draft
11	N-body problem	Draft
11	NYSIIS	Draft
11	Polynomial synthetic division	Draft
11	Proof	Draft
11	Ramer-Douglas-Peucker line simplification	Task
11	Separate the house number from the street name	Draft
11	Shortest common supersequence	Draft
11	Vogel's approximation method	Task
10	Aspect Oriented Programming	Draft
10	Commatizing numbers	Task
10	Compiler/code generator	Task
10	Compiler/virtual machine interpreter	Task
10	Determine if two triangles overlap	Draft
10	Find duplicate files	Draft
10	Generate random chess position	Draft
10	HTTPS/Client-authenticated	Task
10	Markov chain text generator	Draft
10	Mersenne primes	Draft
10	Monads/List monad	Draft
10	Nonogram solver	Task
10	P-value correction	Draft
10	Primes - allocate descendants to their ancestors	Task
10	Readline interface	Draft
10	Snake	Draft
10	Topological sort/Extracted top item	Draft
10	Zeckendorf arithmetic	Task
9	Abbreviations, automatic	Draft
9	Base58Check encoding	Draft
9	Bitmap/PPM conversion through a pipe	Task
9	Code segment unload	Draft
9	Color wheel	Draft
9	Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N)	Draft
9	Eertree	Task
9	File size distribution	Draft
9	Four is magic	Draft
9	Free polyominoes enumeration	Draft
9	Suffix tree	Draft
9	Transportation problem	Draft
9	VList	Draft
9	Word search	Task
9	XML Validation	Draft
8	Compiler/AST interpreter	Task
8	Compiler/syntax analyzer	Task
8	Finite state machine	Draft
8	Hunt The Wumpus	Task
8	Kosaraju	Draft
8	Largest number divisible by its digits	Draft
8	Loops/Increment loop index within loop body	Draft
8	Montgomery reduction	Draft
8	Perceptron	Draft
8	Self-hosting compiler	Draft
7	Abbreviations, easy	Draft
7	Canny edge detector	Task
7	Deconvolution/2D+	Task
7	Generalised floating point addition	Draft
7	IPC via named pipe	Draft
7	Mastermind	Draft
7	Monads/Writer monad	Draft
7	Orbital elements	Draft
7	Particle Swarm Optimization	Draft
7	Run as a daemon or service	Draft
7	Singly-linked list/Element removal	Draft
7	The Name Game	Task
7	Time-based One-time Password Algorithm	Draft
7	User defined pipe and redirection operators	Draft
6	Addition chains	Draft
6	Banker's algorithm	Draft
6	Catmull–Clark subdivision surface	Task
6	French Republican calendar	Draft
6	Just in time processing on a character stream	Draft
6	Morpion solitaire	Draft
6	Parse EBNF	Draft
5	ASCII art diagram converter	Draft
5	Abbreviations, simple	Draft
5	Audio frequency generator	Draft
5	Combinations with repetitions/Square Digit Chain	Draft
5	Imaginary base numbers	Draft
5	OpenGL Pixel Shader	Draft
5	Pinstripe/Printer	Task
5	Sorting algorithms/Tree sort on a linked list	Draft
5	Spelling of ordinal numbers	Draft
5	Starting a web browser	Draft
4	15 puzzle solver	Task
4	Addition-chain exponentiation	Draft
4	Colour pinstripe/Printer	Task
4	Continued fraction/Arithmetic/G(matrix NG, Contined Fraction N1, Contined Fraction N2)	Draft
4	Data Encryption Standard	Draft
4	Fibonacci heap	Draft
4	Four is the number of letters in the ...	Draft
4	Functional coverage tree	Draft
4	Gauss-Jordan matrix inversion	Draft
4	Geometric algebra	Draft
4	Greed	Draft
4	One-time pad	Draft
4	Pentomino tiling	Draft
4	Railway circuit	Draft
4	Remote agent/Agent interface	Draft
4	Remote agent/Agent logic	Draft
4	Remote agent/Simulation	Draft
4	Rosetta Code/Run examples	Draft
4	Snake And Ladder	Draft
4	Tarjan	Draft
4	Tetris	Draft
4	Using a Speech engine to highlight words	Draft
4	Using the Meetup.com API	Draft
3	Boids	Draft
3	Hexapawn	Draft
3	OpenGL/Utah Teapot	Draft
3	Robots	Draft
3	Rosetta Code/Rank languages by number of users	Draft
3	Rosetta Code/Tasks without examples	Draft
3	Simulated annealing	Draft
3	Text to HTML	Draft
2	Audio Overlap Loop	Draft
2	Chess player	Draft
2	External sort	Draft
2	OLE Automation	Task
2	OpenWebNet Password	Draft
2	Penrose tiling	Draft
2	Recursive descent parser generator	Draft
2	Solve a Rubik's Cube	Draft
2	Tamagotchi emulator	Draft
1	Black Box	Draft
1	Generalised floating point multiplication	Draft
1	IRC gateway	Draft
1	Multidimensional Newton-Raphson metod	Draft
1	Process SMIL directives in XML data	Draft
1	Rosetta Code/List authors of task descriptions	Draft
1	Solving coin problems	Draft
1	Terminal control/Restricted width positional input/No wrapping	Draft
1	Terminal control/Restricted width positional input/With wrapping	Draft
0	Blackjack strategy	Draft
0	Chess player/Move generation	Draft
0	Chess player/Program options and user interface	Draft
0	Chess player/Search and evaluation	Draft
0	Rosetta Code/Tasks sorted by average lines of code	Draft
0	Ukkonen’s Suffix Tree Construction	Draft
0	Unicode polynomial equation	Draft
0	Waveform analysis/Doh ray me	Draft
0	Waveform analysis/Top and tail	Draft
0	Weather Routing	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

Library: XML (R)

Library: RCurl

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

1. 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

Library: REXML

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,

}

1. [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

Library: 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

Translation of: Perl

<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

Library: Tcllib (Package: json)

<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

}

1. This proc can be replaced by a single regexp command:
2. set count [regexp -all "***=$needle" $haystack]
3. 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