Rosetta Code/Count examples: Difference between revisions

{{libheader|AWS}}

Parsing XML file with XMLAda from AdaCore

with Dom.Readers, Dom.Core, Dom.Core.Documents, Dom.Core.Nodes, Dom.Core.Attrs;

with Input_Sources.Strings, Unicode, Unicode.Ces.Utf8;

Put_Line ("Total :" & Integer'Image (Total) & " exemples.");

end Count_Examples;

Output :

<pre>

=={{header|AutoHotkey}}==

, http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml

, tasks.xml

}

MsgBox % output

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

SYS "LoadLibrary", "URLMON.DLL" TO urlmon%

WHEN "&quot;": = """"

ENDCASE

'''Sample output:'''

<pre>

=={{header|Bracmat}}==

=

. sys$(str$("wget -q -O wget.out \"" !arg \"))

)

& lst$(list,taskfreq,NEW)

Output (in file <code>tasqfreq</code>):

<pre>list=

Object-oriented solution.

using System.Collections.Generic;

using System.Linq;

Console.WriteLine("\nTotal: {0} examples.", tasks.Select(x => x.Examples).Sum());

}

=={{header|Clojure}}==

(:import [java.net URLEncoder])

(:use [clojure.contrib.http.agent :only (http-agent string)]

(flush))

(println "Total: " (reduce #(+ %1 (second %2)) 0 task-counts))))

100 doors: 73

24 game: 18

Total: 11216

nil

=={{header|D}}==

{{works with|Tango}}

import tango.io.Stdout;

import tango.net.http.HttpClient;

}

}

=={{header|EGL}}==

User Interface: RosettaCodeHandler.egl

import org.eclipse.edt.rui.widgets.*;

title string;

count int;

Service Interface: ProxyFunctions.egl

library ProxyFunctions

record QueryContinue

categorymembers Categorymembers;

=={{header|Erlang}}==

{{libheader|xmerl}}

-module(rosseta_examples).

-include_lib("xmerl/include/xmerl.hrl").

replace_chars([],Acc) ->

lists:reverse(Acc).

Using asynchronous workflows to perform downloads concurrently:

let uri1 = "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"

|> Async.Parallel

|> Async.RunSynchronously

This is 21&#215; faster than the python thanks to the concurrency.

Runs in about a minute. The number of threads is limited to 10 avoid cloudfare's protection mechanism.

concurrency.semaphores formatting hashtables http.client io

json.reader kernel math math.parser sequences splitting

all-programming-titles fetch-counts print-counts ;

Outputs:

=={{header|Go}}==

import (

fmt.Printf("%s: %d\n", cm, examples)

total += examples

{{out|Output: (May 25, 2011)}}

<pre>

{{libheader|HTTP XML}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

import Network.HTTP

import Network.URI

mapM_ putStrLn $ zipWith showFormatted tasks ns

some output:

100 doors: 56

24 game: 11

Active object: 9

...

==Icon and {{header|Unicon}}==

The following code uses features exclusive to Unicon. This version handles all tasks, not just the first 500.

$define RCTASK "http://rosettacode.org/mw/index.php?action=raw&title="

$define RCUA "User-Agent: Unicon Rosetta 0.1"

close(page)

return text

{{libheader|Icon Programming Library}}

'''Solution:'''<br>

Using <code>getCategoryMembers</code> from [[Find unimplemented tasks#J|Find unimplemented tasks]].

getAllTaskSolnCounts=: monad define

res=. ;:^:_1 tasks ,. (8!:0 counts) ,. <'examples.'

res , 'Total examples: ' , ": +/counts

'''Example Usage:'''

100 doors: 61 examples.

24 game: 15 examples.

24 game Player: 11 examples.

99 Bottles of Beer: 76 examples.

=={{header|Java}}==

{{works with|Java|1.5+}}

import java.util.ArrayList;

import ScreenScrape;

}

}

[[Count programming examples/Java/ScreenScrape|ScreenScrape class]]

`@uri` filter in the bash function `titles`.

# Produce lines of the form: URI TITLE

n=$((n + i))

done < <(titles)

{{out}}

=={{header|Julia}}==

Output by page is too long, so summaries only output shown.

rosorg = "http://rosettacode.org"

println("Draft programming tasks:")

qdURI |> getpages |> processtaskpages

<pre>

Programming examples at 2019-02-16T21:04:15.583:

=={{header|Lasso}}==

local(tasks = array, title = string, urltitle = string, thiscount = 0, totalex = 0)

with i in #root->find('query')->find('categorymembers') do => {^

'\r'

^}

{{out}}

2. Add a text field called "tasks"

put empty into fld "taskurls"

put URL "http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=10&format=xml" into apixml

end repeat

put "Total" & comma & allTaskTotal after fld "tasks"

=={{header|Maple}}==

local i, tempstring, uniindex;

try

print_examples(x["query"]["categorymembers"]);

end do:

{{Out|Output}}

<pre>

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

Import["http://rosettacode.org/wiki/Category:Programming_Tasks", "Data"][[1, 1]]];

Print["Task \"", StringReplace[#, "_" -> " "], "\" has ",

Length@Select[Import["http://rosettacode.org/wiki/" <> #, "Data"][[1,2]],

StringFreeQ[#, __ ~~ "Programming Task" | __ ~~ "Omit"]& ], " example(s)"]&

returns:

<pre>Task "100 doors" has 143 example(s)

The function count_examples() need to be saved in a file count_examples.m and its directory need to be included in the path.

c = 0;

[s, success] = urlread (url);

c = count_examples(['http://rosettacode.org',t]);

printf('Task "%s" has %i examples.\n',t(7:end), c);

Output:

=={{header|Nim}}==

proc count(s, sub: string): int =

inc sum, c

{{out}}

=={{header|Objeck}}==

use XML;

return xml;

}

Output:<pre>Amb: 28

ocamlfind opt -linkpkg -package str,unix,xml-light,netclient countex.ml -o countex.opt

let catmb = get_child "categorymembers" query in

List.iter f catmb

outputs:

{{libheader|OzHttpClient}}

[HTTPClient] = {Module.link ['x-ozlib://mesaros/net/HTTPClient.ozf']}

[XMLParser] = {Module.link ['x-oz://system/xml/Parser.ozf']}

end

in

Example output:

=={{header|Perl}}==

{{libheader|HTTP:Tiny}}

my $site = "http://rosettacode.org";

my $count = () = $response->{content} =~ /toclevel-1/g;

print "$_: $count examples\n";

{{libheader|Mojolicious}}

use Mojo::UserAgent;

my $count = $ua->get("$site/wiki/$slug")->res->dom->find("#toc .toclevel-1")->size;

say "$_->{title}: $count examples";

=={{header|Phix}}==

First, some common code used by several tasks:

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\rosettacode_cache.e

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

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

The task itself:

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Count_examples.exw

<span style="color: #7060A8;">progress</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Total: %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count_tasks</span><span style="color: #0000FF;">()})</span>

{{out}} (as of 30/2/22, showing first two, every 200th, and last two)

<pre>

=={{header|PicoLisp}}==

(client "rosettacode.org" 80

(unless (sub? "." (till "<" T))

(inc 'Cnt) ) )

Output (05may10):

<pre>100 doors: 79

=={{header|PureBasic}}==

If value = 0

MessageRequester("Error", msg)

Input()

CloseConsole()

Sample output:

<pre>100 doors: 224 examples

=={{header|Python}}==

import xml.dom.minidom

print(f'\nTotal: {sum(tasks)} examples.')

=={{header|R}}==

{{libheader|RCurl}}

library(XML)

library(RCurl)

}

cat("Total: ", length(unlist(counts)), "examples\n")

=={{header|Racket}}==

#lang racket

(printf "~a: ~a\n" task s)

s))

=={{header|Raku}}==

For a full output, see [[Rosetta_Code/Count_examples/Full_list|Top tier]], [[Rosetta_Code/Count_examples/Full_list/Tier_2|Second tier]], [[Rosetta_Code/Count_examples/Full_list/Tier_3|Third tier]], [[Rosetta_Code/Count_examples/Full_list/Tier_4|Fourth tier]]

use URI::Escape;

use JSON::Fast;

sub naturally ($a) { $a.lc.subst(/(\d+)/, ->$/ {0~(65+$0.chars).chr~$0},:g) }

{{out|Abridged output}}

=={{header|Ring}}==

# Project: Rosetta Code/Count examples

end

return sum

Output:

<pre>

{{libheader|REXML}}

First, a RosettaCode module, saved as <tt>rosettacode.rb</tt>:

require 'rexml/document'

end

Then, we implement the task with:

total_examples = 0

puts

=={{header|Run BASIC}}==

a$ = httpGet$("http://rosettacode.org/wiki/Category:Programming_Tasks")

wend

html "<tr bgcolor=wheat><td>**</td><td>** Total **</td><td align=right>";totExamp;"</td></tr></table>"

<table border=1><tr bgcolor=wheat align=center><td>Num</td><td>Task</td><td>Examples</td></tr>

<tr><td align=right>1</td><td>100 doors</td><td align=right>165</td></tr>

=={{header|Rust}}==

extern crate url;

extern crate rustc_serialize;

let json: Json = query_api(query).unwrap();

count_number_examples(&json, task.page_id).unwrap()

The function is then run using the following:

extern crate count_examples;

fn main() {

println!("Task: {} has {} examples", task.title, count);

}

=={{header|Scala}}==

object TaskCount extends App {

counts map (_.apply) map Function.tupled("%s: %d examples." format (_, _)) foreach println

println("\nTotal: %d examples." format (counts map (_.apply._2) sum))

=={{header|Sidef}}==

{{trans|Perl}}

var site = 'http://rosettacode.org';

var count = lwp.get("#{site}/wiki/#{slug}").decoded_content.count(/toclevel-1/g);

say "#{m[0]}: #{count} examples";

{{out}}

<pre>

=={{header|Tcl}}==

{{tcllib|json}}

package require http

package require json

}

=={{header|TUSCRIPT}}==

url="http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"

data=REQUEST (url)

FILE "tasks" = line

Output in file "tasks":

<pre style='height:30ex;overflow:scroll'>

Requires the <tt>curl</tt> and <tt>jq</tt> command-line utilities.

SITE=https://www.rosettacode.org

API=$SITE/mw/api.php

| jq -r '.query.categorymembers[].title')

=={{header|Wren}}==

{{libheader|Wren-pattern}}

An embedded program so we can use the libcurl library.

import "./pattern" for Pattern

}

<br>

which we now embed in the following C program, build and run.

#include <stdio.h>

free(script);

return 0;

{{out}}

=={{header|zkl}}==

Uses shared libraries YAJL and cURL and handles "continue" responses.

fcn getTasks(language){

cnt,n:=0,0; while(re.search(page,True,n)){ cnt+=1; n=re.matched[0].sum(0); }

"%4d: %s".fmt(cnt,task).println();

{{out}}

<pre>