Rosetta Code/Rank languages by popularity: Difference between revisions

 

 

...</pre>

 

 

=={{header|Ada}}==

{{libheader|AWS}}

with Ada.Strings.Fixed; use Ada.Strings.Fixed;

with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;

Counts.Reverse_Iterate (Display'Access);

end Test;

 

=={{header|ALGOL 68}}==

{{incorrect|ALGOL 68| <br> ---among others, Tcl (the top dog) is missing. <br>}}

 

IF grep in string("^HTTP/[0-9.]* 200", page, NIL, NIL) = 0

THEN TRUE

printf(($g(-0)". "g(-0)" - "gl$,i,stats[i]))

OD

{{out|Sample output}}

<pre>

 

===ALGOL 68:using the API===

CHAR line feed = REPR 10, carriage return = REPR 13;

STRING crlf = carriage return + line feed;

lasttied := tied

FI

{{out|Sample output top 10}}

<pre>

 

=={{header|AutoHotkey}}==

ValidUrl = http://rosettacode.org/wiki/Category:Programming_Languages

WebRequest := ComObjCreate("WinHttp.WinHttpRequest.5.1")

GuiClose:

ExitApp

 

=={{header|AWK}}==

This is the third solution. The [http://rosettacode.org/mw/index.php?title=Rosetta_Code/Rank_languages_by_popularity&oldid=102962#AWK first solution] used web scraping with an external program '''ns''' for networking. The [http://rosettacode.org/mw/index.php?title=Rosetta_Code/Rank_languages_by_popularity&oldid=204081 second solution] used the Rosetta Code API instead of web scraping, but continued use of '''ns''' which for unknown reasons didn't work correctly. This solution uses native gawk networking to connect to the API at 500 items per request ("gmcontinue").

 

result = array[start]

for (i = start + 1; i <= end; i++)

print ++i ". " language " - " G[language]

 

{{out|Output from 26 May 2015}}

<pre>1. Tcl - 867

{{works with|BBC BASIC for Windows}}

Note that language names differing only in their case are merged.

SortUp% = FN_sortinit(0,0) : REM Ascending

SortDown% = FN_sortinit(1,0) : REM Descending

UNTIL H%=0

SYS "CompareString", 0, NORM_IGNORECASE, S$, -1, a$(B%), -1 TO C%

'''Output:'''

<pre>

 

=={{header|Bracmat}}==

= url type

. !arg:(?url.?type)

)

)

Output:

<pre> 1. 816 - Tcl

{{improve|C|This solution uses an external program '''wget''' for networking, but it could use '''Library: libcurl''' (see [[Web scraping#C]]) for example. Also this solution scrapes Special:Categories &limit 5000 which will break if the HTML style changes or the number of languages exceeds 5000. It could use the MediWiki API to get the language names and pages in a single call, in blocks of 500 until complete with no upper limit. See the Awk example. If you make an API-based version please retain the web-scrapping version in its own sub-section (following the lead of [[Rosetta_Code/Rank_languages_by_popularity#Tcl|TCL on this page]]). }}

 

#include <stdlib.h>

#include <string.h>

 

return 0;

{{out}}

<pre> 563 Tcl

Usage: rank [number]<br>

Outputs the first [number] languages in the list, default to 10. Use -1 to display all the languages.

#include <stdio.h>

#include <stdlib.h>

} while (sorted!=1);

}

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

using System.Collections;

using System.Collections.Generic;

static void Main(string[] args)

{

 

ArrayList langs = new ArrayList();

Dictionary<string, int> qtdmbr = new Dictionary<string, int>();

 

 

 

foreach (Match match in match2)

if (langs.Contains(match.Groups[1].Value))

{

}

}

 

 

int count = 1;

foreach (string i in test)

{

count++;

}

}

. . .

===Object-oriented solution===

using System.Net;

using System.Linq;

}

}

 

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

{{libheader|Boost}}

using g++ under Linux with <tt>g++ -lboost_thread -lboost_system -lboost_regex</tt>:

#include <boost/regex.hpp>

#include <boost/asio.hpp>

}

return 0 ;

{{out|Sample output (just the "top ten")}}

1. 367 - Tcl

=={{header|Caché ObjectScript}}==

 

{

 

}

 

{{out|Example}}

<pre>

=={{header|D}}==

With dmd you need compile like "<tt>dmd rosetta_popularity.d -L-lphobos2 -L-lcurl</tt>".

import std.stdio, std.algorithm, std.conv, std.array, std.regex,

std.typecons, std.net.curl;

foreach (i, res; pairs.array.sort!q{a > b}.release)

writefln("%3d. %3d - %s", i + 1, res[]);

{{out|Sample output (top twenty as of 2013-01-24)}}

<pre> 1. 717 - Tcl

19. 462 - Unicon

20. 430 - AutoHotkey</pre>

 

=={{header|Erlang}}==

-module( rank_languages_by_popularity ).

 

place_count_category_write( Count, #print_fold{place=Place, place_step=Place_step} ) ->

#print_fold{place=Place + Place_step, previous_count=Count}.

{{out|Sample output (top/last ten as of 2013-05-27)}}

<pre>

 

=={{header|F_Sharp|F#}}==

open System.Text.RegularExpressions

(seq { 1 .. 20 })

(entriesWithCount |> Seq.map (fun x -> sprintf "%3d - %s" (snd x) (fst x)))

Showing top 20 as of 2013-04-02

<pre>

 

=={{header|Go}}==

 

import (

fmt.Printf("%3d. %3d - %s\n", lastIdx, lang.int, lang.string)

}

{{out|Output on 11 Aug 2014}}

<pre>

 

=={{header|Groovy}}==

connectTimeout:500,

readTimeout:15000,

count[language] = (members as int)

}

Output:

<pre>1 Tcl=766

===Haskell: Using the API===

 

 

import Data.Aeson

 

main :: IO ()

{{out}}

(As of 2015-07-29.) Here we show only the top 30.

 

Scraping the languages and categories pages.

import Network.HTTP

import Network.URI

mapM_ printFmt $ zip [1..] $ sortBy (flip (comparing snd))

{{out|First 20}}

<pre>*Main> mostPopLang

 

=={{header|HicEst}}==

DIMENSION RankNr(1)

 

ENDDO

DLG(Text=sortedCat, Format=$CRLF)

Top 10 entries (not all are languages)

1. 394 Tcl

8. 298 Perl

9. 288 WikiStubs

 

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

The following solution only works in Unicon.

 

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

$define RCXUA "X-Unicon: http://unicon.org/"

close(page)

return text

 

Abridged output (top 26 languages as of July 30, 2016):

</pre>

 

{{works with|J|6.02 (32 bit only)}}

 

x2jclass 'rcPopLang'

formatTab =: [: ;:^:_1: [: (20 A. (<'-') , |. , [: ('.' <"1@:,.~ ":) 1 + 1 i.@,~ 1{$)&.|: sortTab f.

 

1. 687 - Tcl

2. 646 - Python

8. 550 - D

9. 549 - Mathematica

'''Notes''': See some [[Talk:Sort most popular programming languages#J|notes on the J solution]].

 

Tested with Java 1.7. Uses the api.

import java.net.URLConnection;

import java.io.*;

} // for lPos

} // main

{{out}}

Top 10 languages as at 27th August 2015

</pre>

 

{{works with|jq|1.4}}

The following solution matches the languages listed on the Category:Programming_Languages page with the statistics given on the Special:Categories page, making an adjustment for the number of irrelevant subcategories.

 

jq 1.4 cannot retrieve documents over the web and has no support for regular expressions, but is intended to work seamlessly with other command line tools, so the following solution is presented in the form of a bash script that uses curl for retrieval, and grep and sed for screen scraping.

 

# produce lines of the form: [ "language", n ]

| reverse

| ranking[]

{{out}}

$ pop.sh

1. 868 - Tcl

386. 1 - Algae

386. 1 - 80386 Assembly

 

=={{header|Kotlin}}==

{{trans|Java}}

import java.io.*

 

}

}

{{out}}

<pre> 1, 901, Racket

 

=={{header|Lasso}}==

sys_listtraits !>> 'xml_tree_trait' ? include('xml_tree.lasso')

local(lang = array)

'. '+#l->second + ' - ' + #l->first+'\r'

^}

 

{{out}}

...</pre>

 

Languages = Most@StringReplace[Languages, {" " -> "_", "+" -> "%2B"}];

b = {#, If[# === {}, 0, #[[1]]]&@( StringCases[Import["http://rosettacode.org/wiki/Category:"<>#,"Plaintext"],

"category, out of " ~~ x:NumberString ~~ " total" ->x])} &/@ Languages;

{{out|Output : As of 29 February 2012}}

<pre>

 

=={{header|Nim}}==

 

const

let regex = re"title=""Category:(.*?)"">.+?</a>.*\((.*) members\)"

 

 

let lang = line.replacef(regex, "$1")

if lang in langs:

 

Output:

...</pre>

 

=={{header|Objeck}}==

use RegEx;

use XML;

};

}

 

<pre>1. 849 - Tcl

=={{header|ooRexx}}==

{{trans|REXX}}

* Create a list of Rosetta Code languages showing the number of tasks

* This program's logic is basically that of the REXX program

* RC_LNG.txt list of languages alphabetically sorted

* RC_TRN.txt list language name translations (debug)

*--------------------------------------------------------------------*/

test=1

If \l._ Then /* not a known language */

Iterate /* ignore */

If\datatype(mems,'W') Then /* not a number of members */

Iterate /* ignore */

* These two lines

* * Lotus 123 Macro Scripting

* are returned as one line:

*-> * Lotus 123 Macro Scripting </wiki/Cate ... (3 members)

If ta<<tb Then res=-1

Else res=1

 

Output (the beginning):

</pre>

Note: If MC++ and µC++ are the same, they should/could be added together to get 501 languages.

 

=={{header|Oz}}==

{{libheader|OzHttpClient}}

Using web scraping. Does not filter non-language categories.

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

[Regex] = {Module.link ['x-oz://contrib/regex']}

do

{System.showInfo I#". "#Count#" - "#Cat}

{{out}}

<pre>

=={{header|Perl}}==

===By using the API===

use MediaWiki::API;

 

my $api =

 

my @languages;

$_->{'categoryinfo'}{'size'};

}

 

{{out}}

 

=={{header|PicoLisp}}==

 

(for (I . X)

(when (format (till " " T))

(link (cons @ (ht:Pack Cat))) ) ) ) ) ) ) )

{{out|Output (dec15)}}

<pre> 1. 903 - Racket

 

=={{header|PowerShell}}==

$get1 = (New-Object Net.WebClient).DownloadString("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Languages&cmlimit=700&format=json")

$get2 = (New-Object Net.WebClient).DownloadString("http://www.rosettacode.org/w/index.php?title=Special:Categories&limit=5000")

}

}| Format-Table -AutoSize

<b>Output: August 04, 2015</b>

<pre>

29 441 PARI/GP 59 249 Delphi

30 434 JavaScript 60 239 Smalltalk

</pre>

 

=={{header|PureBasic}}==

===Using MediaWiki API method===

If value = 0

MessageRequester("Error", msg)

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre>608 languages.

 

===Using web scraping method===

;Uses a web scraping method.

 

PrintN( Str(i + 1) + ". " + Str(Row(i)\count) + " - " + Row(i)\Name)

Next

Sample output:

<pre>1. 907 - Racket

 

===Python: Using web scraping===

Using <code>requests</code> library.

 

import re

 

 

 

 

 

 

 

 

 

 

 

 

 

library(rvest)

library(dplyr)

options(stringsAsFactors=FALSE)

 

 

 

 

 

 

<pre>

</pre>

 

=={{header|Racket}}==

 

 

 

 

 

 

</pre>

 

Recent, occasionally (hourly-ish) updated output also available at:

 

=={{header|REXX}}==

 

<br>This program reads the &nbsp; ''Languages'' &nbsp; file and uses the contents of that file for a validation of

The mechanism is to use a (sparse) stemmed array which holds only the names of languages which

<br>(for most REXXes) uses a hashing algorithm to locate the entry &nbsp; (which is very fast).

(The 3^rd entry is most likely caused by the inability to render unsupported glyphs when it was first used to add that language.)

 

Note that this REXX example properly ranks tied languages.

 

===REXX program===

parse arg catFID lanFID outFID . /*obtain optional arguments from the CL*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

else do while #.k<#.j /*this uses a hard swap ↓*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

 

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

 

The '''output''' &nbsp; for this REXX (RC_POP.REX) program is included here &nbsp; ──► &nbsp; [[RC_POP.OUT]].

 

 

 

=={{header|Ruby}}==

 

Uses the <code>RosettaCode</code> module from [[Count programming examples#Ruby]]

 

langs = []

langcount.sort_by {|key,val| val}.reverse[0,25].each_with_index do |(lang, count), i|

puts "#{i+1}. #{count} - #{lang.sub(/Category:/, '')}"

{{out|Results}}

<pre style="height: 40ex; overflow: scroll">2010-07-08 14:52:46 -0500

 

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

#mem execute("CREATE TABLE stats(lang,cnt)")

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

html "<TR><TD align=right>";rank;"</td><td>";#row lang$();"</td><td align=right>";#row cnt();"</td></tr>"

WEND

<table border=2>

<TR><TD align=right>1</td><td>Tcl</td><td align=right>687</td></tr>

===Parallel internet querying===

Entry point @ object <code>GhettoParserPar</code>

import scala.collection.immutable.TreeSet

import scala.xml.XML

Concurrent.logInfo("Parallel version started")

ActorSystem("Main").actorOf(Props[Concurrent.Listener])

 

===Sequential internet querying===

 

=={{header|Seed7}}==

include "gethttp.s7i";

include "scanstri.s7i";

place +:= length(ranking[numList[listIdx]]);

end for;

 

List of languages as of 2014-01-15:

=={{header|Sidef}}==

{{trans|Perl}}

 

var api = %O<MediaWiki::API>.new(

sorted_languages.each_kv { |i, lang|

printf("%3d. %20s - %3d\n", i+1, lang{:title}, lang{:categoryinfo}{:size})

{{out}}

<pre>

=={{header|SNOBOL4}}==

{{Works with|SNOBOL4|CSNOBOL4 CVS test}}

http.recl = "K,32767" ;* Read next 32767 characters

;* of very long lines.

read line = line fin :f(done)

get line languagepat = :f(read)

done langarray = rsort(langtable,2) :s(write)

url.close(.fin)

 

'''Abridged output (top 30 languages as of August 25, 2015):'''

First we build the database:

 

import delimited lang.html, delim("@") enc("utf-8") clear

keep if ustrpos(v1,"/wiki/Category:")

gen rank=1

replace rank=rank[_n-1]+(count[_n]!=count[_n-1]) in 2/l

 

Now some results, as of 2017-12-03:

 

qui sum n

di r(sum)

| Ruby 845 9 |

| Go 828 10 |

 

=={{header|Tcl}}==

===By web scraping===

package require http

lassign $entry num lang

puts [format "%d. %d - %s" [incr i] $num $lang]

{{out|Output on 29 July 2015 (top 20 entries only)}}

<pre>1. 887 - Tcl

{{libheader|tDOM}}

 

package require http

package require tdom

}

 

 

{{out}}

 

=={{header|TUSCRIPT}}==

remotedata = REQUEST ("http://www.rosettacode.org/mw/index.php?title=Special:Categories&limit=5000")

allmembers=allnames=""

balt=b

ENDLOOP

{{out}}

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

 

{{libheader|curl}}

sed -nre 's/^<li.*title="Category:([^"(]+)".*\(([0-9]+) members\).*/\2 - \1/p' |

 

=={{header|VBScript}}==

Uses the API. Instead of displaying it on the command prompt, the records of the languages are saved on a text file "OutVBRC.txt" encoded with Unicode.

' Rosetta Code/Rank Languages by Popularity '

' VBScript Implementation '

Set HTML = Nothing

Set objFSO = Nothing

{{Out|Some Parts of Output as of December 31, 2016}}

<pre>As of 12/31/2016 11:52:05 PM, RC has 624 languages.

0 Examples - WML

0 Examples - VAX Assembly</pre>

 

=={{header|zkl}}==

This solution using the API as the web scraping URL is pretty slow.

I'm using JSON as format=txt has been deprecated.

 

fcn getLangCounts(language){ // -->( (count,lang), ...)

println("Most popular Rosetta Code languages as of ",Time.Date.prettyDay());

foreach n,name in ([1..15].zip(langCounts))

{{out}}

<pre>