👩🏻‍🚒 🚵 🐮 रोसेटा कोड: बड़ी संख्या में प्रोग्रामिंग भाषाओं में कोड की लंबाई को मापते हैं, एक दूसरे से भाषाओं की निकटता का अध्ययन करते हैं 〰️ 👡 👩🏿‍🍳

आप मेरे ब्लॉग पर मूल पोस्ट में कोड और डेटा के साथ फाइल डाउनलोड कर सकते हैं

एक बहुत ही दिलचस्प परियोजना है - " रोसेटा कोड" । उनका लक्ष्य "अलग-अलग प्रोग्रामिंग भाषाओं की सबसे बड़ी संख्या में समान समस्याओं के समाधान को प्रस्तुत करना है ताकि उनके सामान्य स्थानों और मतभेदों को प्रदर्शित किया जा सके और एक ऐसे व्यक्ति की मदद कर सकें, जिसके पास सीखने के लिए एक विधि के साथ समस्या को हल करने का ज्ञान हो।"

यह संसाधन विभिन्न भाषाओं में प्रोग्राम कोड की तुलना करने का एक अनूठा अवसर प्रदान करता है, जो हम इस लेख में करेंगे। यह जॉन मैकलेन द्वारा " 14 भाषाओं में कोड लंबाई मापी गई" लेख का पूर्ण संशोधन और शोधन है।

डेटा आयात और पार्स करना

आइए आयात फ़ंक्शन में एक संशोधन करके शुरू करें जो भविष्य में उपयोग के लिए डेटा संग्रहीत करेगा ताकि सर्वर से बाद में इसका अनुरोध न करें।

Clear[importOnce]; importOnce[args___]:=importOnce[args]=Import[args]; If[FileExistsQ[#], Get[#], Null]&@FileNameJoin[{NotebookDirectory[], "importOnce.mx"}]

डेटा आयात करने के लिए एक पार्सर बनाएं।

 Clear[createPageLinkDataset]; createPageLinkDataset[baseLink_]:=createPageLinkDataset[baseLink]=Cases[Cases[Import[baseLink, "XMLObject"], XMLElement["div", {"class"->"mw-content-ltr", "dir"->"ltr", "lang"->"en"}, data_]:>data, Infinity], XMLElement["li", {}, {XMLElement["a", {___, "href"->link_, ___}, {name_}]}]:><|"name"->name, "link"->"http://rosettacode.org"<>link|>, Infinity]; If[FileExistsQ[#], Get[#], Null]&@FileNameJoin[{NotebookDirectory[], "createPageLinkDataset.mx"}]

हम परियोजना द्वारा समर्थित सभी प्रोग्रामिंग भाषाओं की सूची आयात करते हैं (पहले से ही उनमें से 750 से अधिक हैं):

 $Languages=createPageLinkDataset["http://rosettacode.org/wiki/Category:Programming_Languages"]; Dataset@$Languages

हम एक लिंक में नाम का अनुवाद करने के लिए कार्य करेंगे और इसके विपरीत, यह बाद में हमारे लिए उपयोगी होगा:

 langLinkToName[link_String]:=langLinkToName[link]=SelectFirst[$Languages, #[["link"]]==link&]["name"]; langNameToLink[name_String]:=langNameToLink[name]=SelectFirst[$Languages, #[["name"]]==name&]["link"];

हम प्रत्येक प्रोग्रामिंग भाषाओं में हल किए गए कार्यों की सूची को लोड करेंगे। पार्सिंग को डिज़ाइन किया गया है ताकि पृष्ठों के सभी लिंक कार्य न हों। हम उन्हें बाद में साफ करेंगे।

 $LangTasksAllPre=Map[<|"name"->#["name"], "link"->#["link"], "tasks"->createPageLinkDataset[#["link"]][[All, "link"]]|>&, $Languages]; Dataset@$LangTasksAllPre

हम उन सभी संभावित कार्यों की सूची की गणना करते हैं जिन्हें परियोजना में हल किया जा सकता है (उनमें से केवल 2600 से अधिक हैं):

 $TasksPre=DeleteDuplicates[Flatten[$LangTasksAllPre[[;;, "tasks"]]]]; Length[$TasksPre]

आइए एक फ़ंक्शन बनाएं जो कार्य पृष्ठ पर सभी कोड अंशों को कैप्चर करता है।

 ClearAll[codeExtractor]; codeExtractor[link_String]:=Module[{code, positions, rawData}, code=importOnce[link, "XMLObject"]; positions=Map[{#[[1, 1;;-2]], Partition[#[[;;, -1]], 2, 1]}&, DeleteCases[ Gather[ Position[code, XMLElement["h2", _, title_]], And[Length[#1]==Length[#2], #1[[1;;-2]]==#2[[1;;-2]]]&], x_/; Length[x]==1]]; rawData=Framed/@Flatten[Map[ With[{pos=#[[1]]}, Map[Extract[code, pos][[#[[1]];;#[[2]]-1]]&, #[[2]]]]&, positions], 1]; Association@DeleteCases[Map[langLinkToName[("link"/.#)]->("code"/.#)&, Map[ KeyValueMap[If[#1==="link", #1->#2[[1]], #1->#2]&, Merge[SequenceSplit[Cases[#, Highlighted[x_, ___]:>x, Infinity], {"Output"}][[1]], Identity]]&, rawData/.{XMLElement["h2", _, title_]:>Cases[title, XMLElement["a", {___, "href"->linkInner_/; MemberQ[$Languages[[;;, "link"]], "http://rosettacode.org"<>linkInner], ___}, {___}]:>Highlighted[<|"link"->"http://rosettacode.org"<>linkInner|>], Infinity], XMLElement["div", {}, x_/; Not[FreeQ[x, "Output:"]]]:>Highlighted["Output"], XMLElement["pre", _, code_]:>Highlighted[<|"code"->Check[StringJoin@Flatten[code//.XMLElement["span", _, codeFragment_]:>codeFragment//.XMLElement["br", {"clear"->"none"}, {}]:>"\n"//.XMLElement["a", {___}, codeFragment_]:>codeFragment//.XMLElement["b", {}, {x_}]:>x//.XMLElement["big", {}, {x_}]:>x//.XMLElement["sup", {}, x_]:>Flatten[x]//.XMLElement["sub", {}, x_]:>Flatten[x]//.XMLElement[_, {___}, x_]:>Flatten[x]], Echo[StringJoin@Flatten[code//.XMLElement["span", _, codeFragment_]:>codeFragment//.XMLElement["br", {"clear"->"none"}, {}]:>"\n"//.XMLElement["a", {___}, codeFragment_]:>codeFragment//.XMLElement["b", {}, {x_}]:>x//.XMLElement["big", {}, {x_}]:>x//.XMLElement["sup", {}, x_]:>Flatten[x]//.XMLElement["sub", {}, x_]:>Flatten[x]//.XMLElement[_, {___}, x_]:>Flatten[x]]]]|>, Background->Red]} ]], _->"code"]];

अब हम सभी पृष्ठों को संसाधित करेंगे:

 ClearAll[taskCodes]; taskCodes[link_]:=taskCodes[link]=Check[codeExtractor[link], Echo[link]]; If[FileExistsQ[#], Get[#], taskCodes/@$TasksPre; DumpSave[#, taskCodes]]&@FileNameJoin[{NotebookDirectory[], "taskCodes.mx"}];

फ़ंक्शन क्या पैदा करता है इसका एक उदाहरण:

 Dataset[taskCodes[$TasksPre[[20]]]]

लंबी तस्वीर

कार्य पृष्ठ (कोड के कम से कम एक टुकड़े वाले) का चयन करें:

 $taskLangs=DeleteCases[{#, taskCodes[#]}&/@$TasksPre, {_, <||>}];

 $langTasks=Map[<|"name"->#[["name"]], "link"->#[["link"]], "tasks"->With[{lang=#[["name"]]}, Select[$taskLangs, MemberQ[Keys[#[[2]]], lang]&][[;;, 1]]]|>&, $Languages]; Dataset[$langTasks]

कार्यों और कार्यों की एक सूची जो लिंक में कार्य नाम का अनुवाद करती है, और इसके विपरीत:

 $Tasks=<|"name"->StringReplace[URLDecode[StringReplace[#, "http://rosettacode.org/wiki/"->""]], {"_"->" ", "/"->" -> "}], "link"->#|>&/@$taskLangs[[;;, 1]]; taskLinkToName[link_String]:=langLinkToName[link]=SelectFirst[$Tasks, #[["link"]]==link&]["name"]; taskNameToLink[name_String]:=langNameToLink[name]=SelectFirst[$Tasks, #[["name"]]==name&]["link"];

सरल आँकड़े

कई भाषाओं के लिए, अभी भी कोई समस्या हल नहीं हुई है:

 WordCloud[1/StringLength[#]->#&/@Select[$langTasks, Length[#["tasks"]]==0&][[All, "name"]], ImageSize->{1200, 800}, MaxItems->All, WordOrientation->{{-Pi/4, Pi/4}}, FontTracking->"Extended", Background->GrayLevel[0.98], FontFamily->"Intro"]

उन भाषाओं की सूची, जिन्होंने समस्याओं को हल किया है:

 $LanguagesWithTasks=Select[$langTasks, Length[#["tasks"]]=!=0&][[All, "name"]]; Length[$LanguagesWithTasks]

भाषा द्वारा हल की गई समस्याओं की संख्या का वितरण:

 Histogram[Length/@$langTasks[[;;, "tasks"]], 50, PlotRange->All, BarOrigin->Bottom, AspectRatio->1/2, ImageSize->700, Background->White, Frame->True, GridLines->Automatic, FrameLabel->Map[Style[#, 20]&, {" ", lg[" "]}], ScalingFunctions->"Log10", PlotLabel->Style["     ", 20]]

हल किए गए कार्यों द्वारा भाषाओं की संख्या का वितरण:

 Histogram[Length/@$taskLangs[[;;, 2]], 50, PlotRange->All, AspectRatio->1/2, ImageSize->700, Background->White, Frame->True, GridLines->Automatic, FrameLabel->Map[Style[#, 20]&, {" ", " "}], PlotLabel->Style["     ", 20]]

वे भाषाएँ जिनमें सबसे अधिक हल की गई समस्याएं हैं:

 BarChart[#1[[;;, 2]], PlotRangePadding->0, BarSpacing -> 0.1, BarOrigin -> Left, AspectRatio -> 1, ImageSize -> 1000, ChartLabels -> #1[[;;, 1]], Frame -> True, GridLines -> {Range[0, 10^3, 50], None}, ColorFunction -> ColorData["Rainbow"], FrameLabel->{{None, None}, Style[#, FontFamily->"Open Sans Light", 16]&/@{"  ", "  "}}, FrameTicks->{Automatic, {All, All}}, Background->White] &@DeleteCases[SortBy[{#[["name"]], Length[#[["tasks"]]]}&/@$langTasks, Last], {_, x_/; x<200}]

प्रोग्रामिंग भाषाओं की सबसे बड़ी संख्या में हल किए गए कार्य:

 BarChart[#1[[;;, 2]], PlotRangePadding->0, BarSpacing -> 0.2, BarOrigin -> Left, AspectRatio -> 1.6, ImageSize -> 1000, ChartLabels -> #1[[;;, 1]], Frame -> True, GridLines -> {Range[0, 10^3, 50], None}, ColorFunction -> ColorData["Rainbow"], FrameLabel->{{None, None}, Style[#, FontFamily->"Open Sans Light", 16]&/@{"  ", "  "}}, FrameTicks->{Automatic, {All, All}}, Background->White] &@DeleteCases[SortBy[{taskLinkToName[#[[1]]], Length[#[[2]]]}&/@$taskLangs, Last], {_, x_/; x<100}]

कार्य जो प्रोग्रामिंग भाषाओं के दिए गए सेट के लिए एक समाधान है

एक फ़ंक्शन जो एक बार में एक या अधिक प्रोग्रामिंग भाषाओं में हल किए गए कार्यों को प्रदर्शित करता है:

 commonTasks[lang_String]:=commonTasks[lang]=Sort[SelectFirst[$langTasks, #["name"]==lang&][["tasks"]]]; commonTasks["Mathematica"]:=commonTasks["Mathematica"]=Union[commonTasks["Wolfram Language"], Sort[SelectFirst[$langTasks, #["name"]=="Mathematica"&][["tasks"]]]]; commonTasks[lang_List]:=commonTasks[lang]=Sort[Intersection@@(commonTasks/@lang)];

पहले 25 सबसे लोकप्रिय भाषाओं के लिए कार्य (फ़ॉन्ट आकार उन भाषाओं की सापेक्ष संख्या से मेल खाता है जिनमें समस्या हल हो गई है):

 WordCloud[With[{tasks=taskLinkToName/@commonTasks[SortBy[{#[["name"]], Length[#[["tasks"]]]}&/@$langTasks, Last][[-25;;-1]][[;;, 1]]]}, Transpose@{tasks, tasks/.Rule@@@SortBy[{taskLinkToName[#[[1]]], Length[#[[2]]]}&/@$taskLangs, Last]}], ImageSize->{1000, 1000}, MaxItems->All, WordOrientation->{{-Pi/4, Pi/4, 0, Pi/2}}, Background->GrayLevel[0.98], FontFamily->"Intro"]

कोड की लंबाई मापने का कार्य

अगला, हमें कोड लंबाई का अनुमान लगाने के लिए एक मीट्रिक की आवश्यकता है। आमतौर पर यह माना जाता है कि यह कोड की संख्या है:

 SetAttributes[lineCount, Listable] lineCount[str_String]:=StringCount[StringReplace[StringReplace[str, {" "->"", "\t"->""}], "\n"..->"\n"], "\n"]+1;

लेकिन चूंकि यह पैरामीटर कोड के मार्कअप से काफी प्रभावित होता है (अंत में, कहते हैं, वुल्फराम लैंगिएज ( मैथेमेटिका ) में आप एक बार में एक पंक्ति में कई कमांड लिख सकते हैं), हम उन वर्णों की संख्या का उपयोग करेंगे जो मीट्रिक के रूप में स्थान नहीं हैं।

 SetAttributes[characterCount, Listable] characterCount[str_String]:=StringLength[StringReplace[str, WhitespaceCharacter->""]];

ऐसा मीट्रिक अपने लंबे वर्णनात्मक आदेश नामों (जो इस ब्लॉग के बाहर निस्संदेह एक बड़ा प्लस है) के साथ गणितज्ञ के हाथों में नहीं खेलता है; इसलिए, हम भी गिनती टोकन ("प्रतीकात्मक") वस्तुओं के आधार पर एक मीट्रिक लागू करते हैं, जिसके लिए हम किसी भी वर्ण द्वारा अलग किए गए अलग-अलग शब्दों को लेंगे जो कि एक अक्षर नहीं है। पत्र।

 SetAttributes[tokens, Listable] tokens[str_String]:=DeleteCases[StringSplit[str, Complement[Characters@FromCharacterCode[Range[1, 127]], CharacterRange["a", "z"], CharacterRange["A", "Z"], CharacterRange["0", "9"], {"."}]], ""]; tokenCount[str_String]:=Length[tokens[str]];

कोड लंबाई माप

हमें प्रत्येक कार्य के बारे में एक डेटा सेट मिलता है:

 $taskData=Map[<|"name"->#[[1]], "lineCount"->Map[lineCount, #[[2]]], "characterCount"->Map[characterCount, #[[2]]], "tokens"->Map[Flatten[tokens[#]]&, #[[2]]]|>&, $taskLangs]; Dataset[$taskData]

एक फ़ंक्शन जो उस पर हल किए गए सभी कार्यों के बारे में प्रत्येक भाषा के लिए आंकड़े एकत्र करता है:

 Clear[langData]; langData[name_]:=langData[name]=<|"name"->name, "lineCount"->If[name==="Mathematica", DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "lineCount"]], name]]]~Join~DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "lineCount"]], "Wolfram Language"]]], AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "lineCount"]], name]]], "characterCount"->If[name==="Mathematica", DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "characterCount"]], name]]]~Join~DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "characterCount"]], "Wolfram Language"]]], AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "characterCount"]], name]]], "tokens"->If[name==="Mathematica", DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "tokens"]], name]]]~Join~DeleteMissing[AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "tokens"]], "Wolfram Language"]]], AssociationThread[#[[;;, "name"]]->Lookup[#[[;;, "tokens"]], name]]]|>&@(With[{task=#}, SelectFirst[$taskData, #[["name"]]==task&]]&/@commonTasks[name]); Map[langData, $LanguagesWithTasks];

एक फ़ंक्शन जो सभी सामान्य कार्यों के आधार पर दो (या अधिक) प्रोग्रामिंग भाषाओं के लिए तुलना मैट्रिक्स की तुलना करता है:

 ClearAll[compareLanguagesData, compareLanguages]; compareLanguagesData[langs_List/; Length[langs]>=2]:=compareLanguagesData[langs]=Module[{tasks, data}, tasks=commonTasks[langs]; data=langData/@langs; <|"lineCount"->Transpose[Lookup[#[["lineCount"]], tasks][[;;, 1]]&/@data], "characterCount"->Transpose[Lookup[#[["characterCount"]], tasks][[;;, 1]]&/@data], "tokensCount"->Transpose[Lookup[Map[Length, #[["tokens"]]], tasks]&/@data]|> ]; compareLanguages[langs_List/; Length[langs]>=2, function_]:=Module[{data}, data=compareLanguagesData[langs]; Map[Map[function, #]&, data] ];

विश्लेषण और दृश्य

अब हम बहुत सारे विश्लेषिकी प्राप्त कर सकते हैं।

शुरू करने के लिए, हम पूर्ण संकेतकों की तुलना करते हैं। नीचे दिया गया फ़ंक्शन एक ग्राफ़ बनाता है जिसमें डॉट्स दो भाषाओं के लिए संबंधित मान दिखाते हैं। यदि बिंदु विकर्ण रेखा के नीचे है (कुल्हाड़ियों के साथ पैमाने अलग है, तो अक्सर यदि कोड की लंबाई बहुत भिन्न होती है), इसका मतलब है कि नीचे से भाषा "जीता", अन्यथा भाषा "ऊपर से" है।

 compareGraphic[{lang1_, lang2_}]:= Grid[{#[[1;;2]], {#[[3]], SpanFromLeft}}&@KeyValueMap[Graphics[{Map[{If[#[[1]]<#[[2]], Orange, Darker@Green], Point[#]}&, #2], AbsoluteThickness[2], Gray, InfiniteLine[{{0, 0}, {1, 1}}]}, PlotRangePadding->0, GridLines->Automatic, AspectRatio->1, PlotRange->All, Frame->True, ImageSize->500, Background->White, FrameLabel->(Style[#/."Mathematica"->"Wolfram Language (Mathematica)", 16, FontFamily->"Open Sans Light"]&/@{lang1, lang2}), PlotLabel->(Style[(#1/.{"lineCount"->"  ", "characterCount"->"   ", "tokensCount"->"   "}), 20, FontFamily->"Open Sans Light"])]&, compareLanguages[{lang1, lang2}, Identity]], Background->White]

आप स्पष्ट रूप से देख सकते हैं कि वुल्फराम भाषा कोड हमेशा C कोड से लगभग छोटा होता है:

 compareGraphic[{"Mathematica", "C"}]

या पायथन:

 compareGraphic[{"Mathematica", "Python"}]

और यहां, उदाहरण के लिए, कोटलिन और जावा अनिवार्य रूप से कोड लंबाई के मामले में "समान" हैं:

 compareGraphic[{"Kotlin", "Java"}]

इस ग्राफिक प्रतिनिधित्व को और अधिक जानकारीपूर्ण बनाया जा सकता है:

 comparePlot[{lang1_, lang2_}]:= Grid[{#[[1;;2]], {#[[3]], SpanFromLeft}}&@KeyValueMap[ListLinePlot[Sort@#2, GridLines->Automatic, AspectRatio->1, PlotRange->{Automatic, {0, 2}}, Frame->True, ImageSize->500, Background->White, FrameLabel->(Style[#/."Mathematica"->"Wolfram Language (Mathematica)", 16, FontFamily->"Open Sans Light"]&/@{lang1, lang2}), PlotLabel->(Style[(#1/.{"lineCount"->"  ", "characterCount"->"   ", "tokensCount"->"   "}), 20, FontFamily->"Open Sans Light"]), ColorFunction->(If[#2>1, Orange, Darker@Green]&), ColorFunctionScaling->False, PlotStyle->AbsoluteThickness[3]]&, compareLanguages[{lang1, lang2}, Divide[#[[1]], #[[2]]]&]], Background->White]

 comparePlot[{"Mathematica", "R"}]

 comparePlot[{"BASIC", "ALGOL 68"}]

हम एक फ़ंक्शन को परिभाषित करते हैं जो "लोकप्रिय" प्रोग्रामिंग भाषाओं की सूची प्रदर्शित करेगा (जो सबसे बड़ी संख्या में हल किए गए कार्य हैं):

 Clear[$popularLanguages]; $popularLanguages[n_/; n>2]:=$popularLanguages[n]=Reverse[SortBy[{#[["name"]], Length[#[["tasks"]]]}&/@$langTasks, Last][[-n;;-1]]]

 $popularLanguages[25]

हम पहले 350 भाषाओं की सूची की कल्पना करते हैं (इस तरह इस पोस्ट के लिए स्क्रीनसेवर की शुरुआत में बनाया गया था):

 WordCloud[$popularLanguages[350], ColorNegate@Binarize@ImageCrop@Import@"D:\\YandexDisk\\WolframMathematicaRuFiles\\388-3885229_rosetta-stone-silhouette-stone-silhouette-png-transparent-png.png", ImageSize->1000, MaxItems->All, WordOrientation->{{-Pi/4, Pi/4}}, FontTracking->"Extended", Background->GrayLevel[0.98], FontFamily->"Intro"]

एक फ़ंक्शन जो n पहली लोकप्रिय भाषाओं के लिए विभिन्न मैट्रिक्स में कोड लंबाई विश्लेषण प्रदर्शित करता है:

 ClearAll[langMetricsGrid]; langMetricsGrid[n_Integer, type_, OptionsPattern[{"SortQ"->True, "measureFunction"->Mean}]]:=Module[{$nPL, $pl, tableData, scale, notSortedTableData, order, fullTableData, min, max, orderedMeans, meanFunction}, $nPL=n; meanFunction[{lang1_, lang2_}]:=Quiet[Map[Median[N[#]]&, compareLanguages[{lang1, lang2}, Divide[#[[1]], #[[2]]]&]/.ComplexInfinity->Nothing/.Indeterminate->Nothing]]; $pl=$popularLanguages[$nPL][[;;, 1]]; tableData=Quiet@Table[If[i==j, "", meanFunction[{$pl[[i]], $pl[[j]]}][[type]]], {i, 1, $nPL}, {j, 1, $nPL}]; order=If[OptionValue["SortQ"], Ordering[tableData, All, OptionValue["measureFunction"][#1/.""->Nothing]<OptionValue["measureFunction"][#2/.""->Nothing]&], Range[1, $nPL]]; orderedMeans=Round[If[OptionValue["SortQ"], Map[Mean, tableData/.""->Nothing][[order]], Map[Mean, tableData/.""->Nothing]], 1/1000]//N; {min, max}=MinMax[Cases[Flatten[tableData], _?NumericQ]]; scale=Function[Evaluate[Rescale[#, {min, max}, {0, 1}]]]; fullTableData=Transpose[{{""}~Join~$pl[[order]]}~Join~{{""}~Join~orderedMeans}~Join~Transpose[{Map[Rotate[#, 90Degree]&, $pl]}~Join~ReplaceAll[tableData, x_?NumericQ:>Item[Round[x, 1/100]//N, Background->Which[x<1, LightGreen, x==1, LightBlue, x>1, LightRed]]][[order]]/.""->Item["", Background->Gray]]]; Framed[Labeled[Style[Row[{"    ", Style[type/.{"lineCount"->" ", "characterCount"->"  ", "tokensCount"->"  "}, Bold], "\n      "}], 22, FontFamily->"Open Sans Light", TextAlignment->Center], Grid[fullTableData, Background->White, ItemStyle->Directive[FontSize -> 12, FontFamily->"Open Sans Light"], Dividers->White]], FrameStyle->None, Background->White]];

विभिन्न प्रोग्रामिंग भाषाओं में समस्याओं को हल करने में कोड की लाइनों की संख्या के अनुपात का औसत मूल्य:

 langMetricsGrid[25, "lineCount", "SortQ"->False]

यदि आप "औसत" कॉलम द्वारा तालिका को सॉर्ट करते हैं, तो यह अधिक स्पष्ट होगा - वोल्फ्राम भाषा (गणित) लीड:

 langMetricsGrid[25, "lineCount", "SortQ"->True]

विभिन्न प्रोग्रामिंग भाषाओं में समस्याओं को हल करने में कोड में वर्णों की संख्या के अनुपात का औसत मूल्य:

 langMetricsGrid[25, "characterCount", "SortQ"->True]

विभिन्न प्रोग्रामिंग भाषाओं में समस्याओं को हल करने में कोड में टोकन की संख्या के अनुपात का औसत मूल्य:

 langMetricsGrid[25, "tokensCount", "SortQ"->True]

पहले 50 सबसे लोकप्रिय भाषाओं के लिए एक ही टेबल बनाई जा सकती है, कहते हैं:

 langMetricsGrid[50, "lineCount", "SortQ"->True] langMetricsGrid[50, "characterCount", "SortQ"->True] langMetricsGrid[50, "tokensCount", "SortQ"->True]

हम एक ही जानकारी को और अधिक कॉम्पैक्ट रूप से कल्पना कर सकते हैं - एक मूंछ वाले बॉक्स के रूप में (बॉक्स-एंड-व्हिकर्स डायग्राम):

 ClearAll[langMetricsBoxWhiskerChart]; langMetricsBoxWhiskerChart[n_Integer, type_, OptionsPattern[{"SortQ"->True, "measureFunction"->Mean}]]:=Module[{$nPL, $pl, tableData, scale, notSortedTableData, order, fullTableData, min, max, orderedMeans, meanFunction}, $nPL=n; meanFunction[{lang1_, lang2_}]:=Quiet[Map[Median[N[#]]&, compareLanguages[{lang1, lang2}, Divide[#[[1]], #[[2]]]&]/.ComplexInfinity->Nothing/.Indeterminate->Nothing]]; $pl=Reverse@$popularLanguages[$nPL][[;;, 1]]; tableData=Quiet@Table[If[i==j, "", meanFunction[{$pl[[i]], $pl[[j]]}][[type]]], {i, 1, $nPL}, {j, 1, $nPL}]; order=If[OptionValue["SortQ"], Ordering[tableData, All, OptionValue["measureFunction"][#1/.""->Nothing]>OptionValue["measureFunction"][#2/.""->Nothing]&], Range[1, $nPL]]; Framed[Labeled[Style[Row[{"    ", Style[type/.{"lineCount"->" ", "characterCount"->"  ", "tokensCount"->"  "}, Bold], "\n      "}], 22, FontFamily->"Open Sans Light", TextAlignment->Center], BoxWhiskerChart[tableData[[order]], "Outliers", ChartLabels->$pl[[order]], BarOrigin->Left, ImageSize->1000, AspectRatio->1, GridLines->{Range[0, 20, 1/2], None}, FrameTicks->{Range[0, 20, 0.5], Automatic}, PlotRangePadding->0, PlotRange->{{0, 8}, Automatic}, Background->White] ], FrameStyle->None, Background->White]];

भाषाएं लोकप्रियता द्वारा क्रमबद्ध होती हैं (आरेख भाषाओं के बीच कोड की संख्या की संख्या का अनुपात दिखाता है):

 langMetricsBoxWhiskerChart[80, "lineCount", "SortQ"->False]

औसत मूल्य द्वारा:

 langMetricsBoxWhiskerChart[80, "lineCount", "SortQ"->True]

अंत में, वर्ण और टोकन की संख्या के बारे में चार्ट:

 langMetricsBoxWhiskerChart[80, "characterCount", "SortQ"->True] langMetricsBoxWhiskerChart[80, "tokensCount", "SortQ"->True]

आइए देखें कि विभिन्न भाषाओं में कौन से टोकन लोकप्रिय हैं:

 languagePopularTokens[lang_, nMin_:50]:=Framed[Labeled[Style[Row[{"   ", Style[lang, Bold]}], FontFamily->"Open Sans Light", 24], WordCloud[Cases[SortBy[Tally[Flatten[Values[langData[lang][["tokens"]]]]], -Last[#]&], {x_/; (StringLength[x]>1&&StringMatchQ[x, RegularExpression["[a-zA-Z0-9.]+"]]&&Not[StringMatchQ[x, RegularExpression["[0-9.]+"]]]), y_/; y>nMin}], ImageSize->{1000, 500}, MaxItems->200, WordOrientation->{{-Pi/4, Pi/4}}, Background->GrayLevel[0.98]]], FrameStyle->None, Background->White]

 clouds=Grid[{Image[#, ImageSize->All]&@Rasterize[languagePopularTokens[#, 10]]}&/@{"Mathematica", "C", "Python", "Go", "JavaScript"}]

और अंत में, उनके टोकन की निकटता के आधार पर भाषाओं की एक बहुत ही दिलचस्प तुलना।

LangSimilarity फ़ंक्शन निम्नानुसार काम करता है: पहला, "सार्थक टोकन" चुने गए हैं (जिन्हें कम से कम 2 वर्णों की लंबाई वाले लैटिन वर्णों के सभी तार माना जाता है जिसमें एक अवधि शामिल हो सकती है); फिर टोकन भाषा लैंग 1 और लैंग 2 की एक जोड़ी के लिए खोजे जाते हैं; उसके बाद, उनके "समानता" के माप को माना जाता है, एक दूसरे के बीच टोकन की निकटता के लिए जिम्मेदार राशि द्वारा टोकन के दो सेटों के जैक्वार्ड के उत्पाद के रूप में (फार्म के तत्वों का योग)

f r a c w_{1} + w_{2} 1 + t e x t A b s l e f t [w_{1} - w_{2} r i g h t]

$\ frac {w_1 + w_2} {1+ \ text {Abs} \ left [w_1-w_2 \ right]}$ जहाँ

w_{1}, w_{2}

$w_1, w_2$ क्रमशः lang1 और lang2 भाषा समस्याओं के सभी समाधानों में टोकन दिखावे का योग है)।

 Clear[langSimilarity]; langSimilarity[{lang1_,lang2_},clearTokens_]:=langSimilarity@@(Sort[{lang1,lang2}]~Join~{clearTokens}); langSimilarity[lang1_,lang2_,clearTokens_:False]:=langSimilarity[lang1,lang2,clearTokens]=Module[{tokens,t1,t2,t1W,t2W,intersection}, tokens[lang_]:=Module[{values,tokensPre,allValues,replacements,n}, values=Values[langData[lang][["tokens"]]]; n=Length[values]; allValues=DeleteDuplicates[Flatten[values]]; tokensPre=If[clearTokens,Cases[allValues,x_/;(StringLength[x]>1&&StringMatchQ[x,RegularExpression["[a-zA-Z0-9._$]+"]]&&Not[StringMatchQ[x,RegularExpression["[0-9.,eE]+"]]])],allValues]; replacements=Dispatch@ Thread[Complement[allValues,tokensPre]->Nothing]; Cases[Tally@Flatten@(values/.replacements),{t_,x_/;x>=n/10}:>{t,x}]]; {t1,t2}=tokens/@{lang1,lang2}; {t1W,t2W}=Dispatch/@{Rule@@@t1,Rule@@@t2}; intersection=Intersection[t1[[;;,1]],t2[[;;,1]]]; Times@@{Total[(#[[1]]+#[[2]])/(1+Abs[#[[1]]-#[[2]]])&/@Transpose@N[{intersection/.t1W,intersection/.t2W}]],Length[intersection]/Length[Union[t1[[;;,1]],t2[[;;,1]]]]}]

 ClearAll[langSimilarityGrid]; langSimilarityGrid[n_Integer, OptionsPattern[{"SortQ" -> True, "measureFunction" -> Mean, "clearTokens" -> True}]] := Module[{$nPL, $pl, tableData, notSortedTableData, order, fullTableData, min, max, orderedMeans, median, rescale}, $nPL = n; $pl = $popularLanguages[$nPL][[;; , 1]]; tableData = Quiet@Table[ If[i == j, "", langSimilarity[{$pl[[i]], $pl[[j]]}, OptionValue["clearTokens"]]], {i, 1, $nPL}, {j, 1, $nPL}]; {min, max} = MinMax[Flatten[tableData] /. "" -> Nothing]; median = 10^Median@Log10@Flatten[tableData /. "" -> Nothing]; rescale = Function[Evaluate[Rescale[#, {median, max}, {0, 1}]]]; order = If[OptionValue["SortQ"], Ordering[tableData, All, OptionValue["measureFunction"][#1 /. "" -> Nothing] > OptionValue["measureFunction"][#2 /. "" -> Nothing] &], Range[1, $nPL]]; fullTableData = Transpose[{{""}~Join~$pl[[order]]}~Join~ Transpose[{Map[Rotate[#, 90 Degree] &, $pl]}~Join~ ReplaceAll[tableData[[order]], x_?NumericQ :> Item[Style[Round[x, 1], If[x < median, Black, White]], Background -> If[x < median, LightGray, ColorData["Rainbow"][rescale[x]]]]] /. "" -> Item["", Background -> Gray]]]; Framed[ Labeled[Style[ Row[{"      (  )", "\n", "(", Style[If[OptionValue["clearTokens"], "  ", "   "], Bold], ")"}], 22, FontFamily -> "Open Sans Light", TextAlignment -> Center], Grid[fullTableData, Background -> White, ItemStyle -> Directive[FontSize -> 12, FontFamily -> "Open Sans Light"], Dividers -> White]], FrameStyle -> None, Background -> White]];

UPD: एक मूल्यवान टिप्पणी के बाद, इकट्ठे दो तालिकाओं को बनाने का निर्णय लिया गया: परिणाम को कम से कम प्रभावित करने के लिए, किसी भी प्रकार की सफाई के बिना, साफ टोकन और सभी टोकन के साथ। परिणाम थोड़ा अलग है, जैसा कि आप अपने लिए देख सकते हैं, हालांकि कुछ निर्भरताएं स्पष्ट हो गई हैं।

यहाँ पर हमें जो मिलता है (अनरीड टेबल):

 langSimilarityGrid[30, "SortQ" -> False, "clearTokens" -> True] langSimilarityGrid[30, "SortQ" -> False, "clearTokens" -> False]

क्रमबद्ध तालिका (अन्य भाषाओं के साथ औसत समानता के संदर्भ में - उच्चतर रेखा, इस भाषा की अन्य प्रोग्रामिंग भाषाओं की संख्या जितनी अधिक होगी:

 langSimilarityGrid[30, "SortQ"->True, "clearTokens" -> True] langSimilarityGrid[30, "SortQ"->True, "clearTokens" -> False]

अंत में, लोकप्रियता में पहले 50 भाषाओं के लिए एक बड़ी तालिका।

यह उम्मीद की जाती है कि जावा, सी, सी ++, सी # जैसी "प्रमुख" भाषाएं शीर्ष पर हैं। रैकेट (पहले PLTScheme) था, जिसका एक उद्देश्य प्रोग्रामिंग भाषाओं का निर्माण, विकास और कार्यान्वयन है।

दिलचस्प बात यह है कि वुल्फराम भाषा अनिवार्य रूप से एक अलग भाषा है।

भाषाओं के बीच के लिंक भी दिखाई देते हैं, मान लें कि जावा और सी #, गो और सी, सी और जावा, हास्केल और जावा, कोटलिन और जावा, पायथन और फिक्स, पायथन और रैकेट के बीच की कड़ी और बहुत कुछ दिखाई देता है।

 langSimilarityGrid[50, "SortQ"->True, "clearTokens" -> True] langSimilarityGrid[50, "SortQ"->True, "clearTokens" -> False]

मुझे उम्मीद है कि यह अध्ययन आपके लिए दिलचस्प होगा और आप कुछ नया खोज सकेंगे। मेरे लिए, एक व्यक्ति के रूप में जो लगातार वुल्फराम भाषा का उपयोग करता है, यह जानकर अच्छा लगा कि यह एक ओर सबसे "कॉम्पैक्ट" भाषा है, दूसरी ओर, इसका उद्देश्य अन्य भाषाओं के लिए इसका "असमानता", जाहिर है, इसे थोड़ा और मुश्किल बना देता है।

वुल्फ्राम भाषा में कार्यक्रम कैसे सीखना चाहते हैं?
साप्ताहिक वेबिनार देखें ।
नए पाठ्यक्रमों के लिए पंजीकरण । ऑनलाइन कोर्स तैयार है।