public/subjects/go-reloaded.audit.en.md

Atoi

Try with the argument: ""

Does the function Atoi returns 0?•1

Try with the argument: "-"

Does the function Atoi returns 0?•1

Try with the argument: "+"

Does the function Atoi returns 0?•1

Try with the argument: "0"

Does the function Atoi returns 0?•1

Try with the argument: "+0"

Does the function Atoi returns 0?•1

Try with the argument: "-Invalid123"

*Does the function Atoi returns 0?•7389

Try with the argument: "--123"

Does the function Atoi returns 0?•1

Try with the argument: "1"

Does the function Atoi returns 1?•1

Try with the argument: "-3"

Does the function Atoi returns -3?•1

Try with the argument: "8292"

Does the function Atoi returns 8292?•1

Try with the argument: "9223372036854775807"

Does the function Atoi returns 9223372036854775807?•1

Try with the argument: "-9223372036854775808"

Does the function Atoi returns -9223372036854775808?•1

RecursivePower

Try with the arguments: nb = -7 and power = -2

Does the function returns 0?(1)

Try with the arguments: nb = -8 and power = -7

Does the function returns 0?(1)

Try with the arguments: nb = 4 and power = 8

Does the function returns 65536?(1)

Try with the arguments: nb = 1 and power = 3

Does the function returns 1?(1)

Try with the arguments: nb = -1 and power = 1

Does the function returns -1?(1)

Try with the arguments: nb = -6 and power = 5

Does the function returns -7776?(1)

Try with the arguments: nb = 0 and power = 9

Does the function returns 0?(1)

Try with the arguments: nb = -6 and power = 6

Does the function returns 46656?(1)

Try with the arguments: nb = -4 and power = -6

Does the function returns 0?(1)

Try with the arguments: nb = -7 and power = 5

Does the function returns -16807?(1)

Try with the arguments: nb = 5 and power = 7

Does the function returns 78125?(1)

Try with the arguments: nb = 0 and power = 0

Does the function returns 1?(1)

Try with the arguments: nb = 0 and power = 1

Does the function returns 0?(1)

PrintCombN

Try with the argument: n = 1

Does the function prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9?(1)

Try with the argument: n = 2

Does the function prints 01, 02, 03, 04, 05, 06, 07, 08, 09, 12, 13, 14, 15, 16, 17, 18, 19, 23, 24, 25, 26, 27, 28, 29, 34, 35, 36, 37, 38, 39, 45, 46, 47, 48, 49, 56, 57, 58, 59, 67, 68, 69, 78, 79, 89?(1)

Try with the argument: n = 3

Does the function prints 012, 013, 014, 015, 016, 017, 018, 019, 023, 024, 025, 026, 027, 028, 029, 034, 035, 036, 037, 038, 039, 045, 046, 047, 048, 049, 056, 057, 058, 059, 067, 068, 069, 078, 079, 089, 123, 124, 125, 126, 127, 128, 129, 134, 135, 136, 137, 138, 139, 145, 146, 147, 148, 149, 156, 157, 158, 159, 167, 168, 169, 178, 179, 189, 234, 235, 236, 237, 238, 239, 245, 246, 247, 248, 249, 256, 257, 258, 259, 267, 268, 269, 278, 279, 289, 345, 346, 347, 348, 349, 356, 357, 358, 359, 367, 368, 369, 378, 379, 389, 456, 457, 458, 459, 467, 468, 469, 478, 479, 489, 567, 568, 569, 578, 579, 589, 678, 679, 689, 789?(1)

Try with the argument: n = 4

Does the function prints 0123, 0124, 0125, 0126, 0127, 0128, 0129, 0134, 0135, 0136, 0137, 0138, 0139, 0145, 0146, 0147, 0148, 0149, 0156, 0157, 0158, 0159, 0167, 0168, 0169, 0178, 0179, 0189, 0234, 0235, 0236, 0237, 0238, 0239, 0245, 0246, 0247, 0248, 0249, 0256, 0257, 0258, 0259, 0267, 0268, 0269, 0278, 0279, 0289, 0345, 0346, 0347, 0348, 0349, 0356, 0357, 0358, 0359, 0367, 0368, 0369, 0378, 0379, 0389, 0456, 0457, 0458, 0459, 0467, 0468, 0469, 0478, 0479, 0489, 0567, 0568, 0569, 0578, 0579, 0589, 0678, 0679, 0689, 0789, 1234, 1235, 1236, 1237, 1238, 1239, 1245, 1246, 1247, 1248, 1249, 1256, 1257, 1258, 1259, 1267, 1268, 1269, 1278, 1279, 1289, 1345, 1346, 1347, 1348, 1349, 1356, 1357, 1358, 1359, 1367, 1368, 1369, 1378, 1379, 1389, 1456, 1457, 1458, 1459, 1467, 1468, 1469, 1478, 1479, 1489, 1567, 1568, 1569, 1578, 1579, 1589, 1678, 1679, 1689, 1789, 2345, 2346, 2347, 2348, 2349, 2356, 2357, 2358, 2359, 2367, 2368, 2369, 2378, 2379, 2389, 2456, 2457, 2458, 2459, 2467, 2468, 2469, 2478, 2479, 2489, 2567, 2568, 2569, 2578, 2579, 2589, 2678, 2679, 2689, 2789, 3456, 3457, 3458, 3459, 3467, 3468, 3469, 3478, 3479, 3489, 3567, 3568, 3569, 3578, 3579, 3589, 3678, 3679, 3689, 3789, 4567, 4568, 4569, 4578, 4579, 4589, 4678, 4679, 4689, 4789, 5678, 5679, 5689, 5789, 6789?(1)

Try with the argument: n = 5

Does the function prints 01234, 01235, 01236, 01237, 01238, 01239, 01245, 01246, 01247, 01248, 01249, 01256, 01257, 01258, 01259, 01267, 01268, 01269, 01278, 01279, 01289, 01345, 01346, 01347, 01348, 01349, 01356, 01357, 01358, 01359, 01367, 01368, 01369, 01378, 01379, 01389, 01456, 01457, 01458, 01459, 01467, 01468, 01469, 01478, 01479, 01489, 01567, 01568, 01569, 01578, 01579, 01589, 01678, 01679, 01689, 01789, 02345, 02346, 02347, 02348, 02349, 02356, 02357, 02358, 02359, 02367, 02368, 02369, 02378, 02379, 02389, 02456, 02457, 02458, 02459, 02467, 02468, 02469, 02478, 02479, 02489, 02567, 02568, 02569, 02578, 02579, 02589, 02678, 02679, 02689, 02789, 03456, 03457, 03458, 03459, 03467, 03468, 03469, 03478, 03479, 03489, 03567, 03568, 03569, 03578, 03579, 03589, 03678, 03679, 03689, 03789, 04567, 04568, 04569, 04578, 04579, 04589, 04678, 04679, 04689, 04789, 05678, 05679, 05689, 05789, 06789, 12345, 12346, 12347, 12348, 12349, 12356, 12357, 12358, 12359, 12367, 12368, 12369, 12378, 12379, 12389, 12456, 12457, 12458, 12459, 12467, 12468, 12469, 12478, 12479, 12489, 12567, 12568, 12569, 12578, 12579, 12589, 12678, 12679, 12689, 12789, 13456, 13457, 13458, 13459, 13467, 13468, 13469, 13478, 13479, 13489, 13567, 13568, 13569, 13578, 13579, 13589, 13678, 13679, 13689, 13789, 14567, 14568, 14569, 14578, 14579, 14589, 14678, 14679, 14689, 14789, 15678, 15679, 15689, 15789, 16789, 23456, 23457, 23458, 23459, 23467, 23468, 23469, 23478, 23479, 23489, 23567, 23568, 23569, 23578, 23579, 23589, 23678, 23679, 23689, 23789, 24567, 24568, 24569, 24578, 24579, 24589, 24678, 24679, 24689, 24789, 25678, 25679, 25689, 25789, 26789, 34567, 34568, 34569, 34578, 34579, 34589, 34678, 34679, 34689, 34789, 35678, 35679, 35689, 35789, 36789, 45678, 45679, 45689, 45789, 46789, 56789?(1)

Try with the argument: n = 6

Does the function prints 012345, 012346, 012347, 012348, 012349, 012356, 012357, 012358, 012359, 012367, 012368, 012369, 012378, 012379, 012389, 012456, 012457, 012458, 012459, 012467, 012468, 012469, 012478, 012479, 012489, 012567, 012568, 012569, 012578, 012579, 012589, 012678, 012679, 012689, 012789, 013456, 013457, 013458, 013459, 013467, 013468, 013469, 013478, 013479, 013489, 013567, 013568, 013569, 013578, 013579, 013589, 013678, 013679, 013689, 013789, 014567, 014568, 014569, 014578, 014579, 014589, 014678, 014679, 014689, 014789, 015678, 015679, 015689, 015789, 016789, 023456, 023457, 023458, 023459, 023467, 023468, 023469, 023478, 023479, 023489, 023567, 023568, 023569, 023578, 023579, 023589, 023678, 023679, 023689, 023789, 024567, 024568, 024569, 024578, 024579, 024589, 024678, 024679, 024689, 024789, 025678, 025679, 025689, 025789, 026789, 034567, 034568, 034569, 034578, 034579, 034589, 034678, 034679, 034689, 034789, 035678, 035679, 035689, 035789, 036789, 045678, 045679, 045689, 045789, 046789, 056789, 123456, 123457, 123458, 123459, 123467, 123468, 123469, 123478, 123479, 123489, 123567, 123568, 123569, 123578, 123579, 123589, 123678, 123679, 123689, 123789, 124567, 124568, 124569, 124578, 124579, 124589, 124678, 124679, 124689, 124789, 125678, 125679, 125689, 125789, 126789, 134567, 134568, 134569, 134578, 134579, 134589, 134678, 134679, 134689, 134789, 135678, 135679, 135689, 135789, 136789, 145678, 145679, 145689, 145789, 146789, 156789, 234567, 234568, 234569, 234578, 234579, 234589, 234678, 234679, 234689, 234789, 235678, 235679, 235689, 235789, 236789, 245678, 245679, 245689, 245789, 246789, 256789, 345678, 345679, 345689, 345789, 346789, 356789, 456789?(1)

Try with the argument: n = 7

Does the function prints 0123456, 0123457, 0123458, 0123459, 0123467, 0123468, 0123469, 0123478, 0123479, 0123489, 0123567, 0123568, 0123569, 0123578, 0123579, 0123589, 0123678, 0123679, 0123689, 0123789, 0124567, 0124568, 0124569, 0124578, 0124579, 0124589, 0124678, 0124679, 0124689, 0124789, 0125678, 0125679, 0125689, 0125789, 0126789, 0134567, 0134568, 0134569, 0134578, 0134579, 0134589, 0134678, 0134679, 0134689, 0134789, 0135678, 0135679, 0135689, 0135789, 0136789, 0145678, 0145679, 0145689, 0145789, 0146789, 0156789, 0234567, 0234568, 0234569, 0234578, 0234579, 0234589, 0234678, 0234679, 0234689, 0234789, 0235678, 0235679, 0235689, 0235789, 0236789, 0245678, 0245679, 0245689, 0245789, 0246789, 0256789, 0345678, 0345679, 0345689, 0345789, 0346789, 0356789, 0456789, 1234567, 1234568, 1234569, 1234578, 1234579, 1234589, 1234678, 1234679, 1234689, 1234789, 1235678, 1235679, 1235689, 1235789, 1236789, 1245678, 1245679, 1245689, 1245789, 1246789, 1256789, 1345678, 1345679, 1345689, 1345789, 1346789, 1356789, 1456789, 2345678, 2345679, 2345689, 2345789, 2346789, 2356789, 2456789, 3456789?(1)

Try with the argument: n = 8

Does the function prints 01234567, 01234568, 01234569, 01234578, 01234579, 01234589, 01234678, 01234679, 01234689, 01234789, 01235678, 01235679, 01235689, 01235789, 01236789, 01245678, 01245679, 01245689, 01245789, 01246789, 01256789, 01345678, 01345679, 01345689, 01345789, 01346789, 01356789, 01456789, 02345678, 02345679, 02345689, 02345789, 02346789, 02356789, 02456789, 03456789, 12345678, 12345679, 12345689, 12345789, 12346789, 12356789, 12456789, 13456789, 23456789?(1)

Try with the argument: n = 9

Does the function prints 012345678, 012345679, 012345689, 012345789, 012346789, 012356789, 012456789, 013456789, 023456789, 123456789?(1)

PrintNbrBase

Try with the argument: nbr = 919617 and base = 01

Does the function prints 11100000100001000001?(1)

Try with the argument: nbr = 753639 and base = CHOUMIisDAcat!

Does the function prints HIDAHI?(1)

Try with the argument: nbr = -174336 and base = CHOUMIisDAcat!

Does the function prints -MssiD?(1)

Try with the argument: nbr = -661165 and base = 1

Does the function prints NV?(1)

Try with the argument: nbr = -839376 and base = choumiChoumi

Does the function prints NV?(1)

Try with the argument: nbr = -861737 and base = Zone01Zone01

Does the function prints -1111101?(1)

Try with the argument: nbr = 125 and base = 0123456789ABCDEF

Does the function prints 7D?(1)

Try with the argument: nbr = -125 and base = choumi

Does the function prints -uoi?(1)

Try with the argument: nbr = 125 and base = -ab

Does the function prints NV?(1)

Try with the argument: nbr = -9223372036854775808 and base = 0123456789

Does the function prints -9223372036854775808?(1)

doop

Try with the arguments: 861 + 870

Does the program prints 1731(1)

Try with the arguments: 861 - 870

Does the program prints -9(1)

Try with the arguments: 861 * 870

Does the program prints 749070(1)

Try with the arguments: 861 / 870

Does the program prints 0(1)

Try with the arguments: 861 % 870

Try with the arguments: hello + 1

Does the program prints 0(1)

Try with the arguments: 1 p 1

Does the program prints 0(1)

Try with the arguments: 1 / 0

Does the program prints No division by 0(1)

Try with the arguments: 1 % 0

Does the program prints No remainder of division by 0(1)

Try with the arguments: 1 * 1

Does the program prints 1(1)

Try with the arguments: 2 arguments

Does the program prints ``(1)

Try with the arguments: 4 arguments so invalid

Does the program prints ``(1)

Try with the arguments: 9223372036854775807 + 1

Does the program prints 0(1)

Try with the arguments: 9223372036854775809 - 3

Does the program prints 0(1)

Try with the arguments: 9223372036854775807 * 3

Does the program prints 0(1)

Atoibase

Try with the arguments: s = bcbbbbaab and base = abc

Does the function returns 12016?(1)

Try with the arguments: s = 0001 and base = 01

Does the function returns 1?(1)

Try with the arguments: s = 00 and base = 01

Does the function returns 0?(1)

Try with the arguments: s = saDt!I!sI and base = CHOUMIisDAcat!

Does the function returns 11557277891?(1)

Try with the arguments: s = AAho?Ao and base = WhoAmI?

Does the function returns 406772?(1)

Try with the arguments: s = thisinputshouldnotmatter and base = abca

Does the function returns 0?(1)

Try with the arguments: s = 125 and base = 0123456789

Does the function returns 125?(1)

Try with the arguments: s = 1111101 and base = 01

Does the function returns 125?(1)

Try with the arguments: s = 7D and base = 0123456789ABCDEF

Does the function returns 125?(1)

Try with the arguments: s = uoi and base = choumi

Does the function returns 125?(1)

Try with the arguments: s = bbbbbab and base = -ab

Does the function returns 0?(1)

splitwhitespaces

Try with the argument: str = The earliest foundations of what would become computer science predate the invention of the modern digital computer

Does the function returns [The earliest foundations of what would become computer science predate the invention of the modern digital computer]?(1)

Try with the argument: str = Machines for calculating fixed numerical tasks such as the abacus have existed since antiquity,

Does the function returns [Machines for calculating fixed numerical tasks such as the abacus have existed since antiquity,]?(1)

Try with the argument: str = aiding in computations such as multiplication and division .

Does the function returns [aiding in computations such as multiplication and division .]?(1)

Try with the argument: str = Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment.

Does the function returns [Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment.]?(1)

Try with the argument: str = Wilhelm Schickard designed and constructed the first working mechanical calculator in 1623.[4]

Does the function returns [Wilhelm Schickard designed and constructed the first working mechanical calculator in 1623.[4]]?(1)

Try with the argument: str = In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator,

Does the function returns [In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator,]?(1)

Try with the argument: str = called the Stepped Reckoner.[5] He may be considered the first computer scientist and information theorist

Does the function returns [called the Stepped Reckoner.[5] He may be considered the first computer scientist and information theorist]?(1)

Try with the argument: str = , for, among other reasons

documenting the binary number system., Does the function returns [, for, among other reasons, documenting the binary number system.]?(1)

Try with the argument: str = In 1820, Thomas de Colmar launched the mechanical calculator industry[note 1] when he released his simplified arithmometer,

Does the function returns [In 1820, Thomas de Colmar launched the mechanical calculator industry[note 1] when he released his simplified arithmometer,]?(1)

Try with the argument: str = which was the first calculating machine strong enough and reliable enough to be used daily in an office environment.

Does the function returns [which was the first calculating machine strong enough and reliable enough to be used daily in an office environment.]?(1)

Try with the argument: str = Charles Babbage started the design of the first automatic mechanical calculator,

Does the function returns [Charles Babbage started the design of the first automatic mechanical calculator,]?(1)

Try with the argument: str = his Difference Engine, in 1822, which eventually gave him the idea of the first programmable mechanical calculator,

Does the function returns [his Difference Engine, in 1822, which eventually gave him the idea of the first programmable mechanical calculator,]?(1)

Try with the argument: str = his Analytical Engine.[6] He started developing this machine in 1834,

Does the function returns [his Analytical Engine.[6] He started developing this machine in 1834,]?(1)

Try with the argument: str = and "in less than two years,

Does the function returns [and "in less than two years,]?(1)

Try with the argument: str = he had sketched out many of the salient features of the modern computer".[7] "A crucial step was th

adoption of a punched card system derived from the Jacquard loom"[7] making it infinitely programmable.[note 2] In 1843,, Does the function returns [he had sketched out many of the salient features of the modern computer".[7] "A crucial step was the adoption of a punched card system derived from the Jacquard loom"[7] making it infinitely programmable.[note 2] In 1843,]?(1)

Try with the argument: str = during the translation of a French article on the Analytical Engine,

Does the function returns [during the translation of a French article on the Analytical Engine,]?(1)

Try with the argument: str = Ada Lovelace wrote,

Does the function returns [Ada Lovelace wrote,]?(1)

Try with the argument: str = in one of the many notes she included,

Does the function returns [in one of the many notes she included,]?(1)

Try with the argument: str = an algorithm to compute the Bernoulli numbers,

Does the function returns [an algorithm to compute the Bernoulli numbers,]?(1)

Try with the argument: str = which is considered to be the first published algorithm ever specifically tailored for implementation on a computer.[8] Around 1885,

Does the function returns [which is considered to be the first published algorithm ever specifically tailored for implementation on a computer.[8] Around 1885,]?(1)

Try with the argument: str = Herman Hollerith invented the tabulator,

Does the function returns [Herman Hollerith invented the tabulator,]?(1)

Try with the argument: str = which used punched cards to process statistical information; eventually his company became part of IBM. Following Babbage,

Does the function returns [which used punched cards to process statistical information; eventually his company became part of IBM. Following Babbage,]?(1)

Try with the argument: str = although unaware of his earlier work,

Does the function returns [although unaware of his earlier work,]?(1)

Try with the argument: str = Percy Ludgate in 1909 published [9] the 2nd of the only two designs for mechanical analytical engines in history. In 1937,

Does the function returns [Percy Ludgate in 1909 published [9] the 2nd of the only two designs for mechanical analytical engines in history. In 1937,]?(1)

Try with the argument: str = one hundred years after Babbage's impossible dream,

Does the function returns [one hundred years after Babbage's impossible dream,]?(1)

Try with the argument: str = Howard Aiken convinced IBM,

Does the function returns [Howard Aiken convinced IBM,]?(1)

Try with the argument: str = which was making all kinds of punched card equipment and was also in the calculator business[10] to develop his giant programmable calculator,

Does the function returns [which was making all kinds of punched card equipment and was also in the calculator business[10] to develop his giant programmable calculator,]?(1)

Try with the argument: str = the ASCC/Harvard Mark I,

Does the function returns [the ASCC/Harvard Mark I,]?(1)

Try with the argument: str = based on Babbage's Analytical Engine,

Does the function returns [based on Babbage's Analytical Engine,]?(1)

Try with the argument: str = which itself used cards and a central computing unit. When the machine was finished,

Does the function returns [which itself used cards and a central computing unit. When the machine was finished,]?(1)

Try with the argument: str = some hailed it as "Babbage's dream come true".[11]

Does the function returns [some hailed it as "Babbage's dream come true".[11]]?(1)

Try with the argument: str = During the 1940s,

Does the function returns [During the 1940s,]?(1)

Try with the argument: str = as new and more powerful computing machines such as the Atanasoff-Berry computer and ENIAC were developed,

Does the function returns [as new and more powerful computing machines such as the Atanasoff-Berry computer and ENIAC were developed,]?(1)

Try with the argument: str = the term computer came to refer to the machines rather than their human predecessors.[12] As it became clear that computers could be used for more than just mathematical calculations,

Does the function returns [the term computer came to refer to the machines rather than their human predecessors.[12] As it became clear that computers could be used for more than just mathematical calculations,]?(1)

Try with the argument: str = the field of computer science broadened to study computation in general. In 1945,

Does the function returns [the field of computer science broadened to study computation in general. In 1945,]?(1)

Try with the argument: str = IBM founded the Watson Scientific Computing Laboratory at Columbia University in New York City. The renovated fraternity house on Manhattan's West Side was IBM's first laboratory devoted to pure science.

Does the function returns [IBM founded the Watson Scientific Computing Laboratory at Columbia University in New York City. The renovated fraternity house on Manhattan's West Side was IBM's first laboratory devoted to pure science.]?(1)

Try with the argument: str = Hello how are you?

Does the function returns [Hello how are you?]?(1)

split

Try with the arguments: str = |=choumi=|which|=choumi=|itself|=choumi=|used|=choumi=|cards|=choumi=|and|=choumi=|a|=choumi=|central|=choumi=|computing|=choumi=|unit.|=choumi=|When|=choumi=|the|=choumi=|machine|=choumi=|was|=choumi=|finished, and charset = |=choumi=|

Does the function returns [ which itself used cards and a central computing unit. When the machine was finished,]?(1)

Try with the arguments: str = !==!which!==!was!==!making!==!all!==!kinds!==!of!==!punched!==!card!==!equipment!==!and!==!was!==!also!==!in!==!the!==!calculator!==!business[10]!==!to!==!develop!==!his!==!giant!==!programmable!==!calculator, and charset = !==!

Does the function returns [ which was making all kinds of punched card equipment and was also in the calculator business[10] to develop his giant programmable calculator,]?(1)

Try with the arguments: str = AFJCharlesAFJBabbageAFJstartedAFJtheAFJdesignAFJofAFJtheAFJfirstAFJautomaticAFJmechanicalAFJcalculator, and charset = AFJ

Does the function returns [ Charles Babbage started the design of the first automatic mechanical calculator,]?(1)

Try with the arguments: str = |=choumi=|Ada|=choumi=|Lovelace|=choumi=|wrote, and charset = |=choumi=|

Does the function returns [ Ada Lovelace wrote,]?(1)

Try with the arguments: str = !==!the!==!term!==!computer!==!came!==!to!==!refer!==!to!==!the!==!machines!==!rather!==!than!==!their!==!human!==!predecessors.[12]!==!As!==!it!==!became!==!clear!==!that!==!computers!==!could!==!be!==!used!==!for!==!more!==!than!==!just!==!mathematical!==!calculations, and charset = !==!

Does the function returns [ the term computer came to refer to the machines rather than their human predecessors.[12] As it became clear that computers could be used for more than just mathematical calculations,]?(1)

Try with the arguments: str = <<==123==>>In<<==123==>>1820,<<==123==>>Thomas<<==123==>>de<<==123==>>Colmar<<==123==>>launched<<==123==>>the<<==123==>>mechanical<<==123==>>calculator<<==123==>>industry[note<<==123==>>1]<<==123==>>when<<==123==>>he<<==123==>>released<<==123==>>his<<==123==>>simplified<<==123==>>arithmometer, and charset = <<==123==>>

Does the function returns [ In 1820, Thomas de Colmar launched the mechanical calculator industry[note 1] when he released his simplified arithmometer,]?(1)

Try with the arguments: str = The!==!earliest!==!foundations!==!of!==!what!==!would!==!become!==!computer!==!science!==!predate!==!the!==!invention!==!of!==!the!==!modern!==!digital!==!computer and charset = !==!

Does the function returns [The earliest foundations of what would become computer science predate the invention of the modern digital computer]?(1)

Try with the arguments: str = !==!the!==!field!==!of!==!computer!==!science!==!broadened!==!to!==!study!==!computation!==!in!==!general.!==!In!==!1945, and charset = !==!

Does the function returns [ the field of computer science broadened to study computation in general. In 1945,]?(1)

Try with the arguments: str = !==!which!==!is!==!considered!==!to!==!be!==!the!==!first!==!published!==!algorithm!==!ever!==!specifically!==!tailored!==!for!==!implementation!==!on!==!a!==!computer.[8]!==!Around!==!1885, and charset = !==!

Does the function returns [ which is considered to be the first published algorithm ever specifically tailored for implementation on a computer.[8] Around 1885,]?(1)

Try with the arguments: str = !=HA=!which!=HA=!is!=HA=!considered!=HA=!to!=HA=!be!=HA=!the!=HA=!first!=HA=!published!=HA=!algorithm!=HA=!ever!=HA=!specifically!=HA=!tailored!=HA=!for!=HA=!implementation!=HA=!on!=HA=!a!=HA=!computer.[8]!=HA=!Around!=HA=!1885, and charset = !=HA=!

Does the function returns [ which is considered to be the first published algorithm ever specifically tailored for implementation on a computer.[8] Around 1885,]?(1)

Try with the arguments: str = based on Babbage's Analytical Engine, and charset =

Does the function returns [ based on Babbage's Analytical Engine,]?(1)

Try with the arguments: str = [<>abc<>]his[<>abc<>]Analytical[<>abc<>]Engine.[6][<>abc<>]He[<>abc<>]started[<>abc<>]developing[<>abc<>]this[<>abc<>]machine[<>abc<>]in[<>abc<>]1834, and charset = [<>abc<>]

Does the function returns [ his Analytical Engine.[6] He started developing this machine in 1834,]?(1)

Try with the arguments: str = During<<==123==>>the<<==123==>>1940s, and charset = <<==123==>>

Does the function returns [During the 1940s,]?(1)

Try with the arguments: str = HelloHAhowHAareHAyou? and charset = HA

Does the function returns [Hello how are you?]?(1)

convertbase

Try with the arguments: nbr = "10010001000011010000", baseFrom = "01" and baseTo = "0123456789ABCDEF"

Does the function returns "910D0"?(1)

Try with the arguments: nbr = "4CDC", baseFrom = "0123456789ABCDEF" and baseTo = "WhoAmI?"

Does the function returns "hhhoA?"?(1)

Try with the arguments: nbr = "o1nonZ0e", baseFrom = "Zone01" and baseTo = "Zone01"

Does the function returns "o1nonZ0e"?(1)

Try with the arguments: nbr = "719462", baseFrom = "0123456789" and baseTo = "choumi"

Does the function returns "ououcico"?(1)

Try with the arguments: nbr = "ococcuho", baseFrom = "choumi" and baseTo = "choumi"

Does the function returns "ococcuho"?(1)

Try with the arguments: nbr = "382230", baseFrom = "0123456789" and baseTo = "abc"

Does the function returns "cabbacacccaa"?(1)

Try with the arguments: nbr = "2CE0C", baseFrom = "0123456789ABCDEF" and baseTo = "choumi"

Does the function returns "uiuiccm"?(1)

Try with the arguments: nbr = "uhcoccm", baseFrom = "choumi" and baseTo = "0123456789"

Does the function returns "148180"?(1)

Try with the arguments: nbr = "IhoWo?I", baseFrom = "WhoAmI?" and baseTo = "abc"

Does the function returns "babaccccacbca"?(1)

Try with the arguments: nbr = "bababbabaabcb", baseFrom = "abc" and baseTo = "WhoAmI?"

Does the function returns "IWmmImA"?(1)

Try with the arguments: nbr = "263798", baseFrom = "0123456789" and baseTo = "CHOUMIisDAcat!"

Does the function returns "itHtc"?(1)

Try with the arguments: nbr = "oo01eZeo", baseFrom = "Zone01" and baseTo = "0123456789"

Does the function returns "364843"?(1)

Try with the arguments: nbr = "43F9C", baseFrom = "0123456789ABCDEF" and baseTo = "0123456789ABCDEF"

Does the function returns "43F9C"?(1)

Try with the arguments: nbr = "hWmhoIII", baseFrom = "WhoAmI?" and baseTo = "abc"

Does the function returns "bcaabacbbcbac"?(1)

Try with the arguments: nbr = "10001110111000110000", baseFrom = "01" and baseTo = "0123456789ABCDEF"

Does the function returns "8EE30"?(1)

Try with the arguments: nbr = "hmuhomuo", baseFrom = "choumi" and baseTo = "abc"

Does the function returns "ccacccbcbaac"?(1)

Try with the arguments: nbr = "HtCODc", baseFrom = "CHOUMIisDAcat!" and baseTo = "choumi"

Does the function returns "uuoucuhc"?(1)

Try with the arguments: nbr = "uhhicomi", baseFrom = "choumi" and baseTo = "01"

Does the function returns "11011011111011010101"?(1)

Try with the arguments: nbr = "mAIIo?o", baseFrom = "WhoAmI?" and baseTo = "CHOUMIisDAcat!"

Does the function returns "!tt!A"?(1)

Try with the arguments: nbr = "cbbcaaccbbcc", baseFrom = "abc" and baseTo = "WhoAmI?"

Does the function returns "AImWIho"?(1)

Try with the arguments: nbr = "113431", baseFrom = "0123456789" and baseTo = "01"

Does the function returns "11011101100010111"?(1)

Try with the arguments: nbr = "10111011101001010000", baseFrom = "01" and baseTo = "Zone01"

Does the function returns "n0n1Zo00"?(1)

Try with the arguments: nbr = "I?WImII", baseFrom = "WhoAmI?" and baseTo = "choumi"

Does the function returns "oomihhuc"?(1)

Try with the arguments: nbr = "babaabbbaccaa", baseFrom = "abc" and baseTo = "01"

Does the function returns "10010000111100111001"?(1)

Try with the arguments: nbr = "ooumiocm", baseFrom = "choumi" and baseTo = "choumi"

Does the function returns "ooumiocm"?(1)

Try with the arguments: nbr = "cacaabaabcc", baseFrom = "abc" and baseTo = "abc"

Does the function returns "cacaabaabcc"?(1)

Try with the arguments: nbr = "imouhho", baseFrom = "choumi" and baseTo = "CHOUMIisDAcat!"

Does the function returns "i!sAO"?(1)

Try with the arguments: nbr = "cabaccaaaacb", baseFrom = "abc" and baseTo = "abc"

Does the function returns "cabaccaaaacb"?(1)

Try with the arguments: nbr = "5FF2C", baseFrom = "0123456789ABCDEF" and baseTo = "CHOUMIisDAcat!"

Does the function returns "cUUHc"?(1)

Try with the arguments: nbr = "ccbcbcabcacc", baseFrom = "abc" and baseTo = "0123456789ABCDEF"

Does the function returns "7C439"?(1)

Try with the arguments: nbr = "101011", baseFrom = "01" and baseTo = "0123456789"

Does the function returns "43"?(1)

rotatevowels

Try the program without any arguments

Does the program displays a new line?(1)

Try executing the program passing as argument: "Hello World"

Does the program return: Hollo Werld(1)

Try executing the program passing as arguments: "HEllO World" "problem solved"

Does the program return: Hello Werld problom sOlvEd(1)

Try executing the program passing as argument: "str" "shh" "psst"

Does the program return: str shh psst(1)

Try executing the program passing as argument: "happy thoughts" "good luck"

Does the program return: happy thoughts good luck(1)

Try executing the program passing as argument: "al's elEphAnt is overly underweight!"

Does the program return: (1)

Try executing the program passing as arguments: Machines for calculating fixed numerical tasks such as the abacus

Does the program return: Muchanas fer calculatang fixed numericil tasks such as tho ebicas(1)

Try executing the program passing as arguments: have existed since antiquity, aiding in computations such as multiplication and division

Does the program return: hovi ixistad sonci antiqiuty, audong in camputotiins sich as miltuplicatein end divesean(1)

Try executing the program passing as arguments: Algorithms for performing computations have existed since antiquity, even before the development of sophisticated computing equipment

Does the program return: elgiruthms fer pirfurmong cempatitions hove oxested sence onteqeety, ivun bifare thi devilepment af sophistacutod cimpoteng oqiopmAnt(1)

Try executing the program passing as arguments: Wilhelm Schickard designed and constructed the first working mechanical calculator in 1623. In 1673, Gottfried Leibniz demonstrated a digital mechanical calculator, called the Stepped Reckoner

Does the program return: Welholm Scheckerd desegned and constractud tha farst wirkang mechanicil calcelator en 1623i in 1673, Gettfreid LoIbn.z dimonstratud a dagital mechinocil celcelutor, called thi Steppad Rickenir(1)

Try executing the program passing as arguments: A crucial step was th

adoption of a punched card system derived from the Jacquard loom, Does the program return: o crocaul stap wes tho edipteen af e punchad cord systom dirovad frem tha Jecqaird luAm(1)

Try executing the program passing as arguments: making it infinitely programmable

Does the program return: mekang at onfenitily prigrimmibla(1)

advancedsortwordarr

Try with the arguments array = [X3RvpTTOo b1 RR bTVi iO 3 5Be2id5AY G a t9J4 NP mJoJM ci97 r W 4 WcVVBJc K 9pkpByJ Ebbia 4ox8TWUD inv q3 jPYp7g av HQ O0 Ncmg z 3WLJcrbLB7LoY lVce8L XWgMsw MkOITgWoS SFv] and f = strings.Compare

Does the function returns [ 4 WcVVBJc K HQ O0 Ncmg z 3WLJcrbLB7LoY 4ox8TWUD inv 5Be2id5AY G a 9pkpByJ Ebbia MkOITgWoS SFv RR bTVi iO 3 X3RvpTTOo b1 ci97 r W lVce8L XWgMsw q3 jPYp7g av t9J4 NP mJoJM]?(1)

Try with the arguments array = [g qRLGp OsCIK SwMSZHN oKqiZ PMorGlQ dPx3F GA6oRAyLtQZ6 aL0JonQwm BZ9 DfUL Dw1 DgDz H ew V kDqyA 8hN i eR 8n 6 tQa9geTu jbO1 qIhPYu ws Tq 54k

O5 E 1p bE PNnGhcR CKLLpKer bQmH] and f = strings.Compare, Does the function returns [ 54kMdO5 E 1p GA6oRAyLtQZ6 H ew V kDqyA bE PNnGhcR 8hN i eR 8n 6 CKLLpKer bQmH DfUL Dw1 DgDz PMorGlQ dPx3F SwMSZHN oKqiZ aL0JonQwm BZ9 g qRLGp OsCIK qIhPYu ws Tq tQa9geTu jbO1]?(1)

Try with the arguments array = [SqIY alP ap s Tk8pzkNob T E 2VL7j RwSiBO CFYtXOF7 Zom7 He K BIPFjx66 1aSM KmGUikVO P CeC2Jzf24zS RYt8vbzmwRJVO lJKAxZ20mN Nq Lgec4HOsQ8ZOl 6ZExl3cG4f09 og7ny HmWg K u H7pHDcClDLo] and f = strings.Compare

Does the function returns [ 2VL7j RwSiBO 6ZExl3cG4f09 1aSM KmGUikVO CFYtXOF7 Zom7 He K BIPFjx66 Lgec4HOsQ8ZOl P CeC2Jzf24zS RYt8vbzmwRJVO SqIY alP ap s Tk8pzkNob T E lJKAxZ20mN Nq og7ny HmWg K u H7pHDcClDLo]?(1)

Try with the arguments array = [8UW WGOHl8IE M RZg2Q5h56Tw yUL sCa 4 mcc TA buEFbpWwNL N5p8tO Z w9H P6 WE6fu kO4O e7 RaOu8rt4o B 71u bY H2 KM5 kQlRASJ J mlBG25F 1j g5EOm5is PUOv yV q91Utk2wZu H KFCSi fYe21] and f = strings.Compare

Does the function returns [ B 71u bY H2 J mlBG25F 1j N5p8tO Z w9H e7 RaOu8rt4o 8UW WGOHl8IE H KFCSi fYe21 KM5 kQlRASJ M RZg2Q5h56Tw P6 WE6fu kO4O TA buEFbpWwNL g5EOm5is PUOv yUL sCa 4 mcc yV q91Utk2wZu]?(1)

Try with the arguments array = [e2r r C8 cJ3 P0K4ol6K Wh obR s0lcvL MA 0 0kEpG leAg3 c6TtKUylSrbcy Ub1SC rq8 EFQ vy eDI D Q0h 8DYlXruE5 w4 0nY TWgHUo pi8y 7QJbwLq HJ46 Ub2 SwfL KU zIBYD WLqY 1zoXnSzLqCk ] and f = strings.Compare

Does the function returns [ P0K4ol6K Wh 1zoXnSzLqCk vy eDI D 0 0kEpG leAg3 HJ46 Ub2 SwfL KU zIBYD WLqY Q0h 8DYlXruE5 Ub1SC rq8 EFQ c6TtKUylSrbcy e2r r C8 cJ3 obR s0lcvL MA pi8y 7QJbwLq w4 0nY TWgHUo]?(1)

Try with the arguments array = [O tdDm A 9 zw uZi 1hHS 2ev7 68FNINIM7VsIs RQCn2Z 9fM M RGT8HxuzYyFJ vMV k gW IzV nkg Lz 377 J AlOX UC4N g a2gf Xgedrm V Zf LE7ioIY v Y Qmr E9 y w AfiVc U WLE1q Ql5L GV B 1yN] and f = strings.Compare

Does the function returns [ Zf LE7ioIY v nkg Lz 377 J 68FNINIM7VsIs AfiVc U WLE1q AlOX UC4N g O tdDm A 9 zw Ql5L GV B 1yN RGT8HxuzYyFJ RQCn2Z 9fM M Y Qmr E9 y w a2gf Xgedrm V uZi 1hHS 2ev7 vMV k gW IzV ]?(1)

Try with the arguments array = [moR204BPzl KV fa7 c1L24GvzH 1k 7YkJ fH 9 xjuhd 9j ROB XPzQO0m7VT6 U 5xLLFf6iZ6g Y 8N47Ua5smTEBI g Fr2y 02Z69 nwLLsXaIPyX ehZwMPr ldCJW c jppnyON Swt O K cmzuLl51 C0 69 tlj Gw] and f = strings.Compare

Does the function returns [ 1k 7YkJ fH 9 5xLLFf6iZ6g Y 8N47Ua5smTEBI C0 69 tlj Gw O K cmzuLl51 XPzQO0m7VT6 U c jppnyON Swt ehZwMPr ldCJW fa7 c1L24GvzH g Fr2y 02Z69 moR204BPzl KV nwLLsXaIPyX xjuhd 9j ROB ]?(1)

Try with the arguments array = [Cv0u3 xEHGgG G CeI3ww 6G F PLWa ep knV l sz st 0ky L hepxt94 askC9 wBhrOuV7 WLq JF V rTVgoW VH g iDXg0Hte h lhLCE1646cy PIY19 keOxx c hiv fmdZ 6uS Ez0h X Sxa n k Y1k oNXq7v ] and f = strings.Compare

Does the function returns [ JF V rTVgoW PLWa ep knV wBhrOuV7 WLq Cv0u3 xEHGgG Ez0h X Sxa n G CeI3ww 6G F PIY19 keOxx c VH g iDXg0Hte h lhLCE1646cy hepxt94 askC9 hiv fmdZ 6uS k Y1k oNXq7v l sz st 0ky L]?(1)

Try with the arguments array = [lt2F NtJBoq JqM 5PZyjnilj SrgfDt smbGxq eYi7 3IfGN6E c JP RqgfL rj 1o 6JxUbFqpv clvTZBsVfP7S 3QGjbeV fi5DA JIsy08xGGE6PD 9XxlAR1Q AW w6XlLVwXo140 C8l0HoVqE5Mw rfmWV w rA0M] and f = strings.Compare

Does the function returns [ 9XxlAR1Q AW C8l0HoVqE5Mw clvTZBsVfP7S 1o 6JxUbFqpv 3QGjbeV fi5DA JIsy08xGGE6PD JqM 5PZyjnilj SrgfDt smbGxq c JP RqgfL rj eYi7 3IfGN6E lt2F NtJBoq rfmWV w rA0M w6XlLVwXo140 ]?(1)

Try with the arguments array = [ lH4kZUt25Nya N IHSGEi6 rFw U4 M5eO 1 zj YLs swu0F0Ji 4 J aA9d9Z no yh 3eRs zEv GryWrm TMQ 3B d aAoR ngZ V 17 t 8bSreZg M bSMZYYtcNwX C P bElYbtRy hu HyZkA bHQ uDzAxn Z 2V] and f = strings.Compare

Does the function returns [ 17 t 8bSreZg lH4kZUt25Nya 4 J aA9d9Z no C P bElYbtRy GryWrm TMQ 3B M bSMZYYtcNwX N IHSGEi6 rFw U4 M5eO 1 zj YLs swu0F0Ji d aAoR ngZ V hu HyZkA bHQ uDzAxn Z 2V yh 3eRs zEv]?(1)

Try with the arguments array = [a A 1 b B 2 c C 3] and f = strings.Compare

Does the function returns [1 2 3 A B C a b c]?(1)

Try with the arguments array = [ 4 WcVVBJc K HQ O0 Ncmg z 3WLJcrbLB7LoY 4ox8TWUD inv 5Be2id5AY G a 9pkpByJ Ebbia MkOITgWoS SFv RR bTVi iO 3 X3RvpTTOo b1 ci97 r W lVce8L XWgMsw q3 jPYp7g av t9J4 NP mJoJM] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [t9J4 NP mJoJM q3 jPYp7g av lVce8L XWgMsw ci97 r W X3RvpTTOo b1 RR bTVi iO 3 MkOITgWoS SFv 9pkpByJ Ebbia 5Be2id5AY G a 4ox8TWUD inv 3WLJcrbLB7LoY HQ O0 Ncmg z 4 WcVVBJc K]?(1)

Try with the arguments array = [ 54k

####### O5 E 1p GA6oRAyLtQZ6 H ew V kDqyA bE PNnGhcR 8hN i eR 8n 6 CKLLpKer bQmH DfUL Dw1 DgDz PMorGlQ dPx3F SwMSZHN oKqiZ aL0JonQwm BZ9 g qRLGp OsCIK qIhPYu ws Tq tQa9geTu jbO1] and f = func(a, b string) int {(1) return strings.Compare(b, a) },

Does the function returns [tQa9geTu jbO1 qIhPYu ws Tq g qRLGp OsCIK aL0JonQwm BZ9 SwMSZHN oKqiZ PMorGlQ dPx3F DfUL Dw1 DgDz CKLLpKer bQmH 8hN i eR 8n 6 bE PNnGhcR H ew V kDqyA GA6oRAyLtQZ6 54kMdO5 E 1p]?(1)

Try with the arguments array = [ 2VL7j RwSiBO 6ZExl3cG4f09 1aSM KmGUikVO CFYtXOF7 Zom7 He K BIPFjx66 Lgec4HOsQ8ZOl P CeC2Jzf24zS RYt8vbzmwRJVO SqIY alP ap s Tk8pzkNob T E lJKAxZ20mN Nq og7ny HmWg K u H7pHDcClDLo] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [u H7pHDcClDLo og7ny HmWg K lJKAxZ20mN Nq Tk8pzkNob T E SqIY alP ap s RYt8vbzmwRJVO P CeC2Jzf24zS Lgec4HOsQ8ZOl He K BIPFjx66 CFYtXOF7 Zom7 1aSM KmGUikVO 6ZExl3cG4f09 2VL7j RwSiBO]?(1)

Try with the arguments array = [ B 71u bY H2 J mlBG25F 1j N5p8tO Z w9H e7 RaOu8rt4o 8UW WGOHl8IE H KFCSi fYe21 KM5 kQlRASJ M RZg2Q5h56Tw P6 WE6fu kO4O TA buEFbpWwNL g5EOm5is PUOv yUL sCa 4 mcc yV q91Utk2wZu] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [yV q91Utk2wZu yUL sCa 4 mcc g5EOm5is PUOv TA buEFbpWwNL P6 WE6fu kO4O M RZg2Q5h56Tw KM5 kQlRASJ H KFCSi fYe21 8UW WGOHl8IE e7 RaOu8rt4o N5p8tO Z w9H J mlBG25F 1j B 71u bY H2]?(1)

Try with the arguments array = [ P0K4ol6K Wh 1zoXnSzLqCk vy eDI D 0 0kEpG leAg3 HJ46 Ub2 SwfL KU zIBYD WLqY Q0h 8DYlXruE5 Ub1SC rq8 EFQ c6TtKUylSrbcy e2r r C8 cJ3 obR s0lcvL MA pi8y 7QJbwLq w4 0nY TWgHUo] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [w4 0nY TWgHUo pi8y 7QJbwLq obR s0lcvL MA e2r r C8 cJ3 c6TtKUylSrbcy Ub1SC rq8 EFQ Q0h 8DYlXruE5 KU zIBYD WLqY HJ46 Ub2 SwfL 0 0kEpG leAg3 vy eDI D 1zoXnSzLqCk P0K4ol6K Wh]?(1)

Try with the arguments array = [ Zf LE7ioIY v nkg Lz 377 J 68FNINIM7VsIs AfiVc U WLE1q AlOX UC4N g O tdDm A 9 zw Ql5L GV B 1yN RGT8HxuzYyFJ RQCn2Z 9fM M Y Qmr E9 y w a2gf Xgedrm V uZi 1hHS 2ev7 vMV k gW IzV ] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [vMV k gW IzV uZi 1hHS 2ev7 a2gf Xgedrm V Y Qmr E9 y w RQCn2Z 9fM M RGT8HxuzYyFJ Ql5L GV B 1yN O tdDm A 9 zw AlOX UC4N g AfiVc U WLE1q 68FNINIM7VsIs nkg Lz 377 J Zf LE7ioIY v]?(1)

Try with the arguments array = [ 1k 7YkJ fH 9 5xLLFf6iZ6g Y 8N47Ua5smTEBI C0 69 tlj Gw O K cmzuLl51 XPzQO0m7VT6 U c jppnyON Swt ehZwMPr ldCJW fa7 c1L24GvzH g Fr2y 02Z69 moR204BPzl KV nwLLsXaIPyX xjuhd 9j ROB ] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [xjuhd 9j ROB nwLLsXaIPyX moR204BPzl KV g Fr2y 02Z69 fa7 c1L24GvzH ehZwMPr ldCJW c jppnyON Swt XPzQO0m7VT6 U O K cmzuLl51 C0 69 tlj Gw 8N47Ua5smTEBI 5xLLFf6iZ6g Y 1k 7YkJ fH 9]?(1)

Try with the arguments array = [ JF V rTVgoW PLWa ep knV wBhrOuV7 WLq Cv0u3 xEHGgG Ez0h X Sxa n G CeI3ww 6G F PIY19 keOxx c VH g iDXg0Hte h lhLCE1646cy hepxt94 askC9 hiv fmdZ 6uS k Y1k oNXq7v l sz st 0ky L] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [l sz st 0ky L k Y1k oNXq7v hiv fmdZ 6uS hepxt94 askC9 h lhLCE1646cy VH g iDXg0Hte PIY19 keOxx c G CeI3ww 6G F Ez0h X Sxa n Cv0u3 xEHGgG wBhrOuV7 WLq PLWa ep knV JF V rTVgoW]?(1)

Try with the arguments array = [ 9XxlAR1Q AW C8l0HoVqE5Mw clvTZBsVfP7S 1o 6JxUbFqpv 3QGjbeV fi5DA JIsy08xGGE6PD JqM 5PZyjnilj SrgfDt smbGxq c JP RqgfL rj eYi7 3IfGN6E lt2F NtJBoq rfmWV w rA0M w6XlLVwXo140 ] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [w6XlLVwXo140 rfmWV w rA0M lt2F NtJBoq eYi7 3IfGN6E c JP RqgfL rj SrgfDt smbGxq JqM 5PZyjnilj JIsy08xGGE6PD 3QGjbeV fi5DA 1o 6JxUbFqpv clvTZBsVfP7S C8l0HoVqE5Mw 9XxlAR1Q AW]?(1)

Try with the arguments array = [ 17 t 8bSreZg lH4kZUt25Nya 4 J aA9d9Z no C P bElYbtRy GryWrm TMQ 3B M bSMZYYtcNwX N IHSGEi6 rFw U4 M5eO 1 zj YLs swu0F0Ji d aAoR ngZ V hu HyZkA bHQ uDzAxn Z 2V yh 3eRs zEv] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [yh 3eRs zEv uDzAxn Z 2V hu HyZkA bHQ d aAoR ngZ V YLs swu0F0Ji U4 M5eO 1 zj N IHSGEi6 rFw M bSMZYYtcNwX GryWrm TMQ 3B C P bElYbtRy 4 J aA9d9Z no lH4kZUt25Nya 17 t 8bSreZg]?(1)

Try with the arguments array = [1 2 3 A B C a b c] and f = func(a, b string) int {

	 return strings.Compare(b, a)
}

Does the function returns [c b a C B A 3 2 1]?(1)

cat

Run the program without arguments:

write: Hello

Does the program return: Hello(1)

write: jaflsdfj

Does the program return: jaflsdfj(1)

write: Computer science (sometimes called computation science or computing science

Does the program return: Computer science (sometimes called computation science or computing science(1)

Run the program passing the file: quest8.txt as an argument of execution of the program (as shown in the subject)

Does the the program displays the same output as in the readme?(1)

Run the program with the file: quest8T.txt

Does the program displays the content of the file?(1)

Run the program with the files: quest8T.txt and quest8.txt in that order

Does the program displays the content of the file in order?(1)

Run the program with a diferent file and then run the system program cat with the same file.

Are the outputs identical?(1)

Run both this program and the system program cat passing as an argument a random string that is not the name of a file

Are the outputs identical?(1)

ztail

Run both ztail and the system command tail with the following arguments. Substitute for the name of a file

-c 20

-c 23

-c jelrjq 15

-c 11 jfdklsa

11 -c

Are the outputs exactly the same?(1)

activebits

Try with the argument: n = 15

Does the function returns 4?(1)

Try with the argument: n = 17

Does the function returns 2?(1)

Try with the argument: n = 17

Does the function returns 2?(1)

Try with the argument: n = 4

Does the function returns 1?(1)

Try with the argument: n = 11

Does the function returns 3?(1)

Try with the argument: n = 9

Does the function returns 2?(1)

Try with the argument: n = 12

Does the function returns 2?(1)

Try with the argument: n = 11

Does the function returns 3?(1)

Try with the argument: n = 2

Does the function returns 1?(1)

Try with the argument: n = 8

Does the function returns 1?(1)

Try with the argument: n = 15

Does the function returns 4?(1)

Try with the argument: n = 17

Does the function returns 2?(1)

Try with the argument: n = 10

Does the function returns 2?(1)

Try with the argument: n = 11

Does the function returns 3?(1)

Try with the argument: n = 16

Does the function returns 1?(1)

Try with the argument: n = 12

Does the function returns 2?(1)

Try with the argument: n = 20

Does the function returns 2?(1)

Try with the argument: n = 19

Does the function returns 3?(1)

Try with the argument: n = 18

Does the function returns 2?(1)

Try with the argument: n = 4

Does the function returns 1?(1)

Try with the argument: n = 8

Does the function returns 1?(1)

sortlistinsert

Try with the arguments: l = 0-> and data_ref = 39

Does the function returns (0-> 39-> )?(1)

Try with the arguments: l = 0-> 1-> 2-> 3-> 4-> 5-> 24-> 25-> 54-> and data_ref = 33

Does the function returns (0-> 1-> 2-> 3-> 4-> 5-> 24-> 25-> 33-> 54-> )?(1)

Try with the arguments: l = 0-> 2-> 18-> 33-> 37-> 37-> 39-> 52-> 53-> 57-> and data_ref = 53

Does the function returns (0-> 2-> 18-> 33-> 37-> 37-> 39-> 52-> 53-> 53-> 57-> )?(1)

Try with the arguments: l = 0-> 5-> 18-> 24-> 28-> 35-> 42-> 45-> 52-> and data_ref = 52

Does the function returns (0-> 5-> 18-> 24-> 28-> 35-> 42-> 45-> 52-> 52-> )?(1)

Try with the arguments: l = 0-> 12-> 20-> 23-> 23-> 24-> 30-> 41-> 53-> 57-> 59-> and data_ref = 38

Does the function returns (0-> 12-> 20-> 23-> 23-> 24-> 30-> 38-> 41-> 53-> 57-> 59-> )?(1)

Try with the arguments: l = 0-> 4-> 11-> 15-> 19-> 22-> 23-> 56-> 58-> and data_ref = 29

Does the function returns (0-> 4-> 11-> 15-> 19-> 22-> 23-> 29-> 56-> 58-> )?(1)

Try with the arguments: l = 0-> 18-> 23-> 25-> 33-> 34-> 35-> 37-> 40-> 57-> and data_ref = 47

Does the function returns (0-> 18-> 23-> 25-> 33-> 34-> 35-> 37-> 40-> 47-> 57-> )?(1)

Try with the arguments: l = 0-> 7-> 14-> 17-> 18-> 24-> 28-> 34-> 34-> 37-> 42-> 46-> 49-> and data_ref = 3

Does the function returns (0-> 3-> 7-> 14-> 17-> 18-> 24-> 28-> 34-> 34-> 37-> 42-> 46-> 49-> )?(1)

sortedlistmerge

Try with the arguments: n1 = and n2 =

Does the function returns ()?(1)

Try with the arguments: n1 = and n2 = 2-> 2-> 4-> 9-> 12-> 12-> 19-> 20->

Does the function returns (2-> 2-> 4-> 9-> 12-> 12-> 19-> 20-> )?(1)

Try with the arguments: n1 = 4-> 4-> 6-> 9-> 13-> 18-> 20-> 20-> and n2 =

Does the function returns (4-> 4-> 6-> 9-> 13-> 18-> 20-> 20-> )?(1)

Try with the arguments: n1 = 0-> 7-> 39-> 92-> 97-> 93-> 91-> 28-> 64-> and n2 = 80-> 23-> 27-> 30-> 85-> 81-> 75-> 70->

Does the function returns (0-> 7-> 39-> 80-> 23-> 27-> 30-> 85-> 81-> 75-> 70-> 92-> 97-> 93-> 91-> 28-> 64-> )?(1)

Try with the arguments: n1 =0-> 2-> 11-> 30-> 54-> 56-> 70-> 79-> 99-> and n2 = 23-> 28-> 38-> 67-> 67-> 79-> 95-> 97->

Does the function returns (0-> 2-> 11-> 23-> 28-> 30-> 38-> 54-> 56-> 67-> 67-> 70-> 79-> 79-> 95-> 97-> 99-> )?(1)

Try with the arguments: n1 = 0-> 3-> 8-> 8-> 13-> 19-> 34-> 38-> 46-> and n2 = 7-> 39-> 45-> 53-> 59-> 70-> 76-> 79->

Does the function returns (0-> 3-> 7-> 8-> 8-> 13-> 19-> 34-> 38-> 39-> 45-> 46-> 53-> 59-> 70-> 76-> 79-> )?(1)

listremoveif

Try with the arguments: l = and data_ref = 1

Does the function returns ()?

Try with the arguments: l = and and data_ref = 96

Does the function returns ()?

y with the arguments: l = 98-> 98-> 33-> 34-> 33-> 34-> 33-> 89-> 33-> and and data_ref = 34, Does the function returns (98-> 98-> 33-> 33-> 33-> 89-> 33-> )? y with the arguments: l = 79-> 74-> 99-> 79-> 7-> and and data_ref = 99, Does the function returns (79-> 74-> 79-> 7-> )? y with the arguments: l = 56-> 93-> 68-> 56-> 87-> 68-> 56-> 68-> and and data_ref = 68, Does the function returns (56-> 93-> 56-> 87-> 56-> )? y with the arguments: l = mvkUxbqhQve4l-> 4Zc4t hnf SQ-> q2If E8BPuX -> and and data_ref = 4Zc4t hnf SQ, Does the function returns (mvkUxbqhQve4l-> q2If E8BPuX -> )? y with the arguments: l = hello1-> hello2-> hello-> hello3-> and and data_ref = hello, Does the function returns (hello1-> hello2-> hello3-> )? ry with the arguments: l = fZfX1 r G9hG-> VRcbreYo4cM -> and and data_ref = VRcbreYo4cM ,

Does the function returns (fZfX1 r G9hG-> )?

btreetransplant

Try with the arguments: root =

01 └── 07 ├── 12 │ └── 10 └── 05 └── 02 └── 03 , node = 12 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

01 └── 07 ├── 55 │ ├── 60 │ └── 33 │ └── 12 │ └── 15 └── 05 └── 02 └── 03 ?

Try with the arguments: root =

33 ├── 5 │ └── 52 └── 20 ├── 31 └── 13 └── 11 , node = 20 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

33 ├── 5 │ └── 52 └── 55 ├── 60 └── 33 └── 12 └── 15 ?

Try with the arguments: root =

03 └── 39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 , node = 11 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

03 └── 39 ├── 99 │ └── 44 └── 55 ├── 60 └── 33 └── 12 └── 15 ?

Try with the arguments: root =

03 ├── 03 │ └── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 , node = 19 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

03 ├── 03 │ └── 94 │ └── 55 │ ├── 60 │ └── 33 │ └── 12 │ └── 15 └── 01 ?

Try with the arguments: root =

02 ├── 03 │ └── 92 │ └── 19 │ ├── 22 │ └── 111 └── 01 , node = 92 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

02 ├── 03 │ └── 55 │ ├── 60 │ └── 33 │ └── 12 │ └── 15 └── 01 ?

Try with the arguments: root =

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 21 , node = 21 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 55 ├── 60 └── 33 └── 12 └── 15 ?

Try with the arguments: root =

02 └── 03 └── 06 └── 09 └── 83 └── 28 └── 24 , node = 06 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

02 └── 03 └── 55 ├── 60 └── 33 └── 12 └── 15 ?

Try with the arguments: root =

06 ├── 07 │ └── 09 │ └── 83 │ └── 68 │ └── 64 └── 01 , node = 06 and repla = 55 ├── 60 └── 33 └── 12 └── 15

Does the function returns(1)

55 ├── 60 └── 33 └── 12 └── 15 ?

btreeapplybylevel

Try with the argument: root =

01 └── 07 ├── 12 │ └── 10 └── 05 └── 02 └── 03 and f = fmt.Println

Does the function prints: 01(1)

07 05 12 02 10 03

Try with the argument: root =

01 └── 07 ├── 12 │ └── 10 └── 05 └── 02 └── 03 and f = fmt.Print

Does the function prints: 01070512021003(1)

Try with the argument: root =

01 └── 07 ├── 12 │ └── 10 └── 05 └── 02 └── 03 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [01],[07],[05],[12],[02],[10],[03],(1)

Try with the argument: root =

33 ├── 5 │ └── 52 └── 20 ├── 31 └── 13 └── 11 and f = fmt.Println

Does the function prints: 33(1)

20 5 13 31 52 11

Try with the argument: root =

33 ├── 5 │ └── 52 └── 20 ├── 31 └── 13 └── 11 and f = fmt.Print

Does the function prints: 3320513315211(1)

Try with the argument: root =

33 ├── 5 │ └── 52 └── 20 ├── 31 └── 13 └── 11 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [33],[20],[5],[13],[31],[52],[11],(1)

Try with the argument: root =

03 └── 39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 and f = fmt.Println

Does the function prints: 03(1)

39 11 99 14 44 11

Try with the argument: root =

03 └── 39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 and f = fmt.Print

Does the function prints: 03391199144411(1)

Try with the argument: root =

03 └── 39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [03],[39],[11],[99],[14],[44],[11],(1)

Try with the argument: root =

03 ├── 03 │ └── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 and f = fmt.Println

Does the function prints: 03(1)

01 03 94 19 111 24

Try with the argument: root =

03 ├── 03 │ └── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 and f = fmt.Print

Does the function prints: 030103941911124(1)

Try with the argument: root =

03 ├── 03 │ └── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [03],[01],[03],[94],[19],[111],[24],(1)

Try with the argument: root =

02 ├── 03 │ └── 92 │ └── 19 │ ├── 22 │ └── 111 └── 01 and f = fmt.Println

Does the function prints: 02(1)

01 03 92 19 111 22

Try with the argument: root =

02 ├── 03 │ └── 92 │ └── 19 │ ├── 22 │ └── 111 └── 01 and f = fmt.Print

Does the function prints: 020103921911122(1)

Try with the argument: root =

02 ├── 03 │ └── 92 │ └── 19 │ ├── 22 │ └── 111 └── 01 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [02],[01],[03],[92],[19],[111],[22],(1)

Try with the argument: root =

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 21 and f = fmt.Println

Does the function prints: 00(1)

02 04 53 23 66 21

Try with the argument: root =

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 21 and f = fmt.Print

Does the function prints: 00020453236621(1)

Try with the argument: root =

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 21 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [00],[02],[04],[53],[23],[66],[21],(1)

Try with the argument: root =

02 └── 03 └── 06 └── 09 └── 83 └── 28 └── 24 and f = fmt.Println

Does the function prints: 02(1)

03 06 09 83 28 24

Try with the argument: root =

02 └── 03 └── 06 └── 09 └── 83 └── 28 └── 24 and f = fmt.Print

Does the function prints: 02030609832824(1)

Try with the argument: root =

02 └── 03 └── 06 └── 09 └── 83 └── 28 └── 24 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [02],[03],[06],[09],[83],[28],[24],(1)

Try with the argument: root =

06 ├── 07 │ └── 09 │ └── 83 │ └── 68 │ └── 64 └── 01 and f = fmt.Println

Does the function prints: 06(1)

01 07 09 83 68 64

Try with the argument: root =

06 ├── 07 │ └── 09 │ └── 83 │ └── 68 │ └── 64 └── 01 and f = fmt.Print

Does the function prints: 06010709836864(1)

Try with the argument: root =

06 ├── 07 │ └── 09 │ └── 83 │ └── 68 │ └── 64 └── 01 and f = f := func(a ...interface{}) (int, error) { return fmt.Printf("%v,", a) }

Does the function prints: [06],[01],[07],[09],[83],[68],[64],(1)

btreedeletenode

Try with the argument: root =

01 └── 07 ├── 12 │ └── 10 └── 05 └── 02 └── 03 and node = 02

Does the function returns(1)

01 └── 07 ├── 12 │ └── 10 └── 05 └── 03 ?

Try with the argument: root =

33 ├── 5 │ └── 52 └── 20 ├── 31 └── 13 └── 11 and node = 20

Does the function returns(1)

33 ├── 5 │ └── 52 └── 31 └── 13 └── 11 ?

Try with the argument: root =

03 └── 39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 and node = 03

Does the function returns(1)

39 ├── 99 │ └── 44 └── 11 └── 14 └── 11 ?

Try with the argument: root =

03 ├── 03 │ └── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 and node = 03

Does the function returns(1)

03 ├── 94 │ └── 19 │ ├── 24 │ └── 111 └── 01 ?

Try with the argument: root =

02 ├── 03 │ └── 92 │ └── 19 │ ├── 22 │ └── 111 └── 01 and node = 01

Does the function returns(1)

02 └── 03 └── 92 └── 19 ├── 22 └── 111 ?

Try with the argument: root =

00 └── 02 └── 04 └── 53 ├── 66 └── 23 └── 21 and node = 00

Does the function returns(1)

02 └── 04 └── 53 ├── 66 └── 23 └── 21 ?

Try with the argument: root =

02 └── 03 └── 06 └── 09 └── 83 └── 28 └── 24 and node = 03

Does the function returns(1)

02 └── 06 └── 09 └── 83 └── 28 └── 24 ?

Try with the argument: root =

06 ├── 07 │ └── 09 │ └── 83 │ └── 68 │ └── 64 └── 01 and node = 09

Does the function returns(1)

06 ├── 07 │ └── 83 │ └── 68 │ └── 64 └── 01 ?